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