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