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