2007-12-17 Eric Seidel <eric@webkit.org>
[WebKit-https.git] / JavaScriptCore / kjs / nodes.h
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
5  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
6  *  Copyright (C) 2007 Maks Orlovich
7  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
8  *
9  *  This library is free software; you can redistribute it and/or
10  *  modify it under the terms of the GNU Library General Public
11  *  License as published by the Free Software Foundation; either
12  *  version 2 of the License, or (at your option) any later version.
13  *
14  *  This library is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *  Library General Public License for more details.
18  *
19  *  You should have received a copy of the GNU Library General Public License
20  *  along with this library; see the file COPYING.LIB.  If not, write to
21  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  *  Boston, MA 02110-1301, USA.
23  *
24  */
25
26 #ifndef NODES_H_
27 #define NODES_H_
28
29 #include "internal.h"
30 #include "regexp.h"
31 #include "SymbolTable.h"
32 #include <wtf/ListRefPtr.h>
33 #include <wtf/OwnPtr.h>
34 #include <wtf/Vector.h>
35
36 #if PLATFORM(X86) && COMPILER(GCC)
37 #define KJS_FAST_CALL __attribute__((regparm(3)))
38 #else
39 #define KJS_FAST_CALL
40 #endif
41
42 #if COMPILER(GCC)
43 #define KJS_NO_INLINE __attribute__((noinline))
44 #else
45 #define KJS_NO_INLINE
46 #endif
47
48 namespace KJS {
49
50     class FuncDeclNode;
51     class Node;
52     class PropertyListNode;
53     class SourceStream;
54     class VarDeclNode;
55
56     enum Operator {
57         OpEqual,
58         OpPlusEq,
59         OpMinusEq,
60         OpMultEq,
61         OpDivEq,
62         OpPlusPlus,
63         OpMinusMinus,
64         OpAndEq,
65         OpXOrEq,
66         OpOrEq,
67         OpModEq,
68         OpLShift,
69         OpRShift,
70         OpURShift,
71     };
72
73     enum Precedence {
74         PrecPrimary,
75         PrecMember,
76         PrecCall,
77         PrecLeftHandSide,
78         PrecPostfix,
79         PrecUnary,
80         PrecMultiplicitave,
81         PrecAdditive,
82         PrecShift,
83         PrecRelational,
84         PrecEquality,
85         PrecBitwiseAnd,
86         PrecBitwiseXor,
87         PrecBitwiseOr,
88         PrecLogicalAnd,
89         PrecLogicalOr,
90         PrecConditional,
91         PrecAssignment,
92         PrecExpression
93     };
94   
95   struct DeclarationStacks {
96       typedef Vector<Node*, 16> NodeStack;
97       typedef Vector<VarDeclNode*, 16> VarStack;
98       typedef Vector<FuncDeclNode*, 16> FunctionStack;
99       
100       DeclarationStacks(ExecState* e, NodeStack& n, VarStack& v, FunctionStack& f)
101         : exec(e)
102         , nodeStack(n)
103         , varStack(v)
104         , functionStack(f)
105       {
106       }
107
108       ExecState* exec;
109       NodeStack& nodeStack;
110       VarStack& varStack; 
111       FunctionStack& functionStack;
112   };
113
114   class ParserRefCounted : Noncopyable {
115   protected:
116     ParserRefCounted() KJS_FAST_CALL;
117     ParserRefCounted(PlacementNewAdoptType) KJS_FAST_CALL { }
118     
119   public:
120     void ref() KJS_FAST_CALL;
121     void deref() KJS_FAST_CALL;
122     unsigned refcount() KJS_FAST_CALL;
123     
124     static void deleteNewObjects() KJS_FAST_CALL;
125   
126     virtual ~ParserRefCounted();
127   };
128
129   class Node : public ParserRefCounted {
130   public:
131     Node() KJS_FAST_CALL;
132     Node(PlacementNewAdoptType placementAdopt) KJS_FAST_CALL
133     : ParserRefCounted(placementAdopt) { }
134
135     UString toString() const KJS_FAST_CALL;
136     int lineNo() const KJS_FAST_CALL { return m_line; }
137
138     // Serialization.
139     virtual void streamTo(SourceStream&) const KJS_FAST_CALL = 0;
140     virtual Precedence precedence() const = 0;
141     
142     // Used for iterative, depth-first traversal of the node tree. Does not cross function call boundaries.
143     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL { }
144
145   protected:
146     Node(JSType) KJS_FAST_CALL; // used by ExpressionNode
147
148     // for use in execute()
149     JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL;
150     JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL;
151
152     // for use in evaluate()
153     JSValue* throwError(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL;
154     JSValue* throwError(ExecState*, ErrorType, const char* msg, const char*) KJS_FAST_CALL;
155     JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*) KJS_FAST_CALL;
156     JSValue* throwError(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL;
157     JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, const Identifier&) KJS_FAST_CALL;
158     JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*, Node*) KJS_FAST_CALL;
159     JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*, const Identifier&) KJS_FAST_CALL;
160
161     JSValue* throwUndefinedVariableError(ExecState*, const Identifier&) KJS_FAST_CALL;
162
163     void handleException(ExecState*) KJS_FAST_CALL;
164     void handleException(ExecState*, JSValue*) KJS_FAST_CALL;
165
166     // for use in execute()
167     JSValue* rethrowException(ExecState*) KJS_FAST_CALL;
168
169     int m_line : 28;
170     unsigned m_expectedReturnType : 3; // JSType
171   };
172     
173     class ExpressionNode : public Node {
174     public:
175         ExpressionNode() KJS_FAST_CALL : Node() {}
176         ExpressionNode(JSType expectedReturn) KJS_FAST_CALL
177             : Node(expectedReturn) {}
178         
179         // Special constructor for cases where we overwrite an object in place.
180         ExpressionNode(PlacementNewAdoptType) KJS_FAST_CALL
181             : Node(PlacementNewAdopt) {}
182         
183         virtual bool isNumber() const KJS_FAST_CALL { return false; }
184         virtual bool isLocation() const KJS_FAST_CALL { return false; }
185         virtual bool isResolveNode() const KJS_FAST_CALL { return false; }
186         virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return false; }
187         virtual bool isDotAccessorNode() const KJS_FAST_CALL { return false; }
188         
189         JSType expectedReturnType() const KJS_FAST_CALL { return static_cast<JSType>(m_expectedReturnType); }
190         
191         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL = 0;
192         virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
193         virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
194         virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
195         virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
196
197         // Used to optimize those nodes that do extra work when returning a result, even if the result has no semantic relevance
198         virtual void optimizeForUnnecessaryResult() { }
199    };
200
201   class StatementNode : public Node {
202   public:
203     StatementNode() KJS_FAST_CALL;
204     void setLoc(int line0, int line1) KJS_FAST_CALL;
205     int firstLine() const KJS_FAST_CALL { return lineNo(); }
206     int lastLine() const KJS_FAST_CALL { return m_lastLine; }
207     virtual JSValue* execute(ExecState *exec) KJS_FAST_CALL = 0;
208     void pushLabel(const Identifier &id) KJS_FAST_CALL { ls.push(id); }
209     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
210   protected:
211     bool hitStatement(ExecState*) KJS_FAST_CALL;
212     LabelStack ls;
213   private:
214     int m_lastLine;
215   };
216
217   class NullNode : public ExpressionNode {
218   public:
219     NullNode() KJS_FAST_CALL : ExpressionNode(NullType) {}
220     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
221     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
222     virtual Precedence precedence() const { return PrecPrimary; }
223   };
224
225   class FalseNode : public ExpressionNode {
226   public:
227     FalseNode() KJS_FAST_CALL : ExpressionNode(BooleanType) {}
228     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
229     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL { return false; }
230     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
231     virtual Precedence precedence() const { return PrecPrimary; }
232   };
233
234   class TrueNode : public ExpressionNode {
235   public:
236     TrueNode() KJS_FAST_CALL : ExpressionNode(BooleanType) {}
237     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
238     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL { return true; }
239     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
240     virtual Precedence precedence() const { return PrecPrimary; }
241   };
242
243   class NumberNode : public ExpressionNode {
244   public:
245     NumberNode(double v) KJS_FAST_CALL : ExpressionNode(NumberType), m_double(v) {}
246     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
247     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
248     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
249     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
250     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
251     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
252     virtual Precedence precedence() const { return PrecPrimary; }
253
254     virtual bool isNumber() const KJS_FAST_CALL { return true; }
255     double value() const KJS_FAST_CALL { return m_double; }
256     virtual void setValue(double d) KJS_FAST_CALL { m_double = d; }
257
258   protected:
259     double m_double;
260   };
261   
262   class ImmediateNumberNode : public NumberNode {
263   public:
264       ImmediateNumberNode(JSValue* v, double d) KJS_FAST_CALL : NumberNode(d), m_value(v) { ASSERT(v == JSImmediate::from(d)); }
265       virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
266       virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
267       virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
268       
269       virtual void setValue(double d) KJS_FAST_CALL { m_double = d; m_value = JSImmediate::from(d); ASSERT(m_value); }
270   private:
271       JSValue* m_value; // This is never a JSCell, only JSImmediate, thus no ProtectedPtr
272   };
273
274   class StringNode : public ExpressionNode {
275   public:
276     StringNode(const UString* v) KJS_FAST_CALL : ExpressionNode(StringType), m_value(*v) {}
277     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
278     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
279     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
280     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
281     virtual Precedence precedence() const { return PrecPrimary; }
282
283   private:
284     UString m_value;
285   };
286
287   class RegExpNode : public ExpressionNode {
288   public:
289     RegExpNode(const UString& pattern, const UString& flags) KJS_FAST_CALL 
290         : m_regExp(new RegExp(pattern, flags))
291     {
292     }
293     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
294     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
295     virtual Precedence precedence() const { return PrecPrimary; }
296   private:
297     RefPtr<RegExp> m_regExp;
298   };
299
300   class ThisNode : public ExpressionNode {
301   public:
302     ThisNode() KJS_FAST_CALL {}
303     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
304     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
305     virtual Precedence precedence() const { return PrecPrimary; }
306  };
307
308   class ResolveNode : public ExpressionNode {
309   public:
310     ResolveNode(const Identifier &s) KJS_FAST_CALL 
311         : ident(s) 
312     { 
313     }
314
315     // Special constructor for cases where we overwrite an object in place.
316     ResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
317         : ExpressionNode(PlacementNewAdopt)
318         , ident(PlacementNewAdopt)
319     {
320     }
321
322     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
323
324     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
325     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
326     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
327     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
328     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
329     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
330     virtual Precedence precedence() const { return PrecPrimary; }
331
332     virtual bool isLocation() const KJS_FAST_CALL { return true; }
333     virtual bool isResolveNode() const KJS_FAST_CALL { return true; }
334     const Identifier& identifier() const KJS_FAST_CALL { return ident; }
335
336   protected:
337     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
338     Identifier ident;
339     size_t index; // Used by LocalVarAccessNode.
340   };
341
342   class LocalVarAccessNode : public ResolveNode {
343   public:
344     // Overwrites a ResolveNode in place.
345     LocalVarAccessNode(size_t i) KJS_FAST_CALL
346         : ResolveNode(PlacementNewAdopt)
347     {
348         ASSERT(i != missingSymbolMarker());
349         index = i;
350     }
351     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
352     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
353     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
354     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
355     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
356   private:
357     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
358   };
359
360   class ElementNode : public Node {
361   public:
362     ElementNode(int e, ExpressionNode* n) KJS_FAST_CALL : elision(e), node(n) { }
363     ElementNode(ElementNode* l, int e, ExpressionNode* n) KJS_FAST_CALL
364       : elision(e), node(n) { l->next = this; }
365     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
366     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
367     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
368
369     PassRefPtr<ElementNode> releaseNext() KJS_FAST_CALL { return next.release(); }
370
371     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
372
373   private:
374     friend class ArrayNode;
375     ListRefPtr<ElementNode> next;
376     int elision;
377     RefPtr<ExpressionNode> node;
378   };
379
380   class ArrayNode : public ExpressionNode {
381   public:
382     ArrayNode(int e) KJS_FAST_CALL : elision(e), opt(true) { }
383     ArrayNode(ElementNode* ele) KJS_FAST_CALL
384       : element(ele), elision(0), opt(false) { }
385     ArrayNode(int eli, ElementNode* ele) KJS_FAST_CALL
386       : element(ele), elision(eli), opt(true) { }
387     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
388     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
389     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
390     virtual Precedence precedence() const { return PrecPrimary; }
391   private:
392     RefPtr<ElementNode> element;
393     int elision;
394     bool opt;
395   };
396
397   class PropertyNode : public Node {
398   public:
399     enum Type { Constant, Getter, Setter };
400     PropertyNode(const Identifier& n, ExpressionNode* a, Type t) KJS_FAST_CALL
401       : m_name(n), assign(a), type(t) { }
402     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
403     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
404     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
405
406     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
407     const Identifier& name() const { return m_name; }
408
409   private:
410     friend class PropertyListNode;
411     Identifier m_name;
412     RefPtr<ExpressionNode> assign;
413     Type type;
414   };
415   
416   class PropertyListNode : public Node {
417   public:
418     PropertyListNode(PropertyNode* n) KJS_FAST_CALL
419       : node(n) { }
420     PropertyListNode(PropertyNode* n, PropertyListNode* l) KJS_FAST_CALL
421       : node(n) { l->next = this; }
422     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
423     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
424     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
425
426     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
427     PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return next.release(); }
428
429   private:
430     friend class ObjectLiteralNode;
431     RefPtr<PropertyNode> node;
432     ListRefPtr<PropertyListNode> next;
433   };
434
435   class ObjectLiteralNode : public ExpressionNode {
436   public:
437     ObjectLiteralNode() KJS_FAST_CALL { }
438     ObjectLiteralNode(PropertyListNode* l) KJS_FAST_CALL : list(l) { }
439     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
440     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
441     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
442     virtual Precedence precedence() const { return PrecPrimary; }
443   private:
444     RefPtr<PropertyListNode> list;
445   };
446
447   class BracketAccessorNode : public ExpressionNode {
448   public:
449     BracketAccessorNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL : expr1(e1), expr2(e2) {}
450     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
451     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
452     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
453     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
454     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
455     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
456     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
457     virtual Precedence precedence() const { return PrecMember; }
458
459     virtual bool isLocation() const KJS_FAST_CALL { return true; }
460     virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return true; }
461     ExpressionNode* base() KJS_FAST_CALL { return expr1.get(); }
462     ExpressionNode* subscript() KJS_FAST_CALL { return expr2.get(); }
463
464   private:
465     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
466     RefPtr<ExpressionNode> expr1;
467     RefPtr<ExpressionNode> expr2;
468   };
469
470   class DotAccessorNode : public ExpressionNode {
471   public:
472     DotAccessorNode(ExpressionNode* e, const Identifier& s) KJS_FAST_CALL : expr(e), ident(s) { }
473     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
474     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
475     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
476     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
477     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
478     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
479     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
480     virtual Precedence precedence() const { return PrecMember; }
481
482     virtual bool isLocation() const KJS_FAST_CALL { return true; }
483     virtual bool isDotAccessorNode() const KJS_FAST_CALL { return true; }
484     ExpressionNode* base() const KJS_FAST_CALL { return expr.get(); }
485     const Identifier& identifier() const KJS_FAST_CALL { return ident; }
486
487   private:
488     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
489     RefPtr<ExpressionNode> expr;
490     Identifier ident;
491   };
492
493   class ArgumentListNode : public Node {
494   public:
495     ArgumentListNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
496     ArgumentListNode(ArgumentListNode* l, ExpressionNode* e) KJS_FAST_CALL 
497       : expr(e) { l->next = this; }
498     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
499     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
500     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
501
502     void evaluateList(ExecState*, List&) KJS_FAST_CALL;
503     PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return next.release(); }
504
505   private:
506     friend class ArgumentsNode;
507     ListRefPtr<ArgumentListNode> next;
508     RefPtr<ExpressionNode> expr;
509   };
510
511   class ArgumentsNode : public Node {
512   public:
513     ArgumentsNode() KJS_FAST_CALL { }
514     ArgumentsNode(ArgumentListNode* l) KJS_FAST_CALL
515       : listNode(l) { }
516     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
517     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
518     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
519
520     void evaluateList(ExecState* exec, List& list) KJS_FAST_CALL { if (listNode) listNode->evaluateList(exec, list); }
521
522   private:
523     RefPtr<ArgumentListNode> listNode;
524   };
525
526   class NewExprNode : public ExpressionNode {
527   public:
528     NewExprNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
529     NewExprNode(ExpressionNode* e, ArgumentsNode* a) KJS_FAST_CALL : expr(e), args(a) {}
530     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
531     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
532     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
533     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
534     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
535     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
536     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
537     virtual Precedence precedence() const { return PrecLeftHandSide; }
538   private:
539     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
540     RefPtr<ExpressionNode> expr;
541     RefPtr<ArgumentsNode> args;
542   };
543
544   class FunctionCallValueNode : public ExpressionNode {
545   public:
546     FunctionCallValueNode(ExpressionNode* e, ArgumentsNode* a) KJS_FAST_CALL : expr(e), args(a) {}
547     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
548     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
549     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
550     virtual Precedence precedence() const { return PrecCall; }
551   private:
552     RefPtr<ExpressionNode> expr;
553     RefPtr<ArgumentsNode> args;
554   };
555
556   class FunctionCallResolveNode : public ExpressionNode {
557   public:
558     FunctionCallResolveNode(const Identifier& i, ArgumentsNode* a) KJS_FAST_CALL
559         : ident(i)
560         , args(a)
561     {
562     }
563
564     FunctionCallResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
565         : ExpressionNode(PlacementNewAdopt)
566         , ident(PlacementNewAdopt)
567         , args(PlacementNewAdopt)
568     {
569     }
570
571     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
572     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
573     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
574     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
575     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
576     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
577     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
578     virtual Precedence precedence() const { return PrecCall; }
579
580   protected:
581     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
582     Identifier ident;
583     RefPtr<ArgumentsNode> args;
584     size_t index; // Used by LocalVarFunctionCallNode.
585   };
586
587   class LocalVarFunctionCallNode : public FunctionCallResolveNode {
588   public:
589     LocalVarFunctionCallNode(size_t i) KJS_FAST_CALL
590         : FunctionCallResolveNode(PlacementNewAdopt)
591     {
592         ASSERT(i != missingSymbolMarker());
593         index = i;
594     }
595
596     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
597     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
598     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
599     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
600     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
601   private:
602     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
603   };
604
605   class FunctionCallBracketNode : public ExpressionNode {
606   public:
607     FunctionCallBracketNode(ExpressionNode* b, ExpressionNode* s, ArgumentsNode* a) KJS_FAST_CALL : base(b), subscript(s), args(a) {}
608     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
609     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
610     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
611     virtual Precedence precedence() const { return PrecCall; }
612   protected:
613     RefPtr<ExpressionNode> base;
614     RefPtr<ExpressionNode> subscript;
615     RefPtr<ArgumentsNode> args;
616   };
617
618   class FunctionCallDotNode : public ExpressionNode {
619   public:
620     FunctionCallDotNode(ExpressionNode* b, const Identifier& i, ArgumentsNode* a) KJS_FAST_CALL : base(b), ident(i), args(a) {}
621     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
622     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
623     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
624     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
625     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
626     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
627     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
628     virtual Precedence precedence() const { return PrecCall; }
629   private:
630     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
631     RefPtr<ExpressionNode> base;
632     Identifier ident;
633     RefPtr<ArgumentsNode> args;
634   };
635
636   class PrePostResolveNode : public ExpressionNode {
637   public:
638     PrePostResolveNode(const Identifier& i) KJS_FAST_CALL : ExpressionNode(NumberType), m_ident(i) {}
639       
640     PrePostResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
641         : ExpressionNode(PlacementNewAdopt)
642         , m_ident(PlacementNewAdopt)
643     {
644     }
645       
646   protected:
647       Identifier m_ident;
648       size_t m_index; // Used by LocalVarPostfixNode.      
649   };
650     
651   class PostIncResolveNode : public PrePostResolveNode {
652   public:
653     PostIncResolveNode(const Identifier& i) KJS_FAST_CALL : PrePostResolveNode(i) {}
654
655     PostIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
656         : PrePostResolveNode(PlacementNewAdopt)
657     {
658     }
659
660     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
661     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
662     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
663     virtual Precedence precedence() const { return PrecPostfix; }
664     virtual void optimizeForUnnecessaryResult();
665
666   };
667
668   class PostIncLocalVarNode : public PostIncResolveNode {
669   public:
670     PostIncLocalVarNode(size_t i) KJS_FAST_CALL
671         : PostIncResolveNode(PlacementNewAdopt)
672     {
673         ASSERT(i != missingSymbolMarker());
674         m_index = i;
675     }
676
677     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
678     virtual void optimizeForUnnecessaryResult();
679   };
680
681   class PostDecResolveNode : public PrePostResolveNode {
682   public:
683     PostDecResolveNode(const Identifier& i) KJS_FAST_CALL : PrePostResolveNode(i) {}
684
685     PostDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
686         : PrePostResolveNode(PlacementNewAdopt)
687     {
688     }
689
690     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
691     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
692     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
693     virtual Precedence precedence() const { return PrecPostfix; }
694     virtual void optimizeForUnnecessaryResult();
695   };
696
697   class PostDecLocalVarNode : public PostDecResolveNode {
698   public:
699     PostDecLocalVarNode(size_t i) KJS_FAST_CALL
700         : PostDecResolveNode(PlacementNewAdopt)
701     {
702         ASSERT(i != missingSymbolMarker());
703         m_index = i;
704     }
705
706     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
707     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
708     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
709     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
710     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
711     virtual void optimizeForUnnecessaryResult();
712   private:
713     ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
714   };
715
716   class PostfixBracketNode : public ExpressionNode {
717   public:
718     PostfixBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : m_base(b), m_subscript(s) {}
719     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
720     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
721     virtual Precedence precedence() const { return PrecPostfix; }
722   protected:
723     virtual bool isIncrement() const = 0;
724     RefPtr<ExpressionNode> m_base;
725     RefPtr<ExpressionNode> m_subscript;
726   };
727
728   class PostIncBracketNode : public PostfixBracketNode {
729   public:
730     PostIncBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : PostfixBracketNode(b, s) {}
731     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
732   protected:
733     virtual bool isIncrement() const { return true; }
734   };
735
736   class PostDecBracketNode : public PostfixBracketNode {
737   public:
738     PostDecBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : PostfixBracketNode(b, s) {}
739     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
740   protected:
741     virtual bool isIncrement() const { return false; }
742   };
743
744     class PostfixDotNode : public ExpressionNode {
745   public:
746     PostfixDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : m_base(b), m_ident(i) {}
747     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
748     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
749     virtual Precedence precedence() const { return PrecPostfix; }
750   protected:
751     virtual bool isIncrement() const = 0;
752     RefPtr<ExpressionNode> m_base;
753     Identifier m_ident;
754   };
755
756   class PostIncDotNode : public PostfixDotNode {
757   public:
758     PostIncDotNode(ExpressionNode*  b, const Identifier& i) KJS_FAST_CALL : PostfixDotNode(b, i) {}
759     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
760   protected:
761     virtual bool isIncrement() const { return true; }
762   };
763
764   class PostDecDotNode : public PostfixDotNode {
765   public:
766     PostDecDotNode(ExpressionNode*  b, const Identifier& i) KJS_FAST_CALL : PostfixDotNode(b, i) {}
767     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
768   protected:
769     virtual bool isIncrement() const { return false; }
770   };
771
772   class PostfixErrorNode : public ExpressionNode {
773   public:
774     PostfixErrorNode(ExpressionNode* e, Operator o) KJS_FAST_CALL : m_expr(e), m_oper(o) {}
775     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
776     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
777     virtual Precedence precedence() const { return PrecPostfix; }
778   private:
779     RefPtr<ExpressionNode> m_expr;
780     Operator m_oper;
781   };
782
783   class DeleteResolveNode : public ExpressionNode {
784   public:
785     DeleteResolveNode(const Identifier& i) KJS_FAST_CALL : m_ident(i) {}
786     DeleteResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
787         : ExpressionNode(PlacementNewAdopt)
788         , m_ident(PlacementNewAdopt)
789     {
790     }
791
792     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
793     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
794     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
795     virtual Precedence precedence() const { return PrecUnary; }
796   private:
797     Identifier m_ident;
798   };
799
800   class LocalVarDeleteNode : public DeleteResolveNode {
801   public:
802     LocalVarDeleteNode() KJS_FAST_CALL
803         : DeleteResolveNode(PlacementNewAdopt)
804     {
805     }
806
807     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
808   };
809
810   class DeleteBracketNode : public ExpressionNode {
811   public:
812     DeleteBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL : m_base(base), m_subscript(subscript) {}
813     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
814     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
815     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
816     virtual Precedence precedence() const { return PrecUnary; }
817   private:
818     RefPtr<ExpressionNode> m_base;
819     RefPtr<ExpressionNode> m_subscript;
820   };
821
822   class DeleteDotNode : public ExpressionNode {
823   public:
824     DeleteDotNode(ExpressionNode* base, const Identifier& i) KJS_FAST_CALL : m_base(base), m_ident(i) {}
825     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
826     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
827     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
828     virtual Precedence precedence() const { return PrecUnary; }
829   private:
830     RefPtr<ExpressionNode> m_base;
831     Identifier m_ident;
832   };
833
834   class DeleteValueNode : public ExpressionNode {
835   public:
836     DeleteValueNode(ExpressionNode* e) KJS_FAST_CALL : m_expr(e) {}
837     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
838     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
839     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
840     virtual Precedence precedence() const { return PrecUnary; }
841   private:
842     RefPtr<ExpressionNode> m_expr;
843   };
844
845   class VoidNode : public ExpressionNode {
846   public:
847     VoidNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
848     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
849     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
850     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
851     virtual Precedence precedence() const { return PrecUnary; }
852   private:
853     RefPtr<ExpressionNode> expr;
854   };
855
856   class TypeOfResolveNode : public ExpressionNode {
857   public:
858     TypeOfResolveNode(const Identifier &s) KJS_FAST_CALL 
859         : ExpressionNode(StringType), m_ident(s) {}
860     
861     TypeOfResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
862         : ExpressionNode(PlacementNewAdopt)
863         , m_ident(PlacementNewAdopt) 
864     {
865         m_expectedReturnType = StringType;
866     }
867
868     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
869     
870     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
871     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
872     virtual Precedence precedence() const { return PrecUnary; }
873
874     const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
875
876   protected:
877     Identifier m_ident;
878     size_t m_index; // Used by LocalTypeOfNode.
879   };
880     
881   class LocalVarTypeOfNode : public TypeOfResolveNode {
882   public:
883     LocalVarTypeOfNode(size_t i) KJS_FAST_CALL 
884         : TypeOfResolveNode(PlacementNewAdopt)
885     {
886         m_expectedReturnType = StringType;
887         ASSERT(i != missingSymbolMarker());
888         m_index = i;
889     }
890
891     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
892   };
893
894   class TypeOfValueNode : public ExpressionNode {
895   public:
896     TypeOfValueNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(StringType), m_expr(e) {}
897     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
898     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
899     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
900     virtual Precedence precedence() const { return PrecUnary; }
901   private:
902     RefPtr<ExpressionNode> m_expr;
903   };
904
905   class PreIncResolveNode : public PrePostResolveNode {
906   public:
907     PreIncResolveNode(const Identifier &s) KJS_FAST_CALL 
908         : PrePostResolveNode(s) 
909     { 
910     }
911     
912     PreIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
913         : PrePostResolveNode(PlacementNewAdopt)
914     {
915     }
916     
917     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
918
919     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
920     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
921     virtual Precedence precedence() const { return PrecUnary; }
922   };
923
924   class PreIncLocalVarNode : public PreIncResolveNode {
925   public:
926     PreIncLocalVarNode(size_t i) KJS_FAST_CALL 
927         : PreIncResolveNode(PlacementNewAdopt)
928     { 
929         ASSERT(i != missingSymbolMarker());
930         m_index = i;
931     }
932     
933     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
934   };
935   
936   class PreDecResolveNode : public PrePostResolveNode {
937   public:
938     PreDecResolveNode(const Identifier &s) KJS_FAST_CALL 
939         : PrePostResolveNode(s) 
940     { 
941     }
942     
943     PreDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
944         : PrePostResolveNode(PlacementNewAdopt)
945     {
946     }
947     
948     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
949
950     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
951     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
952     virtual Precedence precedence() const { return PrecUnary; }
953   };
954
955   class PreDecLocalVarNode : public PreDecResolveNode {
956   public:
957     PreDecLocalVarNode(size_t i) KJS_FAST_CALL 
958         : PreDecResolveNode(PlacementNewAdopt)
959     { 
960         ASSERT(i != missingSymbolMarker());
961         m_index = i;
962     }
963     
964     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
965   };
966   
967   class PrefixBracketNode : public ExpressionNode {
968   public:
969     PrefixBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : m_base(b), m_subscript(s) {}
970     
971     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
972     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
973     virtual Precedence precedence() const { return PrecUnary; }
974   protected:
975     virtual bool isIncrement() const = 0;
976     RefPtr<ExpressionNode> m_base;
977     RefPtr<ExpressionNode> m_subscript;
978   };
979   
980   class PreIncBracketNode : public PrefixBracketNode {
981   public:
982     PreIncBracketNode(ExpressionNode*  b, ExpressionNode*  s) KJS_FAST_CALL : PrefixBracketNode(b, s) {}
983     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
984   protected:
985     bool isIncrement() const { return true; }
986   };
987   
988   class PreDecBracketNode : public PrefixBracketNode {
989   public:
990     PreDecBracketNode(ExpressionNode*  b, ExpressionNode*  s) KJS_FAST_CALL : PrefixBracketNode(b, s) {}
991     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
992   protected:
993     bool isIncrement() const { return false; }
994   };
995
996   class PrefixDotNode : public ExpressionNode {
997   public:
998     PrefixDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : m_base(b), m_ident(i) {}
999     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1000     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1001     virtual Precedence precedence() const { return PrecPostfix; }
1002   protected:
1003     virtual bool isIncrement() const = 0;
1004     RefPtr<ExpressionNode> m_base;
1005     Identifier m_ident;
1006   };
1007
1008   class PreIncDotNode : public PrefixDotNode {
1009   public:
1010     PreIncDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : PrefixDotNode(b, i) {}
1011     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1012   protected:
1013     virtual bool isIncrement() const { return true; }
1014   };
1015
1016   class PreDecDotNode : public PrefixDotNode {
1017   public:
1018     PreDecDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : PrefixDotNode(b, i) {}
1019     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1020   protected:
1021     virtual bool isIncrement() const { return false; }
1022   };
1023
1024   class PrefixErrorNode : public ExpressionNode {
1025   public:
1026     PrefixErrorNode(ExpressionNode* e, Operator o) KJS_FAST_CALL : m_expr(e), m_oper(o) {}
1027     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1028     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1029     virtual Precedence precedence() const { return PrecUnary; }
1030   private:
1031     RefPtr<ExpressionNode> m_expr;
1032     Operator m_oper;
1033   };
1034
1035   class UnaryPlusNode : public ExpressionNode {
1036   public:
1037     UnaryPlusNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), m_expr(e) {}
1038     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1039     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1040     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1041     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1042     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1043     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1044     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1045     virtual Precedence precedence() const { return PrecUnary; }
1046   private:
1047     RefPtr<ExpressionNode> m_expr;
1048   };
1049
1050   class NegateNode : public ExpressionNode {
1051   public:
1052     NegateNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), expr(e) {}
1053     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1054     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1055     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1056     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1057     virtual Precedence precedence() const { return PrecUnary; }
1058   private:
1059     RefPtr<ExpressionNode> expr;
1060   };
1061
1062   class BitwiseNotNode : public ExpressionNode {
1063   public:
1064     BitwiseNotNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), expr(e) {}
1065     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1066     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1067     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1068     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1069     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1070     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1071     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1072     virtual Precedence precedence() const { return PrecUnary; }
1073   private:
1074     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
1075     RefPtr<ExpressionNode> expr;
1076   };
1077
1078   class LogicalNotNode : public ExpressionNode {
1079   public:
1080     LogicalNotNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(BooleanType), expr(e) {}
1081     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1082     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1083     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1084     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1085     virtual Precedence precedence() const { return PrecUnary; }
1086   private:
1087     RefPtr<ExpressionNode> expr;
1088   };
1089   
1090   class MultNode : public ExpressionNode {
1091   public:
1092       MultNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
1093       virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1094       virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1095       virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1096       virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1097       virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1098       virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1099       virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1100       virtual Precedence precedence() const { return PrecMultiplicitave; }
1101   private:
1102       ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
1103       RefPtr<ExpressionNode> term1;
1104       RefPtr<ExpressionNode> term2;
1105   };
1106   
1107   class DivNode : public ExpressionNode {
1108   public:
1109       DivNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
1110       virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1111       virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1112       virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1113       virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1114       virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1115       virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1116       virtual Precedence precedence() const { return PrecMultiplicitave; }
1117   private:
1118       ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
1119       RefPtr<ExpressionNode> term1;
1120       RefPtr<ExpressionNode> term2;
1121   };
1122   
1123   class ModNode : public ExpressionNode {
1124   public:
1125       ModNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
1126       virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1127       virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1128       virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1129       virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1130       virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1131       virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1132       virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1133       virtual Precedence precedence() const { return PrecMultiplicitave; }
1134   private:
1135       ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
1136       RefPtr<ExpressionNode> term1;
1137       RefPtr<ExpressionNode> term2;
1138   };
1139
1140   class AddNode : public ExpressionNode {
1141   public:
1142     AddNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
1143     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1144     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1145     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1146     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1147     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1148     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1149     virtual Precedence precedence() const { return PrecAdditive; }
1150   protected:
1151     AddNode(ExpressionNode* t1, ExpressionNode* t2, JSType expectedReturn) KJS_FAST_CALL : ExpressionNode(expectedReturn), term1(t1), term2(t2) {}
1152     RefPtr<ExpressionNode> term1;
1153     RefPtr<ExpressionNode> term2;
1154   private:
1155     ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
1156   };
1157
1158     class AddNumbersNode : public AddNode {
1159     public:
1160         AddNumbersNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, NumberType) {}
1161         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1162         virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1163         virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1164         virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1165     private:
1166         ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*) KJS_FAST_CALL;
1167     };
1168
1169     class AddStringLeftNode : public AddNode {
1170     public:
1171         AddStringLeftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
1172         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1173     };
1174
1175     class AddStringRightNode : public AddNode {
1176     public:
1177         AddStringRightNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
1178         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1179     };
1180
1181     class AddStringsNode : public AddNode {
1182     public:
1183         AddStringsNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
1184         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1185     };
1186
1187   class SubNode : public ExpressionNode {
1188   public:
1189       SubNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
1190       virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1191       virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1192       virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1193       virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1194       virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1195       virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1196       virtual Precedence precedence() const { return PrecAdditive; }
1197   private:
1198       ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
1199       RefPtr<ExpressionNode> term1;
1200       RefPtr<ExpressionNode> term2;
1201   };
1202
1203   class LeftShiftNode : public ExpressionNode {
1204   public:
1205     LeftShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
1206       : ExpressionNode(NumberType), term1(t1), term2(t2) {}
1207     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1208     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1209     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1210     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1211     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1212     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1213     virtual Precedence precedence() const { return PrecShift; }
1214   private:
1215     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
1216     RefPtr<ExpressionNode> term1;
1217     RefPtr<ExpressionNode> term2;
1218   };
1219
1220   class RightShiftNode : public ExpressionNode {
1221   public:
1222     RightShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
1223       : ExpressionNode(NumberType), term1(t1), term2(t2) {}
1224     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1225     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1226     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1227     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1228     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1229     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1230     virtual Precedence precedence() const { return PrecShift; }
1231   private:
1232     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
1233     RefPtr<ExpressionNode> term1;
1234     RefPtr<ExpressionNode> term2;
1235   };
1236
1237   class UnsignedRightShiftNode : public ExpressionNode {
1238   public:
1239     UnsignedRightShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
1240       : ExpressionNode(NumberType), term1(t1), term2(t2) {}
1241     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1242     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1243     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1244     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1245     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1246     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1247     virtual Precedence precedence() const { return PrecShift; }
1248   private:
1249     ALWAYS_INLINE uint32_t inlineEvaluateToUInt32(ExecState*);
1250     RefPtr<ExpressionNode> term1;
1251     RefPtr<ExpressionNode> term2;
1252   };
1253
1254   class LessNode : public ExpressionNode {
1255   public:
1256     LessNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1257       : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
1258     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1259     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1260     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1261     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1262     virtual Precedence precedence() const { return PrecRelational; }
1263   private:
1264     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1265   protected:
1266     RefPtr<ExpressionNode> expr1;
1267     RefPtr<ExpressionNode> expr2;
1268   };
1269
1270     class LessNumbersNode : public LessNode {
1271     public:
1272         LessNumbersNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1273             : LessNode(e1, e2) {}
1274         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1275         virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1276     private:
1277         ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1278     };
1279
1280     class LessStringsNode : public LessNode {
1281     public:
1282         LessStringsNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1283             : LessNode(e1, e2) {}
1284         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1285         virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1286     private:
1287         ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1288     };
1289
1290   class GreaterNode : public ExpressionNode {
1291   public:
1292     GreaterNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
1293       expr1(e1), expr2(e2) {}
1294     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1295     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1296     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1297     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1298     virtual Precedence precedence() const { return PrecRelational; }
1299   private:
1300     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1301     RefPtr<ExpressionNode> expr1;
1302     RefPtr<ExpressionNode> expr2;
1303   };
1304
1305   class LessEqNode : public ExpressionNode {
1306   public:
1307     LessEqNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
1308       expr1(e1), expr2(e2) {}
1309     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1310     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1311     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1312     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1313     virtual Precedence precedence() const { return PrecRelational; }
1314   private:
1315     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1316     RefPtr<ExpressionNode> expr1;
1317     RefPtr<ExpressionNode> expr2;
1318   };
1319
1320   class GreaterEqNode : public ExpressionNode {
1321   public:
1322     GreaterEqNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
1323       expr1(e1), expr2(e2) {}
1324     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1325     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1326     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1327     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1328     virtual Precedence precedence() const { return PrecRelational; }
1329   private:
1330     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1331     RefPtr<ExpressionNode> expr1;
1332     RefPtr<ExpressionNode> expr2;
1333   };
1334
1335     class InstanceOfNode : public ExpressionNode {
1336   public:
1337     InstanceOfNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1338         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
1339     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1340     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1341     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1342     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1343     virtual Precedence precedence() const { return PrecRelational; }
1344   private:
1345     RefPtr<ExpressionNode> expr1;
1346     RefPtr<ExpressionNode> expr2;
1347   };
1348
1349     class InNode : public ExpressionNode {
1350   public:
1351     InNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
1352       expr1(e1), expr2(e2) {}
1353     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1354     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1355     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1356     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1357     virtual Precedence precedence() const { return PrecRelational; }
1358   private:
1359     RefPtr<ExpressionNode> expr1;
1360     RefPtr<ExpressionNode> expr2;
1361   };
1362
1363     class EqualNode : public ExpressionNode {
1364   public:
1365     EqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1366         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
1367     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1368     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1369     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1370     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1371     virtual Precedence precedence() const { return PrecEquality; }
1372   private:
1373     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1374     RefPtr<ExpressionNode> expr1;
1375     RefPtr<ExpressionNode> expr2;
1376   };
1377
1378     class NotEqualNode : public ExpressionNode {
1379   public:
1380     NotEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1381         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
1382     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1383     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1384     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1385     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1386     virtual Precedence precedence() const { return PrecEquality; }
1387   private:
1388     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1389     RefPtr<ExpressionNode> expr1;
1390     RefPtr<ExpressionNode> expr2;
1391   };
1392
1393     class StrictEqualNode : public ExpressionNode {
1394   public:
1395     StrictEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1396         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
1397     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1398     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1399     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1400     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1401     virtual Precedence precedence() const { return PrecEquality; }
1402   private:
1403     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1404     RefPtr<ExpressionNode> expr1;
1405     RefPtr<ExpressionNode> expr2;
1406   };
1407
1408     class NotStrictEqualNode : public ExpressionNode {
1409   public:
1410     NotStrictEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1411         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
1412     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1413     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1414     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1415     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1416     virtual Precedence precedence() const { return PrecEquality; }
1417   private:
1418     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1419     RefPtr<ExpressionNode> expr1;
1420     RefPtr<ExpressionNode> expr2;
1421   };
1422
1423     class BitAndNode : public ExpressionNode {
1424   public:
1425     BitAndNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1426         : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
1427     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1428     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1429     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1430     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1431     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1432     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1433     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1434     virtual Precedence precedence() const { return PrecBitwiseAnd; }
1435   private:
1436     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
1437     RefPtr<ExpressionNode> expr1;
1438     RefPtr<ExpressionNode> expr2;
1439   };
1440
1441     class BitOrNode : public ExpressionNode {
1442   public:
1443     BitOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1444         : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
1445     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1446     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1447     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1448     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1449     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1450     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1451     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1452     virtual Precedence precedence() const { return PrecBitwiseOr; }
1453   private:
1454     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
1455     RefPtr<ExpressionNode> expr1;
1456     RefPtr<ExpressionNode> expr2;
1457   };
1458
1459     class BitXOrNode : public ExpressionNode {
1460   public:
1461     BitXOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1462         : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
1463     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1464     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1465     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1466     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1467     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1468     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1469     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1470     virtual Precedence precedence() const { return PrecBitwiseXor; }
1471   private:
1472     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
1473     RefPtr<ExpressionNode> expr1;
1474     RefPtr<ExpressionNode> expr2;
1475   };
1476
1477   /**
1478    * expr1 && expr2, expr1 || expr2
1479    */
1480     class LogicalAndNode : public ExpressionNode {
1481   public:
1482     LogicalAndNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1483         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
1484     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1485     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1486     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1487     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1488     virtual Precedence precedence() const { return PrecLogicalAnd; }
1489   private:
1490     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1491     RefPtr<ExpressionNode> expr1;
1492     RefPtr<ExpressionNode> expr2;
1493   };
1494   
1495     class LogicalOrNode : public ExpressionNode {
1496   public:
1497     LogicalOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
1498         : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
1499     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1500     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1501     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1502     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1503     virtual Precedence precedence() const { return PrecLogicalOr; }
1504   private:
1505     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
1506     RefPtr<ExpressionNode> expr1;
1507     RefPtr<ExpressionNode> expr2;
1508   };
1509
1510   /**
1511    * The ternary operator, "logical ? expr1 : expr2"
1512    */
1513     class ConditionalNode : public ExpressionNode {
1514   public:
1515     ConditionalNode(ExpressionNode*  l, ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
1516       logical(l), expr1(e1), expr2(e2) {}
1517     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1518     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1519     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1520     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1521     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1522     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1523     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1524     virtual Precedence precedence() const { return PrecConditional; }
1525   private:
1526     RefPtr<ExpressionNode> logical;
1527     RefPtr<ExpressionNode> expr1;
1528     RefPtr<ExpressionNode> expr2;
1529   };
1530
1531     class ReadModifyResolveNode : public ExpressionNode {
1532   public:
1533     ReadModifyResolveNode(const Identifier &ident, Operator oper, ExpressionNode*  right) KJS_FAST_CALL
1534       : m_ident(ident)
1535       , m_oper(oper)
1536       , m_right(right) 
1537       {
1538       }
1539
1540     ReadModifyResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
1541       : ExpressionNode(PlacementNewAdopt)
1542       , m_ident(PlacementNewAdopt) 
1543       , m_right(PlacementNewAdopt) 
1544     {
1545     }
1546
1547     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1548     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1549     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1550     virtual Precedence precedence() const { return PrecAssignment; }
1551   protected:
1552     Identifier m_ident;
1553     Operator m_oper;
1554     RefPtr<ExpressionNode> m_right;
1555     size_t m_index; // Used by ReadModifyLocalVarNode.
1556   };
1557
1558   class ReadModifyLocalVarNode : public ReadModifyResolveNode {
1559   public:
1560     ReadModifyLocalVarNode(size_t i) KJS_FAST_CALL 
1561         : ReadModifyResolveNode(PlacementNewAdopt)
1562     { 
1563         ASSERT(i != missingSymbolMarker());
1564         m_index = i;
1565     }
1566     
1567     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1568   };
1569
1570     class AssignResolveNode : public ExpressionNode {
1571   public:
1572      AssignResolveNode(const Identifier &ident, ExpressionNode*  right) KJS_FAST_CALL
1573       : m_ident(ident)
1574       , m_right(right) 
1575       {
1576       }
1577
1578     AssignResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
1579       : ExpressionNode(PlacementNewAdopt)
1580       , m_ident(PlacementNewAdopt) 
1581       , m_right(PlacementNewAdopt) 
1582     {
1583     }
1584
1585     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1586     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1587     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1588     virtual Precedence precedence() const { return PrecAssignment; }
1589   protected:
1590     Identifier m_ident;
1591     RefPtr<ExpressionNode> m_right;
1592     size_t m_index; // Used by ReadModifyLocalVarNode.
1593   };
1594
1595   class AssignLocalVarNode : public AssignResolveNode {
1596   public:
1597     AssignLocalVarNode(size_t i) KJS_FAST_CALL 
1598         : AssignResolveNode(PlacementNewAdopt)
1599     { 
1600         ASSERT(i != missingSymbolMarker());
1601         m_index = i;
1602     }
1603     
1604     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1605   };
1606
1607     class ReadModifyBracketNode : public ExpressionNode {
1608   public:
1609     ReadModifyBracketNode(ExpressionNode*  base, ExpressionNode*  subscript, Operator oper, ExpressionNode*  right) KJS_FAST_CALL
1610       : m_base(base), m_subscript(subscript), m_oper(oper), m_right(right) {}
1611     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1612     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1613     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1614     virtual Precedence precedence() const { return PrecAssignment; }
1615   protected:
1616     RefPtr<ExpressionNode> m_base;
1617     RefPtr<ExpressionNode> m_subscript;
1618     Operator m_oper;
1619     RefPtr<ExpressionNode> m_right;
1620   };
1621
1622     class AssignBracketNode : public ExpressionNode {
1623   public:
1624     AssignBracketNode(ExpressionNode*  base, ExpressionNode*  subscript, ExpressionNode*  right) KJS_FAST_CALL
1625       : m_base(base), m_subscript(subscript), m_right(right) {}
1626     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1627     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1628     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1629     virtual Precedence precedence() const { return PrecAssignment; }
1630   protected:
1631     RefPtr<ExpressionNode> m_base;
1632     RefPtr<ExpressionNode> m_subscript;
1633     RefPtr<ExpressionNode> m_right;
1634   };
1635
1636     class AssignDotNode : public ExpressionNode {
1637   public:
1638     AssignDotNode(ExpressionNode*  base, const Identifier& ident, ExpressionNode*  right) KJS_FAST_CALL
1639       : m_base(base), m_ident(ident), m_right(right) {}
1640     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1641     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1642     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1643     virtual Precedence precedence() const { return PrecAssignment; }
1644   protected:
1645     RefPtr<ExpressionNode> m_base;
1646     Identifier m_ident;
1647     RefPtr<ExpressionNode> m_right;
1648   };
1649
1650     class ReadModifyDotNode : public ExpressionNode {
1651   public:
1652     ReadModifyDotNode(ExpressionNode*  base, const Identifier& ident, Operator oper, ExpressionNode*  right) KJS_FAST_CALL
1653       : m_base(base), m_ident(ident), m_oper(oper), m_right(right) {}
1654     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1655     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1656     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1657     virtual Precedence precedence() const { return PrecAssignment; }
1658   protected:
1659     RefPtr<ExpressionNode> m_base;
1660     Identifier m_ident;
1661     Operator m_oper;
1662     RefPtr<ExpressionNode> m_right;
1663   };
1664
1665     class AssignErrorNode : public ExpressionNode {
1666   public:
1667     AssignErrorNode(ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL
1668       : m_left(left), m_oper(oper), m_right(right) {}
1669     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1670     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1671     virtual Precedence precedence() const { return PrecAssignment; }
1672   protected:
1673     RefPtr<ExpressionNode> m_left;
1674     Operator m_oper;
1675     RefPtr<ExpressionNode> m_right;
1676   };
1677
1678     class CommaNode : public ExpressionNode {
1679   public:
1680     CommaNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL : expr1(e1), expr2(e2)
1681     {
1682         e1->optimizeForUnnecessaryResult();
1683     }
1684     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1685     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1686     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1687     virtual Precedence precedence() const { return PrecExpression; }
1688   private:
1689     RefPtr<ExpressionNode> expr1;
1690     RefPtr<ExpressionNode> expr2;
1691   };
1692
1693     class AssignExprNode : public ExpressionNode {
1694   public:
1695     AssignExprNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
1696     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1697     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1698     virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
1699     virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
1700     virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
1701     virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
1702     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1703     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
1704   private:
1705     RefPtr<ExpressionNode> expr;
1706   };
1707
1708     class VarDeclNode : public ExpressionNode {
1709   public:
1710     enum Type { Variable, Constant };
1711     VarDeclNode(const Identifier &id, AssignExprNode *in, Type t) KJS_FAST_CALL;
1712     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1713     virtual KJS::JSValue* evaluate(ExecState*) KJS_FAST_CALL;
1714     void evaluateSingle(ExecState*) KJS_FAST_CALL;
1715     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1716     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
1717     PassRefPtr<VarDeclNode> releaseNext() KJS_FAST_CALL { return next.release(); }
1718
1719     Type varType;
1720     Identifier ident;
1721     ListRefPtr<VarDeclNode> next;
1722   private:
1723     void handleSlowCase(ExecState*, const ScopeChain&, JSValue*) KJS_FAST_CALL KJS_NO_INLINE;
1724     RefPtr<AssignExprNode> init;
1725   };
1726
1727   class VarStatementNode : public StatementNode {
1728   public:
1729     VarStatementNode(VarDeclNode* l) KJS_FAST_CALL : next(l) { }
1730     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1731     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1732     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1733   private:
1734     RefPtr<VarDeclNode> next;
1735   };
1736
1737   typedef Vector<RefPtr<StatementNode> > SourceElements;
1738
1739   class SourceElementsStub : public Node {
1740   public:
1741     SourceElementsStub()
1742       : m_sourceElements(new SourceElements)
1743       {}
1744     void append(StatementNode* element) { m_sourceElements->append(element); }
1745     SourceElements* release() { 
1746         SourceElements* elems = m_sourceElements.release(); 
1747         return elems;
1748     }
1749     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL { ASSERT_NOT_REACHED(); }
1750     virtual JSValue* execute(ExecState*) KJS_FAST_CALL  { ASSERT_NOT_REACHED(); return 0; }
1751     virtual void streamTo(SourceStream&) const KJS_FAST_CALL  { ASSERT_NOT_REACHED(); }
1752     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
1753   private:
1754     OwnPtr<SourceElements> m_sourceElements;
1755   };
1756     
1757   class BlockNode : public StatementNode {
1758   public:
1759     BlockNode(SourceElements* children) KJS_FAST_CALL;
1760     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1761     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1762     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1763   protected:
1764     OwnPtr<SourceElements> m_children;
1765   };
1766
1767   class EmptyStatementNode : public StatementNode {
1768   public:
1769     EmptyStatementNode() KJS_FAST_CALL { } // debug
1770     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1771     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1772   };
1773
1774   class ExprStatementNode : public StatementNode {
1775   public:
1776     ExprStatementNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
1777     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1778     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1779     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1780   private:
1781     RefPtr<ExpressionNode> expr;
1782   };
1783
1784   class IfNode : public StatementNode {
1785   public:
1786     IfNode(ExpressionNode* e, StatementNode *s) KJS_FAST_CALL
1787       : m_condition(e), m_ifBlock(s) { }
1788     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1789     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1790     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1791   protected:
1792     RefPtr<ExpressionNode> m_condition;
1793     RefPtr<StatementNode> m_ifBlock;
1794   };
1795
1796     class IfElseNode : public IfNode {
1797     public:
1798         IfElseNode(ExpressionNode* e, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL
1799             : IfNode(e, ifBlock), m_elseBlock(elseBlock) { }
1800         virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1801         virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1802         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1803     private:
1804         RefPtr<StatementNode> m_elseBlock;
1805     };
1806
1807   class DoWhileNode : public StatementNode {
1808   public:
1809     DoWhileNode(StatementNode *s, ExpressionNode* e) KJS_FAST_CALL : statement(s), expr(e) { }
1810     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1811     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1812     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1813   private:
1814     RefPtr<StatementNode> statement;
1815     RefPtr<ExpressionNode> expr;
1816   };
1817
1818   class WhileNode : public StatementNode {
1819   public:
1820     WhileNode(ExpressionNode* e, StatementNode *s) KJS_FAST_CALL : expr(e), statement(s) { }
1821     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1822     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1823     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1824   private:
1825     RefPtr<ExpressionNode> expr;
1826     RefPtr<StatementNode> statement;
1827   };
1828
1829   class ForNode : public StatementNode {
1830   public:
1831     ForNode(ExpressionNode* e1, ExpressionNode* e2, ExpressionNode* e3, StatementNode* s) KJS_FAST_CALL
1832         : expr1(e1 ? e1 : new TrueNode)
1833         , expr2(e2 ? e2 : new TrueNode)
1834         , expr3(e3 ? e3 : new TrueNode)
1835         , statement(s)
1836     {
1837         ASSERT(expr1);
1838         ASSERT(expr2);
1839         ASSERT(expr3);
1840         ASSERT(statement);
1841
1842         expr1->optimizeForUnnecessaryResult();
1843         expr3->optimizeForUnnecessaryResult();
1844     }
1845
1846     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1847     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1848     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1849   private:
1850     RefPtr<ExpressionNode> expr1;
1851     RefPtr<ExpressionNode> expr2;
1852     RefPtr<ExpressionNode> expr3;
1853     RefPtr<StatementNode> statement;
1854   };
1855
1856   class ForInNode : public StatementNode {
1857   public:
1858     ForInNode(ExpressionNode*  l, ExpressionNode* e, StatementNode *s) KJS_FAST_CALL;
1859     ForInNode(const Identifier &i, AssignExprNode *in, ExpressionNode* e, StatementNode *s) KJS_FAST_CALL;
1860     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1861     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1862     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1863     VarDeclNode* getVarDecl() { return varDecl.get(); }
1864   private:
1865     Identifier ident;
1866     RefPtr<AssignExprNode> init;
1867     RefPtr<ExpressionNode> lexpr;
1868     RefPtr<ExpressionNode> expr;
1869     RefPtr<VarDeclNode> varDecl;
1870     RefPtr<StatementNode> statement;
1871   };
1872
1873   class ContinueNode : public StatementNode {
1874   public:
1875     ContinueNode() KJS_FAST_CALL { }
1876     ContinueNode(const Identifier &i) KJS_FAST_CALL : ident(i) { }
1877     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1878     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1879   private:
1880     Identifier ident;
1881   };
1882
1883   class BreakNode : public StatementNode {
1884   public:
1885     BreakNode() KJS_FAST_CALL { }
1886     BreakNode(const Identifier &i) KJS_FAST_CALL : ident(i) { }
1887     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1888     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1889   private:
1890     Identifier ident;
1891   };
1892
1893   class ReturnNode : public StatementNode {
1894   public:
1895     ReturnNode(ExpressionNode* v) KJS_FAST_CALL : value(v) {}
1896     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1897     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1898     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1899   private:
1900     RefPtr<ExpressionNode> value;
1901   };
1902
1903   class WithNode : public StatementNode {
1904   public:
1905     WithNode(ExpressionNode* e, StatementNode* s) KJS_FAST_CALL : expr(e), statement(s) { }
1906     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1907     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1908     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1909   private:
1910     RefPtr<ExpressionNode> expr;
1911     RefPtr<StatementNode> statement;
1912   };
1913
1914   class LabelNode : public StatementNode {
1915   public:
1916     LabelNode(const Identifier &l, StatementNode *s) KJS_FAST_CALL : label(l), statement(s) { }
1917     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1918     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1919     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1920   private:
1921     Identifier label;
1922     RefPtr<StatementNode> statement;
1923   };
1924
1925   class ThrowNode : public StatementNode {
1926   public:
1927     ThrowNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
1928     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1929     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1930     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1931   private:
1932     RefPtr<ExpressionNode> expr;
1933   };
1934
1935   class TryNode : public StatementNode {
1936   public:
1937     TryNode(StatementNode *b, const Identifier &e, StatementNode *c, StatementNode *f) KJS_FAST_CALL
1938       : tryBlock(b), exceptionIdent(e), catchBlock(c), finallyBlock(f) { }
1939     virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
1940     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1941     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1942   private:
1943     RefPtr<StatementNode> tryBlock;
1944     Identifier exceptionIdent;
1945     RefPtr<StatementNode> catchBlock;
1946     RefPtr<StatementNode> finallyBlock;
1947   };
1948
1949     class ParameterNode : public Node {
1950   public:
1951     ParameterNode(const Identifier& i) KJS_FAST_CALL : id(i) { }
1952     ParameterNode(ParameterNode* l, const Identifier& i) KJS_FAST_CALL
1953       : id(i) { l->next = this; }
1954     Identifier ident() KJS_FAST_CALL { return id; }
1955     ParameterNode *nextParam() KJS_FAST_CALL { return next.get(); }
1956     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1957     PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return next.release(); }
1958     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
1959   private:
1960     friend class FuncDeclNode;
1961     friend class FuncExprNode;
1962     Identifier id;
1963     ListRefPtr<ParameterNode> next;
1964   };
1965
1966   class ScopeNode : public BlockNode {
1967   public:
1968     ScopeNode(SourceElements*, DeclarationStacks::VarStack*, DeclarationStacks::FunctionStack*) KJS_FAST_CALL;
1969
1970     int sourceId() const KJS_FAST_CALL { return m_sourceId; }
1971     const UString& sourceURL() const KJS_FAST_CALL { return m_sourceURL; }
1972
1973   protected:
1974     void optimizeVariableAccess(ExecState*) KJS_FAST_CALL;
1975
1976     DeclarationStacks::VarStack m_varStack;
1977     DeclarationStacks::FunctionStack m_functionStack;
1978
1979   private:
1980     UString m_sourceURL;
1981     int m_sourceId;
1982   };
1983
1984   class ProgramNode : public ScopeNode {
1985   public:
1986     ProgramNode(SourceElements*, DeclarationStacks::VarStack*, DeclarationStacks::FunctionStack*) KJS_FAST_CALL;
1987     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
1988     
1989   private:
1990     void initializeSymbolTable(ExecState*) KJS_FAST_CALL;
1991     ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
1992
1993     Vector<size_t> m_varIndexes; // Storage indexes belonging to the nodes in m_varStack. (Recorded to avoid double lookup.)
1994     Vector<size_t> m_functionIndexes; // Storage indexes belonging to the nodes in m_functionStack. (Recorded to avoid double lookup.)
1995   };
1996
1997   class EvalNode : public ScopeNode {
1998   public:
1999     EvalNode(SourceElements*, DeclarationStacks::VarStack*, DeclarationStacks::FunctionStack*) KJS_FAST_CALL;
2000     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
2001     
2002   private:
2003     ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
2004   };
2005
2006   class FunctionBodyNode : public ScopeNode {
2007   public:
2008     FunctionBodyNode(SourceElements*, DeclarationStacks::VarStack*, DeclarationStacks::FunctionStack*) KJS_FAST_CALL;
2009
2010     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
2011
2012     SymbolTable& symbolTable() KJS_FAST_CALL { return m_symbolTable; }
2013
2014     Vector<Identifier>& parameters() KJS_FAST_CALL { return m_parameters; }
2015     UString paramString() const KJS_FAST_CALL;
2016
2017   private:
2018     void initializeSymbolTable(ExecState*) KJS_FAST_CALL;
2019     ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
2020
2021     bool m_initialized;
2022     Vector<Identifier> m_parameters;
2023     SymbolTable m_symbolTable;
2024   };
2025
2026   class FuncExprNode : public ExpressionNode {
2027   public:
2028     FuncExprNode(const Identifier& i, FunctionBodyNode* b, ParameterNode* p = 0) KJS_FAST_CALL 
2029       : ident(i), param(p), body(b) { addParams(); }
2030     virtual JSValue *evaluate(ExecState*) KJS_FAST_CALL;
2031     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2032     virtual Precedence precedence() const { return PrecMember; }
2033   private:
2034     void addParams() KJS_FAST_CALL;
2035     // Used for streamTo
2036     friend class PropertyNode;
2037     Identifier ident;
2038     RefPtr<ParameterNode> param;
2039     RefPtr<FunctionBodyNode> body;
2040   };
2041
2042   class FuncDeclNode : public StatementNode {
2043   public:
2044     FuncDeclNode(const Identifier& i, FunctionBodyNode* b) KJS_FAST_CALL
2045       : ident(i), body(b) { addParams(); }
2046     FuncDeclNode(const Identifier& i, ParameterNode* p, FunctionBodyNode* b) KJS_FAST_CALL
2047       : ident(i), param(p), body(b) { addParams(); }
2048     virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
2049     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2050     ALWAYS_INLINE FunctionImp* makeFunction(ExecState*) KJS_FAST_CALL;
2051     Identifier ident;
2052   private:
2053     void addParams() KJS_FAST_CALL;
2054     RefPtr<ParameterNode> param;
2055     RefPtr<FunctionBodyNode> body;
2056   };
2057
2058     class CaseClauseNode : public Node {
2059   public:
2060       CaseClauseNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
2061       CaseClauseNode(ExpressionNode* e, SourceElements* children) KJS_FAST_CALL
2062       : expr(e), m_children(children) { }
2063       virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
2064       virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2065       virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2066
2067       JSValue* evaluate(ExecState*) KJS_FAST_CALL;
2068       JSValue* executeStatements(ExecState*) KJS_FAST_CALL;
2069
2070   private:
2071       RefPtr<ExpressionNode> expr;
2072       OwnPtr<SourceElements> m_children;
2073   };
2074   
2075     class ClauseListNode : public Node {
2076   public:
2077       ClauseListNode(CaseClauseNode* c) KJS_FAST_CALL : clause(c) { }
2078       ClauseListNode(ClauseListNode* n, CaseClauseNode* c) KJS_FAST_CALL
2079       : clause(c) { n->next = this; }
2080       virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
2081       CaseClauseNode* getClause() const KJS_FAST_CALL { return clause.get(); }
2082       ClauseListNode* getNext() const KJS_FAST_CALL { return next.get(); }
2083       virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2084       PassRefPtr<ClauseListNode> releaseNext() KJS_FAST_CALL { return next.release(); }
2085       virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2086   private:
2087       friend class CaseBlockNode;
2088       RefPtr<CaseClauseNode> clause;
2089       ListRefPtr<ClauseListNode> next;
2090   };
2091   
2092     class CaseBlockNode : public Node {
2093   public:
2094       CaseBlockNode(ClauseListNode* l1, CaseClauseNode* d, ClauseListNode* l2) KJS_FAST_CALL;
2095       virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
2096       JSValue* executeBlock(ExecState*, JSValue *input) KJS_FAST_CALL;
2097       virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2098       virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2099   private:
2100       RefPtr<ClauseListNode> list1;
2101       RefPtr<CaseClauseNode> def;
2102       RefPtr<ClauseListNode> list2;
2103   };
2104   
2105   class SwitchNode : public StatementNode {
2106   public:
2107       SwitchNode(ExpressionNode* e, CaseBlockNode *b) KJS_FAST_CALL : expr(e), block(b) { }
2108       virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
2109       virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
2110       virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2111   private:
2112       RefPtr<ExpressionNode> expr;
2113       RefPtr<CaseBlockNode> block;
2114   };
2115   
2116   struct ElementList {
2117       ElementNode* head;
2118       ElementNode* tail;
2119   };
2120
2121   struct PropertyList {
2122       PropertyListNode* head;
2123       PropertyListNode* tail;
2124   };
2125
2126   struct ArgumentList {
2127       ArgumentListNode* head;
2128       ArgumentListNode* tail;
2129   };
2130
2131   struct VarDeclList {
2132       VarDeclNode* head;
2133       VarDeclNode* tail;
2134   };
2135
2136   struct ParameterList {
2137       ParameterNode* head;
2138       ParameterNode* tail;
2139   };
2140
2141   struct ClauseList {
2142       ClauseListNode* head;
2143       ClauseListNode* tail;
2144   };
2145
2146 } // namespace
2147
2148 #endif