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