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