82c51206bdd62f7c451abdd84c221d4b35b857f7
[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, 2008 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 "RegisterID.h"
32 #include "SourceRange.h"
33 #include "SymbolTable.h"
34 #include <wtf/UnusedParam.h>
35 #include <wtf/ListRefPtr.h>
36 #include <wtf/MathExtras.h>
37 #include <wtf/OwnPtr.h>
38 #include <wtf/Vector.h>
39
40 #if PLATFORM(X86) && COMPILER(GCC)
41 #define KJS_FAST_CALL __attribute__((regparm(3)))
42 #else
43 #define KJS_FAST_CALL
44 #endif
45
46 namespace KJS {
47
48     class ArgumentsNode;
49     class CodeBlock;
50     class CodeGenerator;
51     class ConstDeclNode;
52     class FuncDeclNode;
53     class Node;
54     class EvalCodeBlock;
55     class ProgramCodeBlock;
56     class PropertyListNode;
57     class SourceStream;
58
59     enum Operator {
60         OpEqual,
61         OpPlusEq,
62         OpMinusEq,
63         OpMultEq,
64         OpDivEq,
65         OpPlusPlus,
66         OpMinusMinus,
67         OpAndEq,
68         OpXOrEq,
69         OpOrEq,
70         OpModEq,
71         OpLShift,
72         OpRShift,
73         OpURShift,
74     };
75
76     enum Precedence {
77         PrecPrimary,
78         PrecMember,
79         PrecCall,
80         PrecLeftHandSide,
81         PrecPostfix,
82         PrecUnary,
83         PrecMultiplicitave,
84         PrecAdditive,
85         PrecShift,
86         PrecRelational,
87         PrecEquality,
88         PrecBitwiseAnd,
89         PrecBitwiseXor,
90         PrecBitwiseOr,
91         PrecLogicalAnd,
92         PrecLogicalOr,
93         PrecConditional,
94         PrecAssignment,
95         PrecExpression
96     };
97
98     struct DeclarationStacks {
99         typedef Vector<Node*, 16> NodeStack;
100         enum { IsConstant = 1, HasInitializer = 2 } VarAttrs;
101         typedef Vector<std::pair<Identifier, unsigned>, 16> VarStack;
102         typedef Vector<RefPtr<FuncDeclNode>, 16> FunctionStack;
103
104         DeclarationStacks(ExecState* e, NodeStack& n, VarStack& v, FunctionStack& f)
105             : exec(e)
106             , nodeStack(n)
107             , varStack(v)
108             , functionStack(f)
109         {
110         }
111
112         ExecState* exec;
113         NodeStack& nodeStack;
114         VarStack& varStack;
115         FunctionStack& functionStack;
116     };
117
118     class ParserRefCounted : Noncopyable {
119     protected:
120         ParserRefCounted() KJS_FAST_CALL;
121         ParserRefCounted(PlacementNewAdoptType) KJS_FAST_CALL
122         {
123         }
124
125     public:
126         void ref() KJS_FAST_CALL;
127         void deref() KJS_FAST_CALL;
128         bool hasOneRef() KJS_FAST_CALL;
129
130         static void deleteNewObjects() KJS_FAST_CALL;
131
132         virtual ~ParserRefCounted();
133     };
134
135     class Node : public ParserRefCounted {
136     public:
137         typedef DeclarationStacks::NodeStack NodeStack;
138         typedef DeclarationStacks::VarStack VarStack;
139         typedef DeclarationStacks::FunctionStack FunctionStack;
140
141         Node() KJS_FAST_CALL;
142         Node(PlacementNewAdoptType placementAdopt) KJS_FAST_CALL
143             : ParserRefCounted(placementAdopt)
144         {
145         }
146
147         /*
148             Return value: The register holding the production's value.
149                      dst: An optional parameter specifying the most efficient
150                           destination at which to store the production's value.
151                           The callee must honor dst.
152
153             dst provides for a crude form of copy propagation. For example,
154
155             x = 1
156
157             becomes
158             
159             load r[x], 1
160             
161             instead of 
162
163             load r0, 1
164             mov r[x], r0
165             
166             because the assignment node, "x =", passes r[x] as dst to the number
167             node, "1".
168         */
169         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* dst = 0) KJS_FAST_CALL 
170         {
171             ASSERT_WITH_MESSAGE(0, "Don't know how to generate code for:\n%s\n", toString().ascii());
172             UNUSED_PARAM(dst); 
173             return 0; 
174         } // FIXME: Make this pure virtual.
175
176         UString toString() const KJS_FAST_CALL;
177         int lineNo() const KJS_FAST_CALL { return m_line; }
178
179         virtual bool isReturnNode() const KJS_FAST_CALL { return false; }
180
181         // Serialization.
182         virtual void streamTo(SourceStream&) const KJS_FAST_CALL = 0;
183         virtual Precedence precedence() const = 0;
184         virtual bool needsParensIfLeftmost() const { return false; }
185         
186     protected:
187         Node(JSType) KJS_FAST_CALL; // used by ExpressionNode
188
189         RegisterID* emitThrowError(CodeGenerator&, ErrorType, const char* msg);
190         RegisterID* emitThrowError(CodeGenerator&, ErrorType, const char* msg, const Identifier&);
191
192         int m_line : 28;
193         unsigned m_expectedReturnType : 3; // JSType
194     };
195
196     class ExpressionNode : public Node {
197     public:
198         ExpressionNode() KJS_FAST_CALL : Node() {}
199         ExpressionNode(JSType expectedReturn) KJS_FAST_CALL
200             : Node(expectedReturn)
201         {
202         }
203
204         // Special constructor for cases where we overwrite an object in place.
205         ExpressionNode(PlacementNewAdoptType) KJS_FAST_CALL
206             : Node(PlacementNewAdopt)
207         {
208         }
209
210         virtual bool isNumber() const KJS_FAST_CALL { return false; }
211         virtual bool isConstant() const KJS_FAST_CALL { return false; }        
212         virtual bool isLocation() const KJS_FAST_CALL { return false; }
213         virtual bool isResolveNode() const KJS_FAST_CALL { return false; }
214         virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return false; }
215         virtual bool isDotAccessorNode() const KJS_FAST_CALL { return false; }
216
217         JSType expectedReturnType() const KJS_FAST_CALL { return static_cast<JSType>(m_expectedReturnType); }
218
219         // This needs to be in public in order to compile using GCC 3.x 
220         typedef enum { EvalOperator, FunctionCall } CallerType;
221     };
222
223     class StatementNode : public Node {
224     public:
225         StatementNode() KJS_FAST_CALL;
226         void setLoc(int line0, int line1) KJS_FAST_CALL;
227         int firstLine() const KJS_FAST_CALL { return lineNo(); }
228         int lastLine() const KJS_FAST_CALL { return m_lastLine; }
229
230         virtual void pushLabel(const Identifier& ident) KJS_FAST_CALL { m_labelStack.push(ident); }
231         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
232         virtual bool isEmptyStatement() const KJS_FAST_CALL { return false; }
233
234     protected:
235         LabelStack m_labelStack;
236
237     private:
238         int m_lastLine;
239     };
240
241     class NullNode : public ExpressionNode {
242     public:
243         NullNode() KJS_FAST_CALL
244             : ExpressionNode(NullType)
245         {
246         }
247
248         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
249
250         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
251         virtual Precedence precedence() const { return PrecPrimary; }
252     };
253
254     class BooleanNode : public ExpressionNode {
255     public:
256         BooleanNode(bool value) KJS_FAST_CALL
257             : ExpressionNode(BooleanType)
258             , m_value(value)
259         {
260         }
261
262         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
263
264         virtual bool isConstant() const KJS_FAST_CALL { return true; }
265         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
266         virtual Precedence precedence() const { return PrecPrimary; }
267
268     protected:
269         bool m_value;
270     };
271
272     class NumberNode : public ExpressionNode {
273     public:
274         NumberNode(double v) KJS_FAST_CALL
275             : ExpressionNode(NumberType)
276             , m_double(v)
277         {
278         }
279
280         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
281
282         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
283         virtual Precedence precedence() const { return signbit(m_double) ? PrecUnary : PrecPrimary; }
284
285         virtual bool isNumber() const KJS_FAST_CALL { return true; }
286         virtual bool isConstant() const KJS_FAST_CALL { return true; }
287         double value() const KJS_FAST_CALL { return m_double; }
288         virtual void setValue(double d) KJS_FAST_CALL { m_double = d; }
289
290     protected:
291         double m_double;
292     };
293
294     class ImmediateNumberNode : public NumberNode {
295     public:
296         ImmediateNumberNode(JSValue* v, double d) KJS_FAST_CALL
297             : NumberNode(d)
298             , m_value(v)
299         {
300             ASSERT(v == JSImmediate::from(d));
301         }
302
303         virtual void setValue(double d) KJS_FAST_CALL { m_double = d; m_value = JSImmediate::from(d); ASSERT(m_value); }
304
305     private:
306         JSValue* m_value; // This is never a JSCell, only JSImmediate, thus no ProtectedPtr
307     };
308
309     class StringNode : public ExpressionNode {
310     public:
311         StringNode(const UString* v) KJS_FAST_CALL
312             : ExpressionNode(StringType)
313             , m_value(*v)
314         {
315         }
316
317         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
318
319         virtual bool isConstant() const KJS_FAST_CALL { return true; }
320         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
321         virtual Precedence precedence() const { return PrecPrimary; }
322
323     private:
324         UString m_value;
325     };
326
327     class RegExpNode : public ExpressionNode {
328     public:
329         RegExpNode(const UString& pattern, const UString& flags) KJS_FAST_CALL
330             : m_regExp(RegExp::create(pattern, flags))
331         {
332         }
333
334         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
335
336         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
337         virtual Precedence precedence() const { return PrecPrimary; }
338
339     private:
340         RefPtr<RegExp> m_regExp;
341     };
342
343     class ThisNode : public ExpressionNode {
344     public:
345         ThisNode() KJS_FAST_CALL
346         {
347         }
348
349         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
350
351         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
352         virtual Precedence precedence() const { return PrecPrimary; }
353     };
354
355     class ResolveNode : public ExpressionNode {
356     public:
357         ResolveNode(const Identifier& ident) KJS_FAST_CALL
358             : m_ident(ident)
359         {
360         }
361
362         // Special constructor for cases where we overwrite an object in place.
363         ResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
364             : ExpressionNode(PlacementNewAdopt)
365             , m_ident(PlacementNewAdopt)
366         {
367         }
368
369         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
370
371         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
372         virtual Precedence precedence() const { return PrecPrimary; }
373
374         virtual bool isLocation() const KJS_FAST_CALL { return true; }
375         virtual bool isResolveNode() const KJS_FAST_CALL { return true; }
376         const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
377
378     protected:
379         Identifier m_ident;
380         int m_index; // Used by LocalVarAccessNode and ScopedVarAccessNode.
381         size_t m_scopeDepth; // Used by ScopedVarAccessNode
382     };
383
384     class ElementNode : public Node {
385     public:
386         ElementNode(int elision, ExpressionNode* node) KJS_FAST_CALL
387             : m_elision(elision)
388             , m_node(node)
389         {
390         }
391
392         ElementNode(ElementNode* l, int elision, ExpressionNode* node) KJS_FAST_CALL
393             : m_elision(elision)
394             , m_node(node)
395         {
396             l->m_next = this;
397         }
398
399         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
400         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
401
402         PassRefPtr<ElementNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
403
404     private:
405         friend class ArrayNode;
406         ListRefPtr<ElementNode> m_next;
407         int m_elision;
408         RefPtr<ExpressionNode> m_node;
409     };
410
411     class ArrayNode : public ExpressionNode {
412     public:
413         ArrayNode(int elision) KJS_FAST_CALL
414             : m_elision(elision)
415             , m_optional(true)
416         {
417         }
418
419         ArrayNode(ElementNode* element) KJS_FAST_CALL
420             : m_element(element)
421             , m_elision(0)
422             , m_optional(false)
423         {
424         }
425
426         ArrayNode(int elision, ElementNode* element) KJS_FAST_CALL
427             : m_element(element)
428             , m_elision(elision)
429             , m_optional(true)
430         {
431         }
432
433         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
434
435         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
436         virtual Precedence precedence() const { return PrecPrimary; }
437
438     private:
439         RefPtr<ElementNode> m_element;
440         int m_elision;
441         bool m_optional;
442     };
443
444     class PropertyNode : public Node {
445     public:
446         enum Type { Constant, Getter, Setter };
447
448         PropertyNode(const Identifier& name, ExpressionNode* assign, Type type) KJS_FAST_CALL
449             : m_name(name)
450             , m_assign(assign)
451             , m_type(type)
452         {
453         }
454
455         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
456         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
457
458         const Identifier& name() const { return m_name; }
459
460     private:
461         friend class PropertyListNode;
462         Identifier m_name;
463         RefPtr<ExpressionNode> m_assign;
464         Type m_type;
465     };
466
467     class PropertyListNode : public Node {
468     public:
469         PropertyListNode(PropertyNode* node) KJS_FAST_CALL
470             : m_node(node)
471         {
472         }
473
474         PropertyListNode(PropertyNode* node, PropertyListNode* list) KJS_FAST_CALL
475             : m_node(node)
476         {
477             list->m_next = this;
478         }
479
480         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
481         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
482         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
483
484         PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
485
486     private:
487         friend class ObjectLiteralNode;
488         RefPtr<PropertyNode> m_node;
489         ListRefPtr<PropertyListNode> m_next;
490     };
491
492     class ObjectLiteralNode : public ExpressionNode {
493     public:
494         ObjectLiteralNode() KJS_FAST_CALL
495         {
496         }
497
498         ObjectLiteralNode(PropertyListNode* list) KJS_FAST_CALL
499             : m_list(list)
500         {
501         }
502
503         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
504         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
505         virtual Precedence precedence() const { return PrecPrimary; }
506         virtual bool needsParensIfLeftmost() const { return true; }
507
508     private:
509         RefPtr<PropertyListNode> m_list;
510     };
511
512     class BracketAccessorNode : public ExpressionNode {
513     public:
514         BracketAccessorNode(ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments) KJS_FAST_CALL
515             : m_base(base)
516             , m_subscript(subscript)
517             , m_subscriptHasAssignments(subscriptHasAssignments)
518         {
519         }
520
521         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
522
523         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
524         virtual Precedence precedence() const { return PrecMember; }
525
526         virtual bool isLocation() const KJS_FAST_CALL { return true; }
527         virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return true; }
528         ExpressionNode* base() KJS_FAST_CALL { return m_base.get(); }
529         ExpressionNode* subscript() KJS_FAST_CALL { return m_subscript.get(); }
530
531     private:
532         RefPtr<ExpressionNode> m_base;
533         RefPtr<ExpressionNode> m_subscript;
534         bool m_subscriptHasAssignments;
535     };
536
537     class DotAccessorNode : public ExpressionNode {
538     public:
539         DotAccessorNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
540             : m_base(base)
541             , m_ident(ident)
542         {
543         }
544
545         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
546         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
547         virtual Precedence precedence() const { return PrecMember; }
548
549         virtual bool isLocation() const KJS_FAST_CALL { return true; }
550         virtual bool isDotAccessorNode() const KJS_FAST_CALL { return true; }
551         ExpressionNode* base() const KJS_FAST_CALL { return m_base.get(); }
552         const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
553
554     private:
555         RefPtr<ExpressionNode> m_base;
556         Identifier m_ident;
557     };
558
559     class ArgumentListNode : public Node {
560     public:
561         ArgumentListNode(ExpressionNode* expr) KJS_FAST_CALL
562             : m_expr(expr)
563         {
564         }
565
566         ArgumentListNode(ArgumentListNode* listNode, ExpressionNode* expr) KJS_FAST_CALL
567             : m_expr(expr)
568         {
569             listNode->m_next = this;
570         }
571
572         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
573         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
574         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
575
576         PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
577
578         ListRefPtr<ArgumentListNode> m_next;
579         RefPtr<ExpressionNode> m_expr;
580     };
581
582     class ArgumentsNode : public Node {
583     public:
584         ArgumentsNode() KJS_FAST_CALL
585         {
586         }
587
588         ArgumentsNode(ArgumentListNode* listNode) KJS_FAST_CALL
589             : m_listNode(listNode)
590         {
591         }
592
593         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
594         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
595
596         RefPtr<ArgumentListNode> m_listNode;
597     };
598
599     class NewExprNode : public ExpressionNode {
600     public:
601         NewExprNode(ExpressionNode* expr) KJS_FAST_CALL
602             : m_expr(expr)
603         {
604         }
605
606         NewExprNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
607             : m_expr(expr)
608             , m_args(args)
609         {
610         }
611
612         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
613
614         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
615         virtual Precedence precedence() const { return PrecLeftHandSide; }
616
617     private:
618         RefPtr<ExpressionNode> m_expr;
619         RefPtr<ArgumentsNode> m_args;
620     };
621
622     class EvalFunctionCallNode : public ExpressionNode {
623     public:
624         EvalFunctionCallNode(ArgumentsNode* args) KJS_FAST_CALL
625             : m_args(args)
626         {
627         }
628
629         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
630         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
631         virtual Precedence precedence() const { return PrecCall; }
632
633     private:
634         RefPtr<ArgumentsNode> m_args;
635     };
636
637     class FunctionCallValueNode : public ExpressionNode {
638     public:
639         FunctionCallValueNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
640             : m_expr(expr)
641             , m_args(args)
642         {
643         }
644
645         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
646         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
647         virtual Precedence precedence() const { return PrecCall; }
648
649     private:
650         RefPtr<ExpressionNode> m_expr;
651         RefPtr<ArgumentsNode> m_args;
652     };
653
654     class FunctionCallResolveNode : public ExpressionNode {
655     public:
656         FunctionCallResolveNode(const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
657             : m_ident(ident)
658             , m_args(args)
659         {
660         }
661
662         FunctionCallResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
663             : ExpressionNode(PlacementNewAdopt)
664             , m_ident(PlacementNewAdopt)
665             , m_args(PlacementNewAdopt)
666         {
667         }
668
669         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
670
671         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
672         virtual Precedence precedence() const { return PrecCall; }
673
674     protected:
675         Identifier m_ident;
676         RefPtr<ArgumentsNode> m_args;
677         size_t m_index; // Used by LocalVarFunctionCallNode.
678         size_t m_scopeDepth; // Used by ScopedVarFunctionCallNode and NonLocalVarFunctionCallNode
679     };
680     
681     class FunctionCallBracketNode : public ExpressionNode {
682     public:
683         FunctionCallBracketNode(ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args) KJS_FAST_CALL
684             : m_base(base)
685             , m_subscript(subscript)
686             , m_args(args)
687         {
688         }
689
690         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
691         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
692         virtual Precedence precedence() const { return PrecCall; }
693
694     protected:
695         RefPtr<ExpressionNode> m_base;
696         RefPtr<ExpressionNode> m_subscript;
697         RefPtr<ArgumentsNode> m_args;
698     };
699
700     class FunctionCallDotNode : public ExpressionNode {
701     public:
702         FunctionCallDotNode(ExpressionNode* base, const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
703             : m_base(base)
704             , m_ident(ident)
705             , m_args(args)
706         {
707         }
708
709         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
710         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
711         virtual Precedence precedence() const { return PrecCall; }
712
713     private:
714         RefPtr<ExpressionNode> m_base;
715         Identifier m_ident;
716         RefPtr<ArgumentsNode> m_args;
717     };
718
719     class PrePostResolveNode : public ExpressionNode {
720     public:
721         PrePostResolveNode(const Identifier& ident) KJS_FAST_CALL
722             : ExpressionNode(NumberType)
723             , m_ident(ident)
724         {
725         }
726
727         PrePostResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
728             : ExpressionNode(PlacementNewAdopt)
729             , m_ident(PlacementNewAdopt)
730         {
731         }
732
733     protected:
734         Identifier m_ident;
735         size_t m_index; // Used by LocalVarPostfixNode.
736     };
737
738     class PostIncResolveNode : public PrePostResolveNode {
739     public:
740         PostIncResolveNode(const Identifier& ident) KJS_FAST_CALL
741             : PrePostResolveNode(ident)
742         {
743         }
744
745         PostIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
746             : PrePostResolveNode(PlacementNewAdopt)
747         {
748         }
749
750         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
751         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
752         virtual Precedence precedence() const { return PrecPostfix; }
753     };
754
755     class PostDecResolveNode : public PrePostResolveNode {
756     public:
757         PostDecResolveNode(const Identifier& ident) KJS_FAST_CALL
758             : PrePostResolveNode(ident)
759         {
760         }
761
762         PostDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
763             : PrePostResolveNode(PlacementNewAdopt)
764         {
765         }
766
767         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
768
769         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
770         virtual Precedence precedence() const { return PrecPostfix; }
771     };
772
773     class PostfixBracketNode : public ExpressionNode {
774     public:
775         PostfixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
776             : m_base(base)
777             , m_subscript(subscript)
778         {
779         }
780
781         virtual Precedence precedence() const { return PrecPostfix; }
782
783     protected:
784         RefPtr<ExpressionNode> m_base;
785         RefPtr<ExpressionNode> m_subscript;
786     };
787
788     class PostIncBracketNode : public PostfixBracketNode {
789     public:
790         PostIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
791             : PostfixBracketNode(base, subscript)
792         {
793         }
794
795         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
796
797         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
798     };
799
800     class PostDecBracketNode : public PostfixBracketNode {
801     public:
802         PostDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
803             : PostfixBracketNode(base, subscript)
804         {
805         }
806
807         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
808
809         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
810     };
811
812     class PostfixDotNode : public ExpressionNode {
813     public:
814         PostfixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
815             : m_base(base)
816             , m_ident(ident)
817         {
818         }
819
820         virtual Precedence precedence() const { return PrecPostfix; }
821
822     protected:
823         RefPtr<ExpressionNode> m_base;
824         Identifier m_ident;
825     };
826
827     class PostIncDotNode : public PostfixDotNode {
828     public:
829         PostIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
830             : PostfixDotNode(base, ident)
831         {
832         }
833
834         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
835
836         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
837     };
838
839     class PostDecDotNode : public PostfixDotNode {
840     public:
841         PostDecDotNode(ExpressionNode*  base, const Identifier& ident) KJS_FAST_CALL
842             : PostfixDotNode(base, ident)
843         {
844         }
845
846         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
847
848         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
849     };
850
851     class PostfixErrorNode : public ExpressionNode {
852     public:
853         PostfixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL
854             : m_expr(expr)
855             , m_operator(oper)
856         {
857         }
858
859         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
860         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
861         virtual Precedence precedence() const { return PrecPostfix; }
862
863     private:
864         RefPtr<ExpressionNode> m_expr;
865         Operator m_operator;
866     };
867
868     class DeleteResolveNode : public ExpressionNode {
869     public:
870         DeleteResolveNode(const Identifier& ident) KJS_FAST_CALL
871             : m_ident(ident)
872         {
873         }
874
875         DeleteResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
876             : ExpressionNode(PlacementNewAdopt)
877             , m_ident(PlacementNewAdopt)
878         {
879         }
880
881         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
882
883         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
884         virtual Precedence precedence() const { return PrecUnary; }
885
886     private:
887         Identifier m_ident;
888     };
889
890     class DeleteBracketNode : public ExpressionNode {
891     public:
892         DeleteBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
893             : m_base(base)
894             , m_subscript(subscript)
895         {
896         }
897
898         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
899
900         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
901         virtual Precedence precedence() const { return PrecUnary; }
902
903     private:
904         RefPtr<ExpressionNode> m_base;
905         RefPtr<ExpressionNode> m_subscript;
906     };
907
908     class DeleteDotNode : public ExpressionNode {
909     public:
910         DeleteDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
911             : m_base(base)
912             , m_ident(ident)
913         {
914         }
915
916         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
917
918         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
919         virtual Precedence precedence() const { return PrecUnary; }
920
921     private:
922         RefPtr<ExpressionNode> m_base;
923         Identifier m_ident;
924     };
925
926     class DeleteValueNode : public ExpressionNode {
927     public:
928         DeleteValueNode(ExpressionNode* expr) KJS_FAST_CALL
929             : m_expr(expr)
930         {
931         }
932
933         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
934
935         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
936         virtual Precedence precedence() const { return PrecUnary; }
937
938     private:
939         RefPtr<ExpressionNode> m_expr;
940     };
941
942     class VoidNode : public ExpressionNode {
943     public:
944         VoidNode(ExpressionNode* expr) KJS_FAST_CALL
945             : m_expr(expr)
946         {
947         }
948
949         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
950
951         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
952         virtual Precedence precedence() const { return PrecUnary; }
953
954     private:
955         RefPtr<ExpressionNode> m_expr;
956     };
957
958     class TypeOfResolveNode : public ExpressionNode {
959     public:
960         TypeOfResolveNode(const Identifier& ident) KJS_FAST_CALL
961             : ExpressionNode(StringType)
962             , m_ident(ident)
963         {
964         }
965
966         TypeOfResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
967             : ExpressionNode(PlacementNewAdopt)
968             , m_ident(PlacementNewAdopt)
969         {
970             m_expectedReturnType = StringType;
971         }
972
973         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
974
975         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
976         virtual Precedence precedence() const { return PrecUnary; }
977
978         const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
979
980     protected:
981         Identifier m_ident;
982         size_t m_index; // Used by LocalTypeOfNode.
983     };
984
985     class TypeOfValueNode : public ExpressionNode {
986     public:
987         TypeOfValueNode(ExpressionNode* expr) KJS_FAST_CALL
988             : ExpressionNode(StringType)
989             , m_expr(expr)
990         {
991         }
992
993         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
994
995         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
996         virtual Precedence precedence() const { return PrecUnary; }
997
998     private:
999         RefPtr<ExpressionNode> m_expr;
1000     };
1001
1002     class PreIncResolveNode : public PrePostResolveNode {
1003     public:
1004         PreIncResolveNode(const Identifier& ident) KJS_FAST_CALL
1005             : PrePostResolveNode(ident)
1006         {
1007         }
1008
1009         PreIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
1010             : PrePostResolveNode(PlacementNewAdopt)
1011         {
1012         }
1013
1014         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1015
1016         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1017         virtual Precedence precedence() const { return PrecUnary; }
1018     };
1019
1020     class PreDecResolveNode : public PrePostResolveNode {
1021     public:
1022         PreDecResolveNode(const Identifier& ident) KJS_FAST_CALL
1023             : PrePostResolveNode(ident)
1024         {
1025         }
1026
1027         PreDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
1028             : PrePostResolveNode(PlacementNewAdopt)
1029         {
1030         }
1031
1032         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1033
1034         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1035         virtual Precedence precedence() const { return PrecUnary; }
1036     };
1037
1038     class PrefixBracketNode : public ExpressionNode {
1039     public:
1040         PrefixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
1041             : m_base(base)
1042             , m_subscript(subscript)
1043         {
1044         }
1045
1046         virtual Precedence precedence() const { return PrecUnary; }
1047
1048     protected:
1049         RefPtr<ExpressionNode> m_base;
1050         RefPtr<ExpressionNode> m_subscript;
1051     };
1052
1053     class PreIncBracketNode : public PrefixBracketNode {
1054     public:
1055         PreIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
1056             : PrefixBracketNode(base, subscript)
1057         {
1058         }
1059
1060         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1061
1062         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1063     };
1064
1065     class PreDecBracketNode : public PrefixBracketNode {
1066     public:
1067         PreDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
1068             : PrefixBracketNode(base, subscript)
1069         {
1070         }
1071
1072         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1073
1074         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1075     };
1076
1077     class PrefixDotNode : public ExpressionNode {
1078     public:
1079         PrefixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
1080             : m_base(base)
1081             , m_ident(ident)
1082         {
1083         }
1084
1085         virtual Precedence precedence() const { return PrecPostfix; }
1086
1087     protected:
1088         RefPtr<ExpressionNode> m_base;
1089         Identifier m_ident;
1090     };
1091
1092     class PreIncDotNode : public PrefixDotNode {
1093     public:
1094         PreIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
1095             : PrefixDotNode(base, ident)
1096         {
1097         }
1098
1099         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1100
1101         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1102     };
1103
1104     class PreDecDotNode : public PrefixDotNode {
1105     public:
1106         PreDecDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
1107             : PrefixDotNode(base, ident)
1108         {
1109         }
1110
1111         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1112
1113         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1114     };
1115
1116     class PrefixErrorNode : public ExpressionNode {
1117     public:
1118         PrefixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL
1119             : m_expr(expr)
1120             , m_operator(oper)
1121         {
1122         }
1123
1124         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1125         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1126         virtual Precedence precedence() const { return PrecUnary; }
1127
1128     private:
1129         RefPtr<ExpressionNode> m_expr;
1130         Operator m_operator;
1131     };
1132
1133     class UnaryPlusNode : public ExpressionNode {
1134     public:
1135         UnaryPlusNode(ExpressionNode* expr) KJS_FAST_CALL
1136             : ExpressionNode(NumberType)
1137             , m_expr(expr)
1138         {
1139         }
1140
1141         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1142         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1143         virtual Precedence precedence() const { return PrecUnary; }
1144
1145     private:
1146         RefPtr<ExpressionNode> m_expr;
1147     };
1148
1149     class NegateNode : public ExpressionNode {
1150     public:
1151         NegateNode(ExpressionNode* expr) KJS_FAST_CALL
1152             : ExpressionNode(NumberType)
1153             , m_expr(expr)
1154         {
1155         }
1156
1157         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1158         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1159         virtual Precedence precedence() const { return PrecUnary; }
1160
1161     private:
1162         RefPtr<ExpressionNode> m_expr;
1163     };
1164
1165     class BitwiseNotNode : public ExpressionNode {
1166     public:
1167         BitwiseNotNode(ExpressionNode* expr) KJS_FAST_CALL
1168             : ExpressionNode(NumberType)
1169             , m_expr(expr)
1170         {
1171         }
1172
1173         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1174         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1175         virtual Precedence precedence() const { return PrecUnary; }
1176
1177     private:
1178         RefPtr<ExpressionNode> m_expr;
1179     };
1180
1181     class LogicalNotNode : public ExpressionNode {
1182     public:
1183         LogicalNotNode(ExpressionNode* expr) KJS_FAST_CALL
1184             : ExpressionNode(BooleanType)
1185             , m_expr(expr)
1186         {
1187         }
1188
1189         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1190         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1191         virtual Precedence precedence() const { return PrecUnary; }
1192
1193     private:
1194         RefPtr<ExpressionNode> m_expr;
1195     };
1196
1197     class MultNode : public ExpressionNode {
1198     public:
1199         MultNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1200             : ExpressionNode(NumberType)
1201             , m_term1(term1)
1202             , m_term2(term2)
1203         {
1204         }
1205
1206         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1207         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1208         virtual Precedence precedence() const { return PrecMultiplicitave; }
1209
1210     private:
1211         RefPtr<ExpressionNode> m_term1;
1212         RefPtr<ExpressionNode> m_term2;
1213     };
1214
1215     class DivNode : public ExpressionNode {
1216     public:
1217         DivNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1218             : ExpressionNode(NumberType)
1219             , m_term1(term1)
1220             , m_term2(term2)
1221         {
1222         }
1223
1224         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1225         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1226         virtual Precedence precedence() const { return PrecMultiplicitave; }
1227
1228     private:
1229         RefPtr<ExpressionNode> m_term1;
1230         RefPtr<ExpressionNode> m_term2;
1231     };
1232
1233     class ModNode : public ExpressionNode {
1234     public:
1235         ModNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1236             : ExpressionNode(NumberType)
1237             , m_term1(term1)
1238             , m_term2(term2)
1239         {
1240         }
1241
1242         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1243         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1244         virtual Precedence precedence() const { return PrecMultiplicitave; }
1245
1246     private:
1247         RefPtr<ExpressionNode> m_term1;
1248         RefPtr<ExpressionNode> m_term2;
1249     };
1250
1251     class AddNode : public ExpressionNode {
1252     public:
1253         AddNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
1254             : m_term1(term1)
1255             , m_term2(term2)
1256             , m_rightHasAssignments(rightHasAssignments)
1257         {
1258         }
1259
1260         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1261         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1262         virtual Precedence precedence() const { return PrecAdditive; }
1263
1264     protected:
1265         AddNode(ExpressionNode* term1, ExpressionNode* term2, JSType expectedReturn, bool rightHasAssignments) KJS_FAST_CALL
1266             : ExpressionNode(expectedReturn)
1267             , m_term1(term1)
1268             , m_term2(term2)
1269             , m_rightHasAssignments(rightHasAssignments)
1270         {
1271         }
1272
1273         RefPtr<ExpressionNode> m_term1;
1274         RefPtr<ExpressionNode> m_term2;
1275         bool m_rightHasAssignments;
1276     };
1277
1278     class SubNode : public ExpressionNode {
1279     public:
1280         SubNode(ExpressionNode* term1, ExpressionNode* term2, bool rightHasAssignments) KJS_FAST_CALL
1281             : ExpressionNode(NumberType)
1282             , m_term1(term1)
1283             , m_term2(term2)
1284             , m_rightHasAssignments(rightHasAssignments)
1285         {
1286         }
1287
1288         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1289         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1290         virtual Precedence precedence() const { return PrecAdditive; }
1291
1292     private:
1293         RefPtr<ExpressionNode> m_term1;
1294         RefPtr<ExpressionNode> m_term2;
1295         bool m_rightHasAssignments;
1296     };
1297
1298     class LeftShiftNode : public ExpressionNode {
1299     public:
1300         LeftShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1301             : ExpressionNode(NumberType)
1302             , m_term1(term1)
1303             , m_term2(term2)
1304         {
1305         }
1306
1307         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1308         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1309         virtual Precedence precedence() const { return PrecShift; }
1310
1311     private:
1312         RefPtr<ExpressionNode> m_term1;
1313         RefPtr<ExpressionNode> m_term2;
1314     };
1315
1316     class RightShiftNode : public ExpressionNode {
1317     public:
1318         RightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1319             : ExpressionNode(NumberType)
1320             , m_term1(term1)
1321             , m_term2(term2)
1322         {
1323         }
1324
1325         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1326         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1327         virtual Precedence precedence() const { return PrecShift; }
1328
1329     private:
1330         RefPtr<ExpressionNode> m_term1;
1331         RefPtr<ExpressionNode> m_term2;
1332     };
1333
1334     class UnsignedRightShiftNode : public ExpressionNode {
1335     public:
1336         UnsignedRightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1337             : ExpressionNode(NumberType)
1338             , m_term1(term1)
1339             , m_term2(term2)
1340         {
1341         }
1342
1343         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1344         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1345         virtual Precedence precedence() const { return PrecShift; }
1346
1347     private:
1348         RefPtr<ExpressionNode> m_term1;
1349         RefPtr<ExpressionNode> m_term2;
1350     };
1351
1352     class LessNode : public ExpressionNode {
1353     public:
1354         LessNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1355             : ExpressionNode(BooleanType)
1356             , m_expr1(expr1)
1357             , m_expr2(expr2)
1358         {
1359         }
1360
1361         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1362         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1363         virtual Precedence precedence() const { return PrecRelational; }
1364
1365     protected:
1366         RefPtr<ExpressionNode> m_expr1;
1367         RefPtr<ExpressionNode> m_expr2;
1368     };
1369
1370     class GreaterNode : public ExpressionNode {
1371     public:
1372         GreaterNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1373             : m_expr1(expr1)
1374             , m_expr2(expr2)
1375         {
1376         }
1377
1378         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1379         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1380         virtual Precedence precedence() const { return PrecRelational; }
1381
1382     private:
1383         RefPtr<ExpressionNode> m_expr1;
1384         RefPtr<ExpressionNode> m_expr2;
1385     };
1386
1387     class LessEqNode : public ExpressionNode {
1388     public:
1389         LessEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1390             : m_expr1(expr1)
1391             , m_expr2(expr2)
1392         {
1393         }
1394
1395         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1396         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1397         virtual Precedence precedence() const { return PrecRelational; }
1398
1399     private:
1400         RefPtr<ExpressionNode> m_expr1;
1401         RefPtr<ExpressionNode> m_expr2;
1402     };
1403
1404     class GreaterEqNode : public ExpressionNode {
1405     public:
1406         GreaterEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1407             : m_expr1(expr1)
1408             , m_expr2(expr2)
1409         {
1410         }
1411
1412         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1413         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1414         virtual Precedence precedence() const { return PrecRelational; }
1415
1416     private:
1417         RefPtr<ExpressionNode> m_expr1;
1418         RefPtr<ExpressionNode> m_expr2;
1419     };
1420
1421     class InstanceOfNode : public ExpressionNode {
1422     public:
1423         InstanceOfNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1424             : ExpressionNode(BooleanType)
1425             , m_expr1(expr1)
1426             , m_expr2(expr2)
1427         {
1428         }
1429
1430         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1431         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1432         virtual Precedence precedence() const { return PrecRelational; }
1433
1434     private:
1435         RefPtr<ExpressionNode> m_expr1;
1436         RefPtr<ExpressionNode> m_expr2;
1437     };
1438
1439     class InNode : public ExpressionNode {
1440     public:
1441         InNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1442             : m_expr1(expr1)
1443             , m_expr2(expr2)
1444         {
1445         }
1446
1447         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1448
1449         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1450         virtual Precedence precedence() const { return PrecRelational; }
1451
1452     private:
1453         RefPtr<ExpressionNode> m_expr1;
1454         RefPtr<ExpressionNode> m_expr2;
1455     };
1456
1457     class EqualNode : public ExpressionNode {
1458     public:
1459         EqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1460             : ExpressionNode(BooleanType)
1461             , m_expr1(expr1)
1462             , m_expr2(expr2)
1463         {
1464         }
1465
1466         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1467         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1468         virtual Precedence precedence() const { return PrecEquality; }
1469
1470     private:
1471         RefPtr<ExpressionNode> m_expr1;
1472         RefPtr<ExpressionNode> m_expr2;
1473     };
1474
1475     class NotEqualNode : public ExpressionNode {
1476     public:
1477         NotEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1478             : ExpressionNode(BooleanType)
1479             , m_expr1(expr1)
1480             , m_expr2(expr2)
1481         {
1482         }
1483
1484         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1485         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1486         virtual Precedence precedence() const { return PrecEquality; }
1487
1488     private:
1489         RefPtr<ExpressionNode> m_expr1;
1490         RefPtr<ExpressionNode> m_expr2;
1491     };
1492
1493     class StrictEqualNode : public ExpressionNode {
1494     public:
1495         StrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1496             : ExpressionNode(BooleanType)
1497             , m_expr1(expr1)
1498             , m_expr2(expr2)
1499         {
1500         }
1501
1502         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1503         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1504         virtual Precedence precedence() const { return PrecEquality; }
1505
1506     private:
1507         RefPtr<ExpressionNode> m_expr1;
1508         RefPtr<ExpressionNode> m_expr2;
1509     };
1510
1511     class NotStrictEqualNode : public ExpressionNode {
1512     public:
1513         NotStrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1514             : ExpressionNode(BooleanType)
1515             , m_expr1(expr1)
1516             , m_expr2(expr2)
1517         {
1518         }
1519
1520         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1521         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1522         virtual Precedence precedence() const { return PrecEquality; }
1523
1524     private:
1525         RefPtr<ExpressionNode> m_expr1;
1526         RefPtr<ExpressionNode> m_expr2;
1527     };
1528
1529     class BitAndNode : public ExpressionNode {
1530     public:
1531         BitAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1532             : ExpressionNode(NumberType)
1533             , m_expr1(expr1)
1534             , m_expr2(expr2)
1535         {
1536         }
1537
1538         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1539         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1540         virtual Precedence precedence() const { return PrecBitwiseAnd; }
1541
1542     private:
1543         RefPtr<ExpressionNode> m_expr1;
1544         RefPtr<ExpressionNode> m_expr2;
1545     };
1546
1547     class BitOrNode : public ExpressionNode {
1548     public:
1549         BitOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1550             : ExpressionNode(NumberType)
1551             , m_expr1(expr1)
1552             , m_expr2(expr2)
1553         {
1554         }
1555
1556         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1557         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1558         virtual Precedence precedence() const { return PrecBitwiseOr; }
1559
1560     private:
1561         RefPtr<ExpressionNode> m_expr1;
1562         RefPtr<ExpressionNode> m_expr2;
1563     };
1564
1565     class BitXOrNode : public ExpressionNode {
1566     public:
1567         BitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1568             : ExpressionNode(NumberType)
1569             , m_expr1(expr1)
1570             , m_expr2(expr2)
1571         {
1572         }
1573
1574         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1575         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1576         virtual Precedence precedence() const { return PrecBitwiseXor; }
1577
1578     private:
1579         RefPtr<ExpressionNode> m_expr1;
1580         RefPtr<ExpressionNode> m_expr2;
1581     };
1582
1583     /**
1584      * m_expr1 && m_expr2, m_expr1 || m_expr2
1585      */
1586     class LogicalAndNode : public ExpressionNode {
1587     public:
1588         LogicalAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1589             : ExpressionNode(BooleanType)
1590             , m_expr1(expr1)
1591             , m_expr2(expr2)
1592         {
1593         }
1594
1595         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1596         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1597         virtual Precedence precedence() const { return PrecLogicalAnd; }
1598
1599     private:
1600         RefPtr<ExpressionNode> m_expr1;
1601         RefPtr<ExpressionNode> m_expr2;
1602     };
1603
1604     class LogicalOrNode : public ExpressionNode {
1605     public:
1606         LogicalOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1607             : ExpressionNode(BooleanType)
1608             , m_expr1(expr1)
1609             , m_expr2(expr2)
1610         {
1611         }
1612
1613         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1614         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1615         virtual Precedence precedence() const { return PrecLogicalOr; }
1616
1617     private:
1618         RefPtr<ExpressionNode> m_expr1;
1619         RefPtr<ExpressionNode> m_expr2;
1620     };
1621
1622     /**
1623      * The ternary operator, "m_logical ? m_expr1 : m_expr2"
1624      */
1625     class ConditionalNode : public ExpressionNode {
1626     public:
1627         ConditionalNode(ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1628             : m_logical(logical)
1629             , m_expr1(expr1)
1630             , m_expr2(expr2)
1631         {
1632         }
1633
1634         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1635         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1636         virtual Precedence precedence() const { return PrecConditional; }
1637
1638     private:
1639         RefPtr<ExpressionNode> m_logical;
1640         RefPtr<ExpressionNode> m_expr1;
1641         RefPtr<ExpressionNode> m_expr2;
1642     };
1643
1644     class ReadModifyResolveNode : public ExpressionNode {
1645     public:
1646         ReadModifyResolveNode(const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments) KJS_FAST_CALL
1647             : m_ident(ident)
1648             , m_right(right)
1649             , m_operator(oper)
1650             , m_rightHasAssignments(rightHasAssignments)
1651         {
1652         }
1653
1654         ReadModifyResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
1655             : ExpressionNode(PlacementNewAdopt)
1656             , m_ident(PlacementNewAdopt)
1657             , m_right(PlacementNewAdopt)
1658             , m_rightHasAssignments(true)
1659         {
1660         }
1661
1662         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1663
1664         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1665         virtual Precedence precedence() const { return PrecAssignment; }
1666
1667     protected:
1668         Identifier m_ident;
1669         RefPtr<ExpressionNode> m_right;
1670         size_t m_index; // Used by ReadModifyLocalVarNode.
1671         Operator m_operator : 31;
1672         bool m_rightHasAssignments : 1;
1673     };
1674
1675     class AssignResolveNode : public ExpressionNode {
1676     public:
1677         AssignResolveNode(const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
1678             : m_ident(ident)
1679             , m_right(right)
1680             , m_rightHasAssignments(rightHasAssignments)
1681         {
1682         }
1683
1684         AssignResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
1685             : ExpressionNode(PlacementNewAdopt)
1686             , m_ident(PlacementNewAdopt)
1687             , m_right(PlacementNewAdopt)
1688         {
1689         }
1690         
1691         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1692
1693         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1694         virtual Precedence precedence() const { return PrecAssignment; }
1695
1696     protected:
1697         Identifier m_ident;
1698         RefPtr<ExpressionNode> m_right;
1699         size_t m_index; // Used by ReadModifyLocalVarNode.
1700         bool m_rightHasAssignments;
1701     };
1702
1703     class ReadModifyBracketNode : public ExpressionNode {
1704     public:
1705         ReadModifyBracketNode(ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments) KJS_FAST_CALL
1706             : m_base(base)
1707             , m_subscript(subscript)
1708             , m_right(right)
1709             , m_operator(oper)
1710             , m_subscriptHasAssignments(subscriptHasAssignments)
1711             , m_rightHasAssignments(rightHasAssignments)
1712         {
1713         }
1714
1715         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1716
1717         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1718         virtual Precedence precedence() const { return PrecAssignment; }
1719
1720     protected:
1721         RefPtr<ExpressionNode> m_base;
1722         RefPtr<ExpressionNode> m_subscript;
1723         RefPtr<ExpressionNode> m_right;
1724         Operator m_operator : 30;
1725         bool m_subscriptHasAssignments : 1;
1726         bool m_rightHasAssignments : 1;
1727     };
1728
1729     class AssignBracketNode : public ExpressionNode {
1730     public:
1731         AssignBracketNode(ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments) KJS_FAST_CALL
1732             : m_base(base)
1733             , m_subscript(subscript)
1734             , m_right(right)
1735             , m_subscriptHasAssignments(subscriptHasAssignments)
1736             , m_rightHasAssignments(rightHasAssignments)
1737         {
1738         }
1739
1740         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1741
1742         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1743         virtual Precedence precedence() const { return PrecAssignment; }
1744
1745     protected:
1746         RefPtr<ExpressionNode> m_base;
1747         RefPtr<ExpressionNode> m_subscript;
1748         RefPtr<ExpressionNode> m_right;
1749         bool m_subscriptHasAssignments : 1;
1750         bool m_rightHasAssignments : 1;
1751     };
1752
1753     class AssignDotNode : public ExpressionNode {
1754     public:
1755         AssignDotNode(ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
1756             : m_base(base)
1757             , m_ident(ident)
1758             , m_right(right)
1759             , m_rightHasAssignments(rightHasAssignments)
1760         {
1761         }
1762
1763         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1764         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1765         virtual Precedence precedence() const { return PrecAssignment; }
1766
1767     protected:
1768         RefPtr<ExpressionNode> m_base;
1769         Identifier m_ident;
1770         RefPtr<ExpressionNode> m_right;
1771         bool m_rightHasAssignments;
1772     };
1773
1774     class ReadModifyDotNode : public ExpressionNode {
1775     public:
1776         ReadModifyDotNode(ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
1777             : m_base(base)
1778             , m_ident(ident)
1779             , m_right(right)
1780             , m_operator(oper)
1781             , m_rightHasAssignments(rightHasAssignments)
1782         {
1783         }
1784
1785         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1786
1787         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1788         virtual Precedence precedence() const { return PrecAssignment; }
1789
1790     protected:
1791         RefPtr<ExpressionNode> m_base;
1792         Identifier m_ident;
1793         RefPtr<ExpressionNode> m_right;
1794         Operator m_operator : 31;
1795         bool m_rightHasAssignments : 1;
1796     };
1797
1798     class AssignErrorNode : public ExpressionNode {
1799     public:
1800         AssignErrorNode(ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL
1801             : m_left(left)
1802             , m_operator(oper)
1803             , m_right(right)
1804         {
1805         }
1806
1807         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1808         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1809         virtual Precedence precedence() const { return PrecAssignment; }
1810
1811     protected:
1812         RefPtr<ExpressionNode> m_left;
1813         Operator m_operator;
1814         RefPtr<ExpressionNode> m_right;
1815     };
1816
1817     class CommaNode : public ExpressionNode {
1818     public:
1819         CommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1820             : m_expr1(expr1)
1821             , m_expr2(expr2)
1822         {
1823         }
1824
1825         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1826         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1827         virtual Precedence precedence() const { return PrecExpression; }
1828
1829     private:
1830         RefPtr<ExpressionNode> m_expr1;
1831         RefPtr<ExpressionNode> m_expr2;
1832     };
1833     
1834     class VarDeclCommaNode : public CommaNode {
1835     public:
1836         VarDeclCommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1837             : CommaNode(expr1, expr2)
1838         {
1839         }
1840         virtual Precedence precedence() const { return PrecAssignment; }
1841     };
1842
1843     class ConstDeclNode : public ExpressionNode {
1844     public:
1845         ConstDeclNode(const Identifier& ident, ExpressionNode* in) KJS_FAST_CALL;
1846
1847         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1848         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
1849         PassRefPtr<ConstDeclNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
1850
1851         Identifier m_ident;
1852         ListRefPtr<ConstDeclNode> m_next;
1853         RefPtr<ExpressionNode> m_init;
1854         
1855         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1856         virtual RegisterID* emitCodeSingle(CodeGenerator&) KJS_FAST_CALL;
1857     };
1858
1859     class ConstStatementNode : public StatementNode {
1860     public:
1861         ConstStatementNode(ConstDeclNode* next) KJS_FAST_CALL
1862             : m_next(next)
1863         {
1864         }
1865
1866         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1867         
1868         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1869
1870     private:
1871         RefPtr<ConstDeclNode> m_next;
1872     };
1873
1874     typedef Vector<RefPtr<StatementNode> > StatementVector;
1875
1876     class SourceElements : public ParserRefCounted {
1877     public:
1878         void append(PassRefPtr<StatementNode>);
1879         void releaseContentsIntoVector(StatementVector& destination)
1880         {
1881             ASSERT(destination.isEmpty());
1882             m_statements.swap(destination);
1883         }
1884
1885     private:
1886         StatementVector m_statements;
1887     };
1888
1889     class BlockNode : public StatementNode {
1890     public:
1891         BlockNode(SourceElements* children) KJS_FAST_CALL;
1892
1893         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1894         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1895
1896         StatementVector& children() { return m_children; }
1897
1898     protected:
1899         StatementVector m_children;
1900     };
1901
1902     class EmptyStatementNode : public StatementNode {
1903     public:
1904         EmptyStatementNode() KJS_FAST_CALL // debug
1905         {
1906         }
1907
1908         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1909
1910         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1911         virtual bool isEmptyStatement() const KJS_FAST_CALL { return true; }
1912     };
1913     
1914     class DebuggerStatementNode : public StatementNode {
1915     public:
1916         DebuggerStatementNode() KJS_FAST_CALL
1917         {
1918         }
1919         
1920         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1921
1922         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1923     };
1924
1925     class ExprStatementNode : public StatementNode {
1926     public:
1927         ExprStatementNode(ExpressionNode* expr) KJS_FAST_CALL
1928             : m_expr(expr)
1929         {
1930         }
1931
1932         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1933         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1934
1935     private:
1936         RefPtr<ExpressionNode> m_expr;
1937     };
1938
1939     class VarStatementNode : public StatementNode {
1940     public:
1941         VarStatementNode(ExpressionNode* expr) KJS_FAST_CALL
1942             : m_expr(expr)
1943         {
1944         }
1945         
1946         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1947
1948         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1949
1950     private:
1951         RefPtr<ExpressionNode> m_expr;
1952     };
1953
1954     class IfNode : public StatementNode {
1955     public:
1956         IfNode(ExpressionNode* condition, StatementNode* ifBlock) KJS_FAST_CALL
1957             : m_condition(condition)
1958             , m_ifBlock(ifBlock)
1959         {
1960         }
1961
1962         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1963         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1964
1965     protected:
1966         RefPtr<ExpressionNode> m_condition;
1967         RefPtr<StatementNode> m_ifBlock;
1968     };
1969
1970     class IfElseNode : public IfNode {
1971     public:
1972         IfElseNode(ExpressionNode* condtion, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL
1973             : IfNode(condtion, ifBlock)
1974             , m_elseBlock(elseBlock)
1975         {
1976         }
1977
1978         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1979         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1980
1981     private:
1982         RefPtr<StatementNode> m_elseBlock;
1983     };
1984
1985     class DoWhileNode : public StatementNode {
1986     public:
1987         DoWhileNode(StatementNode* statement, ExpressionNode* expr) KJS_FAST_CALL
1988             : m_statement(statement)
1989             , m_expr(expr)
1990         {
1991         }
1992
1993         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1994         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1995
1996     private:
1997         RefPtr<StatementNode> m_statement;
1998         RefPtr<ExpressionNode> m_expr;
1999     };
2000
2001     class WhileNode : public StatementNode {
2002     public:
2003         WhileNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
2004             : m_expr(expr)
2005             , m_statement(statement)
2006         {
2007         }
2008
2009         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2010         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2011
2012     private:
2013         RefPtr<ExpressionNode> m_expr;
2014         RefPtr<StatementNode> m_statement;
2015     };
2016
2017     class ForNode : public StatementNode {
2018     public:
2019         ForNode(ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) KJS_FAST_CALL
2020             : m_expr1(expr1)
2021             , m_expr2(expr2)
2022             , m_expr3(expr3)
2023             , m_statement(statement)
2024             , m_expr1WasVarDecl(expr1 && expr1WasVarDecl)
2025         {
2026             ASSERT(statement);
2027         }
2028
2029         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2030         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2031
2032     private:
2033         RefPtr<ExpressionNode> m_expr1;
2034         RefPtr<ExpressionNode> m_expr2;
2035         RefPtr<ExpressionNode> m_expr3;
2036         RefPtr<StatementNode> m_statement;
2037         bool m_expr1WasVarDecl;
2038     };
2039
2040     class ForInNode : public StatementNode {
2041     public:
2042         ForInNode(ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
2043         ForInNode(const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
2044         
2045         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2046         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2047
2048     private:
2049         Identifier m_ident;
2050         RefPtr<ExpressionNode> m_init;
2051         RefPtr<ExpressionNode> m_lexpr;
2052         RefPtr<ExpressionNode> m_expr;
2053         RefPtr<StatementNode> m_statement;
2054         bool m_identIsVarDecl;
2055     };
2056
2057     class ContinueNode : public StatementNode {
2058     public:
2059         ContinueNode() KJS_FAST_CALL
2060         {
2061         }
2062
2063         ContinueNode(const Identifier& ident) KJS_FAST_CALL
2064             : m_ident(ident)
2065         {
2066         }
2067         
2068         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2069         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2070
2071     private:
2072         Identifier m_ident;
2073     };
2074
2075     class BreakNode : public StatementNode {
2076     public:
2077         BreakNode() KJS_FAST_CALL
2078         {
2079         }
2080
2081         BreakNode(const Identifier& ident) KJS_FAST_CALL
2082             : m_ident(ident)
2083         {
2084         }
2085         
2086         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2087         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2088
2089     private:
2090         Identifier m_ident;
2091     };
2092
2093     class ReturnNode : public StatementNode {
2094     public:
2095         ReturnNode(ExpressionNode* value) KJS_FAST_CALL
2096             : m_value(value)
2097         {
2098         }
2099
2100         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2101         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2102         virtual bool isReturnNode() const KJS_FAST_CALL { return true; }
2103
2104     private:
2105         RefPtr<ExpressionNode> m_value;
2106     };
2107
2108     class WithNode : public StatementNode {
2109     public:
2110         WithNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
2111             : m_expr(expr)
2112             , m_statement(statement)
2113         {
2114         }
2115
2116         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2117         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2118
2119     private:
2120         RefPtr<ExpressionNode> m_expr;
2121         RefPtr<StatementNode> m_statement;
2122     };
2123
2124     class LabelNode : public StatementNode {
2125     public:
2126         LabelNode(const Identifier& label, StatementNode* statement) KJS_FAST_CALL
2127             : m_label(label)
2128             , m_statement(statement)
2129         {
2130         }
2131
2132         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2133         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2134         virtual void pushLabel(const Identifier& ident) KJS_FAST_CALL { m_statement->pushLabel(ident); }
2135
2136     private:
2137         Identifier m_label;
2138         RefPtr<StatementNode> m_statement;
2139     };
2140
2141     class ThrowNode : public StatementNode {
2142     public:
2143         ThrowNode(ExpressionNode* expr) KJS_FAST_CALL
2144             : m_expr(expr)
2145         {
2146         }
2147
2148         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2149         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2150
2151     private:
2152         RefPtr<ExpressionNode> m_expr;
2153     };
2154
2155     class TryNode : public StatementNode {
2156     public:
2157         TryNode(StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock) KJS_FAST_CALL
2158             : m_tryBlock(tryBlock)
2159             , m_exceptionIdent(exceptionIdent)
2160             , m_catchBlock(catchBlock)
2161             , m_finallyBlock(finallyBlock)
2162         {
2163         }
2164
2165         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2166
2167         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* dst = 0) KJS_FAST_CALL;
2168
2169     private:
2170         RefPtr<StatementNode> m_tryBlock;
2171         Identifier m_exceptionIdent;
2172         RefPtr<StatementNode> m_catchBlock;
2173         RefPtr<StatementNode> m_finallyBlock;
2174     };
2175
2176     class ParameterNode : public Node {
2177     public:
2178         ParameterNode(const Identifier& ident) KJS_FAST_CALL
2179             : m_ident(ident)
2180         {
2181         }
2182
2183         ParameterNode(ParameterNode* l, const Identifier& ident) KJS_FAST_CALL
2184             : m_ident(ident)
2185         {
2186             l->m_next = this;
2187         }
2188
2189         Identifier ident() KJS_FAST_CALL { return m_ident; }
2190         ParameterNode *nextParam() KJS_FAST_CALL { return m_next.get(); }
2191         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2192         PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
2193         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2194
2195     private:
2196         friend class FuncDeclNode;
2197         friend class FuncExprNode;
2198         Identifier m_ident;
2199         ListRefPtr<ParameterNode> m_next;
2200     };
2201
2202     class ScopeNode : public BlockNode {
2203     public:
2204         ScopeNode(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2205
2206         int sourceId() const KJS_FAST_CALL { return m_sourceId; }
2207         const UString& sourceURL() const KJS_FAST_CALL { return m_sourceURL; }
2208         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2209         
2210         bool usesEval() const { return m_usesEval; }
2211         bool needsClosure() const { return m_needsClosure; }
2212         
2213         VarStack& varStack() { return m_varStack; }
2214         FunctionStack& functionStack() { return m_functionStack; }
2215         
2216     protected:
2217         VarStack m_varStack;
2218         FunctionStack m_functionStack;
2219
2220     private:
2221         UString m_sourceURL;
2222         int m_sourceId;
2223         bool m_usesEval;
2224         bool m_needsClosure;
2225     };
2226
2227     class ProgramNode : public ScopeNode {
2228     public:
2229         static ProgramNode* create(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2230         virtual ~ProgramNode();
2231         
2232         ProgramCodeBlock& code(ScopeChainNode* scopeChain, bool canCreateGlobals) KJS_FAST_CALL
2233         {
2234             if (!m_code)
2235                 generateCode(scopeChain, canCreateGlobals);
2236             return *m_code;
2237         }
2238
2239     private:
2240         ProgramNode(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2241
2242         void generateCode(ScopeChainNode*, bool) KJS_FAST_CALL;
2243         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2244
2245         Vector<size_t> m_varIndexes; // Storage indexes belonging to the nodes in m_varStack. (Recorded to avoid double lookup.)
2246         Vector<size_t> m_functionIndexes; // Storage indexes belonging to the nodes in m_functionStack. (Recorded to avoid double lookup.)
2247
2248         OwnPtr<ProgramCodeBlock> m_code;
2249     };
2250
2251     class EvalNode : public ScopeNode {
2252     public:
2253         static EvalNode* create(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2254         virtual ~EvalNode();
2255         
2256         EvalCodeBlock& code(ScopeChainNode* scopeChain) KJS_FAST_CALL
2257         {
2258             if (!m_code)
2259                 generateCode(scopeChain);
2260             return *m_code;
2261         }
2262
2263     private:
2264         EvalNode(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2265
2266         void generateCode(ScopeChainNode*) KJS_FAST_CALL;
2267         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2268
2269         OwnPtr<EvalCodeBlock> m_code;
2270     };
2271
2272     class FunctionBodyNode : public ScopeNode {
2273     public:
2274         static FunctionBodyNode* create(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2275         virtual ~FunctionBodyNode();
2276         
2277         Vector<Identifier>& parameters() KJS_FAST_CALL { return m_parameters; }
2278         UString paramString() const KJS_FAST_CALL;
2279
2280         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2281         
2282         SymbolTable& symbolTable() { return m_symbolTable; } // FIXME: Remove this
2283         
2284         CodeBlock& code(ScopeChainNode* scopeChain) KJS_FAST_CALL
2285         {
2286             ASSERT(scopeChain);
2287             if (!m_code)
2288                 generateCode(scopeChain);
2289             return *m_code;
2290         }
2291
2292         CodeBlock& generatedCode() KJS_FAST_CALL
2293         {
2294             ASSERT(m_code);
2295             return *m_code;
2296         }
2297
2298         void mark();
2299
2300         void setSource(const SourceRange& source) { m_source = source; } 
2301         UString toSourceString() const KJS_FAST_CALL { return UString("{") + m_source.toString() + UString("}"); }
2302
2303     protected:
2304         FunctionBodyNode(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2305
2306     private:
2307         void generateCode(ScopeChainNode*) KJS_FAST_CALL;
2308         
2309         Vector<Identifier> m_parameters;
2310         SymbolTable m_symbolTable;
2311         OwnPtr<CodeBlock> m_code;
2312         SourceRange m_source;
2313     };
2314
2315     class FuncExprNode : public ExpressionNode {
2316     public:
2317         FuncExprNode(const Identifier& ident, FunctionBodyNode* body, const SourceRange& source, ParameterNode* parameter = 0) KJS_FAST_CALL
2318             : m_ident(ident)
2319             , m_parameter(parameter)
2320             , m_body(body)
2321         {
2322             addParams();
2323             m_body->setSource(source);
2324         }
2325
2326         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2327         FunctionImp* makeFunction(ExecState*, ScopeChainNode*) KJS_FAST_CALL;
2328         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2329         virtual Precedence precedence() const { return PrecMember; }
2330         virtual bool needsParensIfLeftmost() const { return true; }
2331
2332         FunctionBodyNode* body() { return m_body.get(); }
2333
2334     private:
2335         void addParams() KJS_FAST_CALL;
2336
2337         // Used for streamTo
2338         friend class PropertyNode;
2339         Identifier m_ident;
2340         RefPtr<ParameterNode> m_parameter;
2341         RefPtr<FunctionBodyNode> m_body;
2342     };
2343
2344     class FuncDeclNode : public StatementNode {
2345     public:
2346         FuncDeclNode(const Identifier& ident, FunctionBodyNode* body, const SourceRange& source, ParameterNode* parameter = 0) KJS_FAST_CALL
2347             : m_ident(ident)
2348             , m_parameter(parameter)
2349             , m_body(body)
2350         {
2351             addParams();
2352             m_body->setSource(source);
2353         }
2354
2355         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2356
2357         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2358         FunctionImp* makeFunction(ExecState*, ScopeChainNode*) KJS_FAST_CALL;
2359
2360         Identifier m_ident;
2361
2362         FunctionBodyNode* body() { return m_body.get(); }
2363
2364     private:
2365         void addParams() KJS_FAST_CALL;
2366
2367         RefPtr<ParameterNode> m_parameter;
2368         RefPtr<FunctionBodyNode> m_body;
2369     };
2370
2371     class CaseClauseNode : public Node {
2372     public:
2373         CaseClauseNode(ExpressionNode* expr) KJS_FAST_CALL
2374             : m_expr(expr)
2375         {
2376         }
2377
2378         CaseClauseNode(ExpressionNode* expr, SourceElements* children) KJS_FAST_CALL
2379             : m_expr(expr)
2380         {
2381             if (children)
2382                 children->releaseContentsIntoVector(m_children);
2383         }
2384
2385         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2386         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2387
2388         ExpressionNode* expr() const { return m_expr.get(); }
2389         StatementVector& children() { return m_children; }
2390
2391     private:
2392         RefPtr<ExpressionNode> m_expr;
2393         StatementVector m_children;
2394     };
2395
2396     class ClauseListNode : public Node {
2397     public:
2398         ClauseListNode(CaseClauseNode* clause) KJS_FAST_CALL
2399             : m_clause(clause)
2400         {
2401         }
2402
2403         ClauseListNode(ClauseListNode* clauseList, CaseClauseNode* clause) KJS_FAST_CALL
2404             : m_clause(clause)
2405         {
2406             clauseList->m_next = this;
2407         }
2408
2409         CaseClauseNode* getClause() const KJS_FAST_CALL { return m_clause.get(); }
2410         ClauseListNode* getNext() const KJS_FAST_CALL { return m_next.get(); }
2411         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2412         PassRefPtr<ClauseListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
2413         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2414
2415     private:
2416         friend class CaseBlockNode;
2417         RefPtr<CaseClauseNode> m_clause;
2418         ListRefPtr<ClauseListNode> m_next;
2419     };
2420
2421     class CaseBlockNode : public Node {
2422     public:
2423         CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) KJS_FAST_CALL
2424             : m_list1(list1)
2425             , m_defaultClause(defaultClause)
2426             , m_list2(list2)
2427         {
2428         }
2429
2430         RegisterID* emitCodeForBlock(CodeGenerator&, RegisterID* input, RegisterID* dst = 0) KJS_FAST_CALL;
2431
2432         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2433         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2434
2435     private:
2436         RefPtr<ClauseListNode> m_list1;
2437         RefPtr<CaseClauseNode> m_defaultClause;
2438         RefPtr<ClauseListNode> m_list2;
2439     };
2440
2441     class SwitchNode : public StatementNode {
2442     public:
2443         SwitchNode(ExpressionNode* expr, CaseBlockNode* block) KJS_FAST_CALL
2444             : m_expr(expr)
2445             , m_block(block)
2446         {
2447         }
2448
2449         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2450
2451         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2452
2453     private:
2454         RefPtr<ExpressionNode> m_expr;
2455         RefPtr<CaseBlockNode> m_block;
2456     };
2457
2458     class BreakpointCheckStatement : public StatementNode {
2459     public:
2460         BreakpointCheckStatement(PassRefPtr<StatementNode>) KJS_FAST_CALL;
2461
2462         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2463
2464     private:
2465         RefPtr<StatementNode> m_statement;
2466     };
2467
2468     struct ElementList {
2469         ElementNode* head;
2470         ElementNode* tail;
2471     };
2472
2473     struct PropertyList {
2474         PropertyListNode* head;
2475         PropertyListNode* tail;
2476     };
2477
2478     struct ArgumentList {
2479         ArgumentListNode* head;
2480         ArgumentListNode* tail;
2481     };
2482
2483     struct ConstDeclList {
2484         ConstDeclNode* head;
2485         ConstDeclNode* tail;
2486     };
2487
2488     struct ParameterList {
2489         ParameterNode* head;
2490         ParameterNode* tail;
2491     };
2492
2493     struct ClauseList {
2494         ClauseListNode* head;
2495         ClauseListNode* tail;
2496     };
2497
2498 } // namespace KJS
2499
2500 #endif // NODES_H_