2008-06-13 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         unsigned refcount() 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) KJS_FAST_CALL
1254             : m_term1(term1)
1255             , m_term2(term2)
1256         {
1257         }
1258
1259         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1260         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1261         virtual Precedence precedence() const { return PrecAdditive; }
1262
1263     protected:
1264         AddNode(ExpressionNode* term1, ExpressionNode* term2, JSType expectedReturn) KJS_FAST_CALL
1265             : ExpressionNode(expectedReturn)
1266             , m_term1(term1)
1267             , m_term2(term2)
1268         {
1269         }
1270
1271         RefPtr<ExpressionNode> m_term1;
1272         RefPtr<ExpressionNode> m_term2;
1273     };
1274
1275     class SubNode : public ExpressionNode {
1276     public:
1277         SubNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1278             : ExpressionNode(NumberType)
1279             , m_term1(term1)
1280             , m_term2(term2)
1281         {
1282         }
1283
1284         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1285         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1286         virtual Precedence precedence() const { return PrecAdditive; }
1287
1288     private:
1289         RefPtr<ExpressionNode> m_term1;
1290         RefPtr<ExpressionNode> m_term2;
1291     };
1292
1293     class LeftShiftNode : public ExpressionNode {
1294     public:
1295         LeftShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1296             : ExpressionNode(NumberType)
1297             , m_term1(term1)
1298             , m_term2(term2)
1299         {
1300         }
1301
1302         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1303         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1304         virtual Precedence precedence() const { return PrecShift; }
1305
1306     private:
1307         RefPtr<ExpressionNode> m_term1;
1308         RefPtr<ExpressionNode> m_term2;
1309     };
1310
1311     class RightShiftNode : public ExpressionNode {
1312     public:
1313         RightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1314             : ExpressionNode(NumberType)
1315             , m_term1(term1)
1316             , m_term2(term2)
1317         {
1318         }
1319
1320         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1321         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1322         virtual Precedence precedence() const { return PrecShift; }
1323
1324     private:
1325         RefPtr<ExpressionNode> m_term1;
1326         RefPtr<ExpressionNode> m_term2;
1327     };
1328
1329     class UnsignedRightShiftNode : public ExpressionNode {
1330     public:
1331         UnsignedRightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
1332             : ExpressionNode(NumberType)
1333             , m_term1(term1)
1334             , m_term2(term2)
1335         {
1336         }
1337
1338         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1339         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1340         virtual Precedence precedence() const { return PrecShift; }
1341
1342     private:
1343         RefPtr<ExpressionNode> m_term1;
1344         RefPtr<ExpressionNode> m_term2;
1345     };
1346
1347     class LessNode : public ExpressionNode {
1348     public:
1349         LessNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1350             : ExpressionNode(BooleanType)
1351             , m_expr1(expr1)
1352             , m_expr2(expr2)
1353         {
1354         }
1355
1356         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1357         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1358         virtual Precedence precedence() const { return PrecRelational; }
1359
1360     protected:
1361         RefPtr<ExpressionNode> m_expr1;
1362         RefPtr<ExpressionNode> m_expr2;
1363     };
1364
1365     class GreaterNode : public ExpressionNode {
1366     public:
1367         GreaterNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1368             : m_expr1(expr1)
1369             , m_expr2(expr2)
1370         {
1371         }
1372
1373         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1374         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1375         virtual Precedence precedence() const { return PrecRelational; }
1376
1377     private:
1378         RefPtr<ExpressionNode> m_expr1;
1379         RefPtr<ExpressionNode> m_expr2;
1380     };
1381
1382     class LessEqNode : public ExpressionNode {
1383     public:
1384         LessEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1385             : m_expr1(expr1)
1386             , m_expr2(expr2)
1387         {
1388         }
1389
1390         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1391         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1392         virtual Precedence precedence() const { return PrecRelational; }
1393
1394     private:
1395         RefPtr<ExpressionNode> m_expr1;
1396         RefPtr<ExpressionNode> m_expr2;
1397     };
1398
1399     class GreaterEqNode : public ExpressionNode {
1400     public:
1401         GreaterEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1402             : m_expr1(expr1)
1403             , m_expr2(expr2)
1404         {
1405         }
1406
1407         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1408         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1409         virtual Precedence precedence() const { return PrecRelational; }
1410
1411     private:
1412         RefPtr<ExpressionNode> m_expr1;
1413         RefPtr<ExpressionNode> m_expr2;
1414     };
1415
1416     class InstanceOfNode : public ExpressionNode {
1417     public:
1418         InstanceOfNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1419             : ExpressionNode(BooleanType)
1420             , m_expr1(expr1)
1421             , m_expr2(expr2)
1422         {
1423         }
1424
1425         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1426         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1427         virtual Precedence precedence() const { return PrecRelational; }
1428
1429     private:
1430         RefPtr<ExpressionNode> m_expr1;
1431         RefPtr<ExpressionNode> m_expr2;
1432     };
1433
1434     class InNode : public ExpressionNode {
1435     public:
1436         InNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1437             : m_expr1(expr1)
1438             , m_expr2(expr2)
1439         {
1440         }
1441
1442         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1443
1444         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1445         virtual Precedence precedence() const { return PrecRelational; }
1446
1447     private:
1448         RefPtr<ExpressionNode> m_expr1;
1449         RefPtr<ExpressionNode> m_expr2;
1450     };
1451
1452     class EqualNode : public ExpressionNode {
1453     public:
1454         EqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1455             : ExpressionNode(BooleanType)
1456             , m_expr1(expr1)
1457             , m_expr2(expr2)
1458         {
1459         }
1460
1461         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1462         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1463         virtual Precedence precedence() const { return PrecEquality; }
1464
1465     private:
1466         RefPtr<ExpressionNode> m_expr1;
1467         RefPtr<ExpressionNode> m_expr2;
1468     };
1469
1470     class NotEqualNode : public ExpressionNode {
1471     public:
1472         NotEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1473             : ExpressionNode(BooleanType)
1474             , m_expr1(expr1)
1475             , m_expr2(expr2)
1476         {
1477         }
1478
1479         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1480         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1481         virtual Precedence precedence() const { return PrecEquality; }
1482
1483     private:
1484         RefPtr<ExpressionNode> m_expr1;
1485         RefPtr<ExpressionNode> m_expr2;
1486     };
1487
1488     class StrictEqualNode : public ExpressionNode {
1489     public:
1490         StrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1491             : ExpressionNode(BooleanType)
1492             , m_expr1(expr1)
1493             , m_expr2(expr2)
1494         {
1495         }
1496
1497         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1498         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1499         virtual Precedence precedence() const { return PrecEquality; }
1500
1501     private:
1502         RefPtr<ExpressionNode> m_expr1;
1503         RefPtr<ExpressionNode> m_expr2;
1504     };
1505
1506     class NotStrictEqualNode : public ExpressionNode {
1507     public:
1508         NotStrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1509             : ExpressionNode(BooleanType)
1510             , m_expr1(expr1)
1511             , m_expr2(expr2)
1512         {
1513         }
1514
1515         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1516         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1517         virtual Precedence precedence() const { return PrecEquality; }
1518
1519     private:
1520         RefPtr<ExpressionNode> m_expr1;
1521         RefPtr<ExpressionNode> m_expr2;
1522     };
1523
1524     class BitAndNode : public ExpressionNode {
1525     public:
1526         BitAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1527             : ExpressionNode(NumberType)
1528             , m_expr1(expr1)
1529             , m_expr2(expr2)
1530         {
1531         }
1532
1533         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1534         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1535         virtual Precedence precedence() const { return PrecBitwiseAnd; }
1536
1537     private:
1538         RefPtr<ExpressionNode> m_expr1;
1539         RefPtr<ExpressionNode> m_expr2;
1540     };
1541
1542     class BitOrNode : public ExpressionNode {
1543     public:
1544         BitOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1545             : ExpressionNode(NumberType)
1546             , m_expr1(expr1)
1547             , m_expr2(expr2)
1548         {
1549         }
1550
1551         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1552         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1553         virtual Precedence precedence() const { return PrecBitwiseOr; }
1554
1555     private:
1556         RefPtr<ExpressionNode> m_expr1;
1557         RefPtr<ExpressionNode> m_expr2;
1558     };
1559
1560     class BitXOrNode : public ExpressionNode {
1561     public:
1562         BitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1563             : ExpressionNode(NumberType)
1564             , m_expr1(expr1)
1565             , m_expr2(expr2)
1566         {
1567         }
1568
1569         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1570         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1571         virtual Precedence precedence() const { return PrecBitwiseXor; }
1572
1573     private:
1574         RefPtr<ExpressionNode> m_expr1;
1575         RefPtr<ExpressionNode> m_expr2;
1576     };
1577
1578     /**
1579      * m_expr1 && m_expr2, m_expr1 || m_expr2
1580      */
1581     class LogicalAndNode : public ExpressionNode {
1582     public:
1583         LogicalAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1584             : ExpressionNode(BooleanType)
1585             , m_expr1(expr1)
1586             , m_expr2(expr2)
1587         {
1588         }
1589
1590         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1591         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1592         virtual Precedence precedence() const { return PrecLogicalAnd; }
1593
1594     private:
1595         RefPtr<ExpressionNode> m_expr1;
1596         RefPtr<ExpressionNode> m_expr2;
1597     };
1598
1599     class LogicalOrNode : public ExpressionNode {
1600     public:
1601         LogicalOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1602             : ExpressionNode(BooleanType)
1603             , m_expr1(expr1)
1604             , m_expr2(expr2)
1605         {
1606         }
1607
1608         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1609         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1610         virtual Precedence precedence() const { return PrecLogicalOr; }
1611
1612     private:
1613         RefPtr<ExpressionNode> m_expr1;
1614         RefPtr<ExpressionNode> m_expr2;
1615     };
1616
1617     /**
1618      * The ternary operator, "m_logical ? m_expr1 : m_expr2"
1619      */
1620     class ConditionalNode : public ExpressionNode {
1621     public:
1622         ConditionalNode(ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1623             : m_logical(logical)
1624             , m_expr1(expr1)
1625             , m_expr2(expr2)
1626         {
1627         }
1628
1629         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1630         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1631         virtual Precedence precedence() const { return PrecConditional; }
1632
1633     private:
1634         RefPtr<ExpressionNode> m_logical;
1635         RefPtr<ExpressionNode> m_expr1;
1636         RefPtr<ExpressionNode> m_expr2;
1637     };
1638
1639     class ReadModifyResolveNode : public ExpressionNode {
1640     public:
1641         ReadModifyResolveNode(const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments) KJS_FAST_CALL
1642             : m_ident(ident)
1643             , m_right(right)
1644             , m_operator(oper)
1645             , m_rightHasAssignments(rightHasAssignments)
1646         {
1647         }
1648
1649         ReadModifyResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
1650             : ExpressionNode(PlacementNewAdopt)
1651             , m_ident(PlacementNewAdopt)
1652             , m_right(PlacementNewAdopt)
1653             , m_rightHasAssignments(true)
1654         {
1655         }
1656
1657         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1658
1659         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1660         virtual Precedence precedence() const { return PrecAssignment; }
1661
1662     protected:
1663         Identifier m_ident;
1664         RefPtr<ExpressionNode> m_right;
1665         size_t m_index; // Used by ReadModifyLocalVarNode.
1666         Operator m_operator : 31;
1667         bool m_rightHasAssignments : 1;
1668     };
1669
1670     class AssignResolveNode : public ExpressionNode {
1671     public:
1672         AssignResolveNode(const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
1673             : m_ident(ident)
1674             , m_right(right)
1675             , m_rightHasAssignments(rightHasAssignments)
1676         {
1677         }
1678
1679         AssignResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
1680             : ExpressionNode(PlacementNewAdopt)
1681             , m_ident(PlacementNewAdopt)
1682             , m_right(PlacementNewAdopt)
1683         {
1684         }
1685         
1686         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1687
1688         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1689         virtual Precedence precedence() const { return PrecAssignment; }
1690
1691     protected:
1692         Identifier m_ident;
1693         RefPtr<ExpressionNode> m_right;
1694         size_t m_index; // Used by ReadModifyLocalVarNode.
1695         bool m_rightHasAssignments;
1696     };
1697
1698     class ReadModifyBracketNode : public ExpressionNode {
1699     public:
1700         ReadModifyBracketNode(ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments) KJS_FAST_CALL
1701             : m_base(base)
1702             , m_subscript(subscript)
1703             , m_right(right)
1704             , m_operator(oper)
1705             , m_subscriptHasAssignments(subscriptHasAssignments)
1706             , m_rightHasAssignments(rightHasAssignments)
1707         {
1708         }
1709
1710         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1711
1712         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1713         virtual Precedence precedence() const { return PrecAssignment; }
1714
1715     protected:
1716         RefPtr<ExpressionNode> m_base;
1717         RefPtr<ExpressionNode> m_subscript;
1718         RefPtr<ExpressionNode> m_right;
1719         Operator m_operator : 30;
1720         bool m_subscriptHasAssignments : 1;
1721         bool m_rightHasAssignments : 1;
1722     };
1723
1724     class AssignBracketNode : public ExpressionNode {
1725     public:
1726         AssignBracketNode(ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments) KJS_FAST_CALL
1727             : m_base(base)
1728             , m_subscript(subscript)
1729             , m_right(right)
1730             , m_subscriptHasAssignments(subscriptHasAssignments)
1731             , m_rightHasAssignments(rightHasAssignments)
1732         {
1733         }
1734
1735         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1736
1737         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1738         virtual Precedence precedence() const { return PrecAssignment; }
1739
1740     protected:
1741         RefPtr<ExpressionNode> m_base;
1742         RefPtr<ExpressionNode> m_subscript;
1743         RefPtr<ExpressionNode> m_right;
1744         bool m_subscriptHasAssignments : 1;
1745         bool m_rightHasAssignments : 1;
1746     };
1747
1748     class AssignDotNode : public ExpressionNode {
1749     public:
1750         AssignDotNode(ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
1751             : m_base(base)
1752             , m_ident(ident)
1753             , m_right(right)
1754             , m_rightHasAssignments(rightHasAssignments)
1755         {
1756         }
1757
1758         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1759         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1760         virtual Precedence precedence() const { return PrecAssignment; }
1761
1762     protected:
1763         RefPtr<ExpressionNode> m_base;
1764         Identifier m_ident;
1765         RefPtr<ExpressionNode> m_right;
1766         bool m_rightHasAssignments;
1767     };
1768
1769     class ReadModifyDotNode : public ExpressionNode {
1770     public:
1771         ReadModifyDotNode(ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments) KJS_FAST_CALL
1772             : m_base(base)
1773             , m_ident(ident)
1774             , m_right(right)
1775             , m_operator(oper)
1776             , m_rightHasAssignments(rightHasAssignments)
1777         {
1778         }
1779
1780         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1781
1782         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1783         virtual Precedence precedence() const { return PrecAssignment; }
1784
1785     protected:
1786         RefPtr<ExpressionNode> m_base;
1787         Identifier m_ident;
1788         RefPtr<ExpressionNode> m_right;
1789         Operator m_operator : 31;
1790         bool m_rightHasAssignments : 1;
1791     };
1792
1793     class AssignErrorNode : public ExpressionNode {
1794     public:
1795         AssignErrorNode(ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL
1796             : m_left(left)
1797             , m_operator(oper)
1798             , m_right(right)
1799         {
1800         }
1801
1802         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1803         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1804         virtual Precedence precedence() const { return PrecAssignment; }
1805
1806     protected:
1807         RefPtr<ExpressionNode> m_left;
1808         Operator m_operator;
1809         RefPtr<ExpressionNode> m_right;
1810     };
1811
1812     class CommaNode : public ExpressionNode {
1813     public:
1814         CommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1815             : m_expr1(expr1)
1816             , m_expr2(expr2)
1817         {
1818         }
1819
1820         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1821         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1822         virtual Precedence precedence() const { return PrecExpression; }
1823
1824     private:
1825         RefPtr<ExpressionNode> m_expr1;
1826         RefPtr<ExpressionNode> m_expr2;
1827     };
1828     
1829     class VarDeclCommaNode : public CommaNode {
1830     public:
1831         VarDeclCommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
1832             : CommaNode(expr1, expr2)
1833         {
1834         }
1835         virtual Precedence precedence() const { return PrecAssignment; }
1836     };
1837
1838     class ConstDeclNode : public ExpressionNode {
1839     public:
1840         ConstDeclNode(const Identifier& ident, ExpressionNode* in) KJS_FAST_CALL;
1841
1842         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1843         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
1844         PassRefPtr<ConstDeclNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
1845
1846         Identifier m_ident;
1847         ListRefPtr<ConstDeclNode> m_next;
1848         RefPtr<ExpressionNode> m_init;
1849         
1850         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1851         virtual RegisterID* emitCodeSingle(CodeGenerator&) KJS_FAST_CALL;
1852     };
1853
1854     class ConstStatementNode : public StatementNode {
1855     public:
1856         ConstStatementNode(ConstDeclNode* next) KJS_FAST_CALL
1857             : m_next(next)
1858         {
1859         }
1860
1861         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1862         
1863         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1864
1865     private:
1866         RefPtr<ConstDeclNode> m_next;
1867     };
1868
1869     typedef Vector<RefPtr<StatementNode> > StatementVector;
1870
1871     class SourceElements : public ParserRefCounted {
1872     public:
1873         void append(PassRefPtr<StatementNode>);
1874         void releaseContentsIntoVector(StatementVector& destination)
1875         {
1876             ASSERT(destination.isEmpty());
1877             m_statements.swap(destination);
1878         }
1879
1880     private:
1881         StatementVector m_statements;
1882     };
1883
1884     class BlockNode : public StatementNode {
1885     public:
1886         BlockNode(SourceElements* children) KJS_FAST_CALL;
1887
1888         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1889         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1890
1891         StatementVector& children() { return m_children; }
1892
1893     protected:
1894         StatementVector m_children;
1895     };
1896
1897     class EmptyStatementNode : public StatementNode {
1898     public:
1899         EmptyStatementNode() KJS_FAST_CALL // debug
1900         {
1901         }
1902
1903         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1904
1905         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1906         virtual bool isEmptyStatement() const KJS_FAST_CALL { return true; }
1907     };
1908     
1909     class DebuggerStatementNode : public StatementNode {
1910     public:
1911         DebuggerStatementNode() KJS_FAST_CALL
1912         {
1913         }
1914         
1915         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1916
1917         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1918     };
1919
1920     class ExprStatementNode : public StatementNode {
1921     public:
1922         ExprStatementNode(ExpressionNode* expr) KJS_FAST_CALL
1923             : m_expr(expr)
1924         {
1925         }
1926
1927         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1928         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1929
1930     private:
1931         RefPtr<ExpressionNode> m_expr;
1932     };
1933
1934     class VarStatementNode : public StatementNode {
1935     public:
1936         VarStatementNode(ExpressionNode* expr) KJS_FAST_CALL
1937             : m_expr(expr)
1938         {
1939         }
1940         
1941         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1942
1943         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1944
1945     private:
1946         RefPtr<ExpressionNode> m_expr;
1947     };
1948
1949     class IfNode : public StatementNode {
1950     public:
1951         IfNode(ExpressionNode* condition, StatementNode* ifBlock) KJS_FAST_CALL
1952             : m_condition(condition)
1953             , m_ifBlock(ifBlock)
1954         {
1955         }
1956
1957         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1958         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1959
1960     protected:
1961         RefPtr<ExpressionNode> m_condition;
1962         RefPtr<StatementNode> m_ifBlock;
1963     };
1964
1965     class IfElseNode : public IfNode {
1966     public:
1967         IfElseNode(ExpressionNode* condtion, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL
1968             : IfNode(condtion, ifBlock)
1969             , m_elseBlock(elseBlock)
1970         {
1971         }
1972
1973         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1974         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1975
1976     private:
1977         RefPtr<StatementNode> m_elseBlock;
1978     };
1979
1980     class DoWhileNode : public StatementNode {
1981     public:
1982         DoWhileNode(StatementNode* statement, ExpressionNode* expr) KJS_FAST_CALL
1983             : m_statement(statement)
1984             , m_expr(expr)
1985         {
1986         }
1987
1988         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
1989         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
1990
1991     private:
1992         RefPtr<StatementNode> m_statement;
1993         RefPtr<ExpressionNode> m_expr;
1994     };
1995
1996     class WhileNode : public StatementNode {
1997     public:
1998         WhileNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
1999             : m_expr(expr)
2000             , m_statement(statement)
2001         {
2002         }
2003
2004         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2005         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2006
2007     private:
2008         RefPtr<ExpressionNode> m_expr;
2009         RefPtr<StatementNode> m_statement;
2010     };
2011
2012     class ForNode : public StatementNode {
2013     public:
2014         ForNode(ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) KJS_FAST_CALL
2015             : m_expr1(expr1)
2016             , m_expr2(expr2)
2017             , m_expr3(expr3)
2018             , m_statement(statement)
2019             , m_expr1WasVarDecl(expr1 && expr1WasVarDecl)
2020         {
2021             ASSERT(statement);
2022         }
2023
2024         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2025         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2026
2027     private:
2028         RefPtr<ExpressionNode> m_expr1;
2029         RefPtr<ExpressionNode> m_expr2;
2030         RefPtr<ExpressionNode> m_expr3;
2031         RefPtr<StatementNode> m_statement;
2032         bool m_expr1WasVarDecl;
2033     };
2034
2035     class ForInNode : public StatementNode {
2036     public:
2037         ForInNode(ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
2038         ForInNode(const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
2039         
2040         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2041         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2042
2043     private:
2044         Identifier m_ident;
2045         RefPtr<ExpressionNode> m_init;
2046         RefPtr<ExpressionNode> m_lexpr;
2047         RefPtr<ExpressionNode> m_expr;
2048         RefPtr<StatementNode> m_statement;
2049         bool m_identIsVarDecl;
2050     };
2051
2052     class ContinueNode : public StatementNode {
2053     public:
2054         ContinueNode() KJS_FAST_CALL
2055         {
2056         }
2057
2058         ContinueNode(const Identifier& ident) KJS_FAST_CALL
2059             : m_ident(ident)
2060         {
2061         }
2062         
2063         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2064         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2065
2066     private:
2067         Identifier m_ident;
2068     };
2069
2070     class BreakNode : public StatementNode {
2071     public:
2072         BreakNode() KJS_FAST_CALL
2073         {
2074         }
2075
2076         BreakNode(const Identifier& ident) KJS_FAST_CALL
2077             : m_ident(ident)
2078         {
2079         }
2080         
2081         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2082         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2083
2084     private:
2085         Identifier m_ident;
2086     };
2087
2088     class ReturnNode : public StatementNode {
2089     public:
2090         ReturnNode(ExpressionNode* value) KJS_FAST_CALL
2091             : m_value(value)
2092         {
2093         }
2094
2095         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2096         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2097         virtual bool isReturnNode() const KJS_FAST_CALL { return true; }
2098
2099     private:
2100         RefPtr<ExpressionNode> m_value;
2101     };
2102
2103     class WithNode : public StatementNode {
2104     public:
2105         WithNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
2106             : m_expr(expr)
2107             , m_statement(statement)
2108         {
2109         }
2110
2111         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2112         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2113
2114     private:
2115         RefPtr<ExpressionNode> m_expr;
2116         RefPtr<StatementNode> m_statement;
2117     };
2118
2119     class LabelNode : public StatementNode {
2120     public:
2121         LabelNode(const Identifier& label, StatementNode* statement) KJS_FAST_CALL
2122             : m_label(label)
2123             , m_statement(statement)
2124         {
2125         }
2126
2127         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2128         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2129         virtual void pushLabel(const Identifier& ident) KJS_FAST_CALL { m_statement->pushLabel(ident); }
2130
2131     private:
2132         Identifier m_label;
2133         RefPtr<StatementNode> m_statement;
2134     };
2135
2136     class ThrowNode : public StatementNode {
2137     public:
2138         ThrowNode(ExpressionNode* expr) KJS_FAST_CALL
2139             : m_expr(expr)
2140         {
2141         }
2142
2143         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2144         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2145
2146     private:
2147         RefPtr<ExpressionNode> m_expr;
2148     };
2149
2150     class TryNode : public StatementNode {
2151     public:
2152         TryNode(StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock) KJS_FAST_CALL
2153             : m_tryBlock(tryBlock)
2154             , m_exceptionIdent(exceptionIdent)
2155             , m_catchBlock(catchBlock)
2156             , m_finallyBlock(finallyBlock)
2157         {
2158         }
2159
2160         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2161
2162         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* dst = 0) KJS_FAST_CALL;
2163
2164     private:
2165         RefPtr<StatementNode> m_tryBlock;
2166         Identifier m_exceptionIdent;
2167         RefPtr<StatementNode> m_catchBlock;
2168         RefPtr<StatementNode> m_finallyBlock;
2169     };
2170
2171     class ParameterNode : public Node {
2172     public:
2173         ParameterNode(const Identifier& ident) KJS_FAST_CALL
2174             : m_ident(ident)
2175         {
2176         }
2177
2178         ParameterNode(ParameterNode* l, const Identifier& ident) KJS_FAST_CALL
2179             : m_ident(ident)
2180         {
2181             l->m_next = this;
2182         }
2183
2184         Identifier ident() KJS_FAST_CALL { return m_ident; }
2185         ParameterNode *nextParam() KJS_FAST_CALL { return m_next.get(); }
2186         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2187         PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
2188         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2189
2190     private:
2191         friend class FuncDeclNode;
2192         friend class FuncExprNode;
2193         Identifier m_ident;
2194         ListRefPtr<ParameterNode> m_next;
2195     };
2196
2197     class ScopeNode : public BlockNode {
2198     public:
2199         ScopeNode(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2200
2201         int sourceId() const KJS_FAST_CALL { return m_sourceId; }
2202         const UString& sourceURL() const KJS_FAST_CALL { return m_sourceURL; }
2203         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2204         
2205         bool usesEval() const { return m_usesEval; }
2206         bool needsClosure() const { return m_needsClosure; }
2207         
2208         VarStack& varStack() { return m_varStack; }
2209         FunctionStack& functionStack() { return m_functionStack; }
2210         
2211     protected:
2212         VarStack m_varStack;
2213         FunctionStack m_functionStack;
2214
2215     private:
2216         UString m_sourceURL;
2217         int m_sourceId;
2218         bool m_usesEval;
2219         bool m_needsClosure;
2220     };
2221
2222     class ProgramNode : public ScopeNode {
2223     public:
2224         static ProgramNode* create(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2225         virtual ~ProgramNode();
2226         
2227         ProgramCodeBlock& code(ScopeChainNode* scopeChain, bool canCreateGlobals) KJS_FAST_CALL
2228         {
2229             if (!m_code)
2230                 generateCode(scopeChain, canCreateGlobals);
2231             return *m_code;
2232         }
2233
2234     private:
2235         ProgramNode(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2236
2237         void generateCode(ScopeChainNode*, bool) KJS_FAST_CALL;
2238         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2239
2240         Vector<size_t> m_varIndexes; // Storage indexes belonging to the nodes in m_varStack. (Recorded to avoid double lookup.)
2241         Vector<size_t> m_functionIndexes; // Storage indexes belonging to the nodes in m_functionStack. (Recorded to avoid double lookup.)
2242
2243         OwnPtr<ProgramCodeBlock> m_code;
2244     };
2245
2246     class EvalNode : public ScopeNode {
2247     public:
2248         static EvalNode* create(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2249         virtual ~EvalNode();
2250         
2251         EvalCodeBlock& code(ScopeChainNode* scopeChain) KJS_FAST_CALL
2252         {
2253             if (!m_code)
2254                 generateCode(scopeChain);
2255             return *m_code;
2256         }
2257
2258     private:
2259         EvalNode(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2260
2261         void generateCode(ScopeChainNode*) KJS_FAST_CALL;
2262         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2263
2264         OwnPtr<EvalCodeBlock> m_code;
2265     };
2266
2267     class FunctionBodyNode : public ScopeNode {
2268     public:
2269         static FunctionBodyNode* create(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2270         virtual ~FunctionBodyNode();
2271         
2272         Vector<Identifier>& parameters() KJS_FAST_CALL { return m_parameters; }
2273         UString paramString() const KJS_FAST_CALL;
2274
2275         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2276         
2277         SymbolTable& symbolTable() { return m_symbolTable; } // FIXME: Remove this
2278         
2279         CodeBlock& code(ScopeChainNode* scopeChain) KJS_FAST_CALL
2280         {
2281             ASSERT(scopeChain);
2282             if (!m_code)
2283                 generateCode(scopeChain);
2284             return *m_code;
2285         }
2286
2287         CodeBlock& generatedCode() KJS_FAST_CALL
2288         {
2289             ASSERT(m_code);
2290             return *m_code;
2291         }
2292
2293         void mark();
2294
2295         void setSource(const SourceRange& source) { m_source = source; } 
2296         UString toSourceString() const KJS_FAST_CALL { return UString("{") + m_source.toString() + UString("}"); }
2297
2298     protected:
2299         FunctionBodyNode(SourceElements*, VarStack*, FunctionStack*, bool usesEval, bool needsClosure) KJS_FAST_CALL;
2300
2301     private:
2302         void generateCode(ScopeChainNode*) KJS_FAST_CALL;
2303         
2304         Vector<Identifier> m_parameters;
2305         SymbolTable m_symbolTable;
2306         OwnPtr<CodeBlock> m_code;
2307         SourceRange m_source;
2308     };
2309
2310     class FuncExprNode : public ExpressionNode {
2311     public:
2312         FuncExprNode(const Identifier& ident, FunctionBodyNode* body, const SourceRange& source, ParameterNode* parameter = 0) KJS_FAST_CALL
2313             : m_ident(ident)
2314             , m_parameter(parameter)
2315             , m_body(body)
2316         {
2317             addParams();
2318             m_body->setSource(source);
2319         }
2320
2321         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2322         FunctionImp* makeFunction(ExecState*, ScopeChainNode*) KJS_FAST_CALL;
2323         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2324         virtual Precedence precedence() const { return PrecMember; }
2325         virtual bool needsParensIfLeftmost() const { return true; }
2326
2327         FunctionBodyNode* body() { return m_body.get(); }
2328
2329     private:
2330         void addParams() KJS_FAST_CALL;
2331
2332         // Used for streamTo
2333         friend class PropertyNode;
2334         Identifier m_ident;
2335         RefPtr<ParameterNode> m_parameter;
2336         RefPtr<FunctionBodyNode> m_body;
2337     };
2338
2339     class FuncDeclNode : public StatementNode {
2340     public:
2341         FuncDeclNode(const Identifier& ident, FunctionBodyNode* body, const SourceRange& source, ParameterNode* parameter = 0) KJS_FAST_CALL
2342             : m_ident(ident)
2343             , m_parameter(parameter)
2344             , m_body(body)
2345         {
2346             addParams();
2347             m_body->setSource(source);
2348         }
2349
2350         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2351
2352         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2353         FunctionImp* makeFunction(ExecState*, ScopeChainNode*) KJS_FAST_CALL;
2354
2355         Identifier m_ident;
2356
2357         FunctionBodyNode* body() { return m_body.get(); }
2358
2359     private:
2360         void addParams() KJS_FAST_CALL;
2361
2362         RefPtr<ParameterNode> m_parameter;
2363         RefPtr<FunctionBodyNode> m_body;
2364     };
2365
2366     class CaseClauseNode : public Node {
2367     public:
2368         CaseClauseNode(ExpressionNode* expr) KJS_FAST_CALL
2369             : m_expr(expr)
2370         {
2371         }
2372
2373         CaseClauseNode(ExpressionNode* expr, SourceElements* children) KJS_FAST_CALL
2374             : m_expr(expr)
2375         {
2376             if (children)
2377                 children->releaseContentsIntoVector(m_children);
2378         }
2379
2380         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2381         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2382
2383         ExpressionNode* expr() const { return m_expr.get(); }
2384         StatementVector& children() { return m_children; }
2385
2386     private:
2387         RefPtr<ExpressionNode> m_expr;
2388         StatementVector m_children;
2389     };
2390
2391     class ClauseListNode : public Node {
2392     public:
2393         ClauseListNode(CaseClauseNode* clause) KJS_FAST_CALL
2394             : m_clause(clause)
2395         {
2396         }
2397
2398         ClauseListNode(ClauseListNode* clauseList, CaseClauseNode* clause) KJS_FAST_CALL
2399             : m_clause(clause)
2400         {
2401             clauseList->m_next = this;
2402         }
2403
2404         CaseClauseNode* getClause() const KJS_FAST_CALL { return m_clause.get(); }
2405         ClauseListNode* getNext() const KJS_FAST_CALL { return m_next.get(); }
2406         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2407         PassRefPtr<ClauseListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
2408         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2409
2410     private:
2411         friend class CaseBlockNode;
2412         RefPtr<CaseClauseNode> m_clause;
2413         ListRefPtr<ClauseListNode> m_next;
2414     };
2415
2416     class CaseBlockNode : public Node {
2417     public:
2418         CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) KJS_FAST_CALL
2419             : m_list1(list1)
2420             , m_defaultClause(defaultClause)
2421             , m_list2(list2)
2422         {
2423         }
2424
2425         RegisterID* emitCodeForBlock(CodeGenerator&, RegisterID* input, RegisterID* dst = 0) KJS_FAST_CALL;
2426
2427         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2428         virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
2429
2430     private:
2431         RefPtr<ClauseListNode> m_list1;
2432         RefPtr<CaseClauseNode> m_defaultClause;
2433         RefPtr<ClauseListNode> m_list2;
2434     };
2435
2436     class SwitchNode : public StatementNode {
2437     public:
2438         SwitchNode(ExpressionNode* expr, CaseBlockNode* block) KJS_FAST_CALL
2439             : m_expr(expr)
2440             , m_block(block)
2441         {
2442         }
2443
2444         virtual RegisterID* emitCode(CodeGenerator&, RegisterID* = 0) KJS_FAST_CALL;
2445
2446         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2447
2448     private:
2449         RefPtr<ExpressionNode> m_expr;
2450         RefPtr<CaseBlockNode> m_block;
2451     };
2452
2453     class BreakpointCheckStatement : public StatementNode {
2454     public:
2455         BreakpointCheckStatement(PassRefPtr<StatementNode>) KJS_FAST_CALL;
2456
2457         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
2458
2459     private:
2460         RefPtr<StatementNode> m_statement;
2461     };
2462
2463     struct ElementList {
2464         ElementNode* head;
2465         ElementNode* tail;
2466     };
2467
2468     struct PropertyList {
2469         PropertyListNode* head;
2470         PropertyListNode* tail;
2471     };
2472
2473     struct ArgumentList {
2474         ArgumentListNode* head;
2475         ArgumentListNode* tail;
2476     };
2477
2478     struct ConstDeclList {
2479         ConstDeclNode* head;
2480         ConstDeclNode* tail;
2481     };
2482
2483     struct ParameterList {
2484         ParameterNode* head;
2485         ParameterNode* tail;
2486     };
2487
2488     struct ClauseList {
2489         ClauseListNode* head;
2490         ClauseListNode* tail;
2491     };
2492
2493 } // namespace KJS
2494
2495 #endif // NODES_H_