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