Refactored bytecode generator initialization to support moving captured vars around
[WebKit-https.git] / Source / JavaScriptCore / parser / 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, 2009 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 "Error.h"
30 #include "JITCode.h"
31 #include "Opcode.h"
32 #include "ParserArena.h"
33 #include "ResultType.h"
34 #include "SourceCode.h"
35 #include "SymbolTable.h"
36 #include <wtf/MathExtras.h>
37
38 namespace JSC {
39
40     class ArgumentListNode;
41     class BytecodeGenerator;
42     class FunctionBodyNode;
43     class Label;
44     class PropertyListNode;
45     class ReadModifyResolveNode;
46     class RegisterID;
47     class JSScope;
48     class ScopeNode;
49
50     typedef unsigned CodeFeatures;
51
52     const CodeFeatures NoFeatures = 0;
53     const CodeFeatures EvalFeature = 1 << 0;
54     const CodeFeatures ArgumentsFeature = 1 << 1;
55     const CodeFeatures WithFeature = 1 << 2;
56     const CodeFeatures CatchFeature = 1 << 3;
57     const CodeFeatures ThisFeature = 1 << 4;
58     const CodeFeatures StrictModeFeature = 1 << 5;
59     const CodeFeatures ShadowsArgumentsFeature = 1 << 6;
60     
61     const CodeFeatures AllFeatures = EvalFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature | StrictModeFeature | ShadowsArgumentsFeature;
62
63     enum Operator {
64         OpEqual,
65         OpPlusEq,
66         OpMinusEq,
67         OpMultEq,
68         OpDivEq,
69         OpPlusPlus,
70         OpMinusMinus,
71         OpAndEq,
72         OpXOrEq,
73         OpOrEq,
74         OpModEq,
75         OpLShift,
76         OpRShift,
77         OpURShift
78     };
79     
80     enum LogicalOperator {
81         OpLogicalAnd,
82         OpLogicalOr
83     };
84
85     typedef HashSet<RefPtr<StringImpl>, IdentifierRepHash> IdentifierSet;
86
87     namespace DeclarationStacks {
88         struct VarDeclaration {
89             VarDeclaration(const Identifier* name, unsigned attributes)
90                 : name(name)
91                 , attributes(attributes)
92                 , reg(0)
93             {
94             }
95             const Identifier* name;
96             unsigned attributes;
97             RegisterID* reg;
98         };
99         struct FunctionDeclaration {
100             explicit FunctionDeclaration(FunctionBodyNode* node)
101                 : node(node)
102                 , reg(0)
103             {
104             }
105             FunctionBodyNode* node;
106             RegisterID* reg;
107         };
108         enum VarAttrs { IsConstant = 1, HasInitializer = 2 };
109         typedef Vector<VarDeclaration> VarStack;
110         typedef Vector<FunctionDeclaration> FunctionStack;
111     }
112
113     struct SwitchInfo {
114         enum SwitchType { SwitchNone, SwitchImmediate, SwitchCharacter, SwitchString };
115         uint32_t bytecodeOffset;
116         SwitchType switchType;
117     };
118
119     class ParserArenaFreeable {
120     public:
121         // ParserArenaFreeable objects are are freed when the arena is deleted.
122         // Destructors are not called. Clients must not call delete on such objects.
123         void* operator new(size_t, JSGlobalData*);
124     };
125
126     class ParserArenaDeletable {
127     public:
128         virtual ~ParserArenaDeletable() { }
129
130         // ParserArenaDeletable objects are deleted when the arena is deleted.
131         // Clients must not call delete directly on such objects.
132         void* operator new(size_t, JSGlobalData*);
133     };
134
135     template <typename T>
136     struct ParserArenaData : ParserArenaDeletable {
137         T data;
138     };
139
140     class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {
141     protected:
142         ParserArenaRefCounted(JSGlobalData*);
143
144     public:
145         virtual ~ParserArenaRefCounted()
146         {
147             ASSERT(deletionHasBegun());
148         }
149     };
150
151     class Node : public ParserArenaFreeable {
152     protected:
153         Node(const JSTokenLocation&);
154
155     public:
156         virtual ~Node() { }
157
158         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;
159
160         int lineNo() const { return m_lineNumber; }
161
162         int columnNo() const { return m_columnNumber; }
163
164     protected:
165         int m_lineNumber;
166         int m_columnNumber;
167     };
168
169     class ExpressionNode : public Node {
170     protected:
171         ExpressionNode(const JSTokenLocation&, ResultType = ResultType::unknownType());
172
173     public:
174         virtual bool isNumber() const { return false; }
175         virtual bool isString() const { return false; }
176         virtual bool isNull() const { return false; }
177         virtual bool isPure(BytecodeGenerator&) const { return false; }        
178         virtual bool isLocation() const { return false; }
179         virtual bool isResolveNode() const { return false; }
180         virtual bool isBracketAccessorNode() const { return false; }
181         virtual bool isDotAccessorNode() const { return false; }
182         virtual bool isFuncExprNode() const { return false; }
183         virtual bool isCommaNode() const { return false; }
184         virtual bool isSimpleArray() const { return false; }
185         virtual bool isAdd() const { return false; }
186         virtual bool isSubtract() const { return false; }
187         virtual bool hasConditionContextCodegen() const { return false; }
188
189         virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, bool) { ASSERT_NOT_REACHED(); }
190
191         virtual ExpressionNode* stripUnaryPlus() { return this; }
192
193         ResultType resultDescriptor() const { return m_resultType; }
194
195     private:
196         ResultType m_resultType;
197     };
198
199     class StatementNode : public Node {
200     protected:
201         StatementNode(const JSTokenLocation&);
202
203     public:
204         JS_EXPORT_PRIVATE void setLoc(int firstLine, int lastLine);
205         void setLoc(int firstLine, int lastLine, int column);
206         int firstLine() const { return lineNo(); }
207         int lastLine() const { return m_lastLine; }
208         int column() const { return columnNo();}
209
210         virtual bool isEmptyStatement() const { return false; }
211         virtual bool isReturnNode() const { return false; }
212         virtual bool isExprStatement() const { return false; }
213
214         virtual bool isBlock() const { return false; }
215
216     private:
217         int m_lastLine;
218     };
219
220     class NullNode : public ExpressionNode {
221     public:
222         NullNode(const JSTokenLocation&);
223
224     private:
225         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
226
227         virtual bool isNull() const { return true; }
228     };
229
230     class BooleanNode : public ExpressionNode {
231     public:
232         BooleanNode(const JSTokenLocation&, bool value);
233
234     private:
235         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
236
237         virtual bool isPure(BytecodeGenerator&) const { return true; }
238
239         bool m_value;
240     };
241
242     class NumberNode : public ExpressionNode {
243     public:
244         NumberNode(const JSTokenLocation&, double value);
245
246         double value() const { return m_value; }
247         void setValue(double value) { m_value = value; }
248
249     private:
250         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
251
252         virtual bool isNumber() const { return true; }
253         virtual bool isPure(BytecodeGenerator&) const { return true; }
254
255         double m_value;
256     };
257
258     class StringNode : public ExpressionNode {
259     public:
260         StringNode(const JSTokenLocation&, const Identifier&);
261
262         const Identifier& value() { return m_value; }
263
264     private:
265         virtual bool isPure(BytecodeGenerator&) const { return true; }
266
267         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
268         
269         virtual bool isString() const { return true; }
270
271         const Identifier& m_value;
272     };
273     
274     class ThrowableExpressionData {
275     public:
276         ThrowableExpressionData()
277             : m_divot(static_cast<uint32_t>(-1))
278             , m_startOffset(static_cast<uint16_t>(-1))
279             , m_endOffset(static_cast<uint16_t>(-1))
280         {
281         }
282         
283         ThrowableExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
284             : m_divot(divot)
285             , m_startOffset(startOffset)
286             , m_endOffset(endOffset)
287         {
288         }
289         
290         void setExceptionSourceCode(unsigned divot, unsigned startOffset, unsigned endOffset)
291         {
292             m_divot = divot;
293             m_startOffset = startOffset;
294             m_endOffset = endOffset;
295         }
296
297         uint32_t divot() const { return m_divot; }
298         uint16_t startOffset() const { return m_startOffset; }
299         uint16_t endOffset() const { return m_endOffset; }
300
301     protected:
302         RegisterID* emitThrowReferenceError(BytecodeGenerator&, const String& message);
303
304     private:
305         uint32_t m_divot;
306         uint16_t m_startOffset;
307         uint16_t m_endOffset;
308     };
309
310     class ThrowableSubExpressionData : public ThrowableExpressionData {
311     public:
312         ThrowableSubExpressionData()
313             : m_subexpressionDivotOffset(0)
314             , m_subexpressionEndOffset(0)
315         {
316         }
317
318         ThrowableSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
319             : ThrowableExpressionData(divot, startOffset, endOffset)
320             , m_subexpressionDivotOffset(0)
321             , m_subexpressionEndOffset(0)
322         {
323         }
324
325         void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)
326         {
327             ASSERT(subexpressionDivot <= divot());
328             if ((divot() - subexpressionDivot) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot
329                 return;
330             m_subexpressionDivotOffset = divot() - subexpressionDivot;
331             m_subexpressionEndOffset = subexpressionOffset;
332         }
333
334     protected:
335         uint16_t m_subexpressionDivotOffset;
336         uint16_t m_subexpressionEndOffset;
337     };
338     
339     class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {
340     public:
341         ThrowablePrefixedSubExpressionData()
342             : m_subexpressionDivotOffset(0)
343             , m_subexpressionStartOffset(0)
344         {
345         }
346
347         ThrowablePrefixedSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
348             : ThrowableExpressionData(divot, startOffset, endOffset)
349             , m_subexpressionDivotOffset(0)
350             , m_subexpressionStartOffset(0)
351         {
352         }
353
354         void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)
355         {
356             ASSERT(subexpressionDivot >= divot());
357             if ((subexpressionDivot - divot()) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot
358                 return;
359             m_subexpressionDivotOffset = subexpressionDivot - divot();
360             m_subexpressionStartOffset = subexpressionOffset;
361         }
362
363     protected:
364         uint16_t m_subexpressionDivotOffset;
365         uint16_t m_subexpressionStartOffset;
366     };
367
368     class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
369     public:
370         RegExpNode(const JSTokenLocation&, const Identifier& pattern, const Identifier& flags);
371
372     private:
373         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
374
375         const Identifier& m_pattern;
376         const Identifier& m_flags;
377     };
378
379     class ThisNode : public ExpressionNode {
380     public:
381         ThisNode(const JSTokenLocation&);
382
383     private:
384         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
385     };
386
387     class ResolveNode : public ExpressionNode {
388     public:
389         ResolveNode(const JSTokenLocation&, const Identifier&, int startOffset);
390
391         const Identifier& identifier() const { return m_ident; }
392
393     private:
394         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
395
396         virtual bool isPure(BytecodeGenerator&) const ;
397         virtual bool isLocation() const { return true; }
398         virtual bool isResolveNode() const { return true; }
399
400         const Identifier& m_ident;
401         int32_t m_startOffset;
402     };
403
404     class ElementNode : public ParserArenaFreeable {
405     public:
406         ElementNode(int elision, ExpressionNode*);
407         ElementNode(ElementNode*, int elision, ExpressionNode*);
408
409         int elision() const { return m_elision; }
410         ExpressionNode* value() { return m_node; }
411         ElementNode* next() { return m_next; }
412
413     private:
414         ElementNode* m_next;
415         int m_elision;
416         ExpressionNode* m_node;
417     };
418
419     class ArrayNode : public ExpressionNode {
420     public:
421         ArrayNode(const JSTokenLocation&, int elision);
422         ArrayNode(const JSTokenLocation&, ElementNode*);
423         ArrayNode(const JSTokenLocation&, int elision, ElementNode*);
424
425         ArgumentListNode* toArgumentList(JSGlobalData*, int, int) const;
426
427     private:
428         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
429
430         virtual bool isSimpleArray() const ;
431
432         ElementNode* m_element;
433         int m_elision;
434         bool m_optional;
435     };
436
437     class PropertyNode : public ParserArenaFreeable {
438     public:
439         enum Type { Constant = 1, Getter = 2, Setter = 4 };
440
441         PropertyNode(JSGlobalData*, const Identifier&, ExpressionNode*, Type);
442         PropertyNode(JSGlobalData*, double, ExpressionNode*, Type);
443
444         const Identifier& name() const { return m_name; }
445         Type type() const { return m_type; }
446
447     private:
448         friend class PropertyListNode;
449         const Identifier& m_name;
450         ExpressionNode* m_assign;
451         Type m_type;
452     };
453
454     class PropertyListNode : public Node {
455     public:
456         PropertyListNode(const JSTokenLocation&, PropertyNode*);
457         PropertyListNode(const JSTokenLocation&, PropertyNode*, PropertyListNode*);
458
459         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
460
461     private:
462         PropertyNode* m_node;
463         PropertyListNode* m_next;
464     };
465
466     class ObjectLiteralNode : public ExpressionNode {
467     public:
468         ObjectLiteralNode(const JSTokenLocation&);
469         ObjectLiteralNode(const JSTokenLocation&, PropertyListNode*);
470
471     private:
472         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
473
474         PropertyListNode* m_list;
475     };
476     
477     class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
478     public:
479         BracketAccessorNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);
480
481         ExpressionNode* base() const { return m_base; }
482         ExpressionNode* subscript() const { return m_subscript; }
483
484         bool subscriptHasAssignments() const { return m_subscriptHasAssignments; }
485
486     private:
487         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
488
489         virtual bool isLocation() const { return true; }
490         virtual bool isBracketAccessorNode() const { return true; }
491
492         ExpressionNode* m_base;
493         ExpressionNode* m_subscript;
494         bool m_subscriptHasAssignments;
495     };
496
497     class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
498     public:
499         DotAccessorNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&);
500
501         ExpressionNode* base() const { return m_base; }
502         const Identifier& identifier() const { return m_ident; }
503
504     private:
505         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
506
507         virtual bool isLocation() const { return true; }
508         virtual bool isDotAccessorNode() const { return true; }
509
510         ExpressionNode* m_base;
511         const Identifier& m_ident;
512     };
513
514     class ArgumentListNode : public Node {
515     public:
516         ArgumentListNode(const JSTokenLocation&, ExpressionNode*);
517         ArgumentListNode(const JSTokenLocation&, ArgumentListNode*, ExpressionNode*);
518
519         ArgumentListNode* m_next;
520         ExpressionNode* m_expr;
521
522     private:
523         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
524     };
525
526     class ArgumentsNode : public ParserArenaFreeable {
527     public:
528         ArgumentsNode();
529         ArgumentsNode(ArgumentListNode*);
530
531         ArgumentListNode* m_listNode;
532     };
533
534     class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
535     public:
536         NewExprNode(const JSTokenLocation&, ExpressionNode*);
537         NewExprNode(const JSTokenLocation&, ExpressionNode*, ArgumentsNode*);
538
539     private:
540         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
541
542         ExpressionNode* m_expr;
543         ArgumentsNode* m_args;
544     };
545
546     class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
547     public:
548         EvalFunctionCallNode(const JSTokenLocation&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
549
550     private:
551         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
552
553         ArgumentsNode* m_args;
554     };
555
556     class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
557     public:
558         FunctionCallValueNode(const JSTokenLocation&, ExpressionNode*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
559
560     private:
561         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
562
563         ExpressionNode* m_expr;
564         ArgumentsNode* m_args;
565     };
566
567     class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
568     public:
569         FunctionCallResolveNode(const JSTokenLocation&, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
570
571     private:
572         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
573
574         const Identifier& m_ident;
575         ArgumentsNode* m_args;
576     };
577     
578     class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
579     public:
580         FunctionCallBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
581
582     private:
583         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
584
585         ExpressionNode* m_base;
586         ExpressionNode* m_subscript;
587         ArgumentsNode* m_args;
588     };
589
590     class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
591     public:
592         FunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
593
594     private:
595         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
596
597     protected:
598         ExpressionNode* m_base;
599         const Identifier& m_ident;
600         ArgumentsNode* m_args;
601     };
602
603     class CallFunctionCallDotNode : public FunctionCallDotNode {
604     public:
605         CallFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
606
607     private:
608         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
609     };
610     
611     class ApplyFunctionCallDotNode : public FunctionCallDotNode {
612     public:
613         ApplyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
614
615     private:
616         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
617     };
618
619     class PostfixNode : public ExpressionNode, public ThrowableExpressionData {
620     public:
621         PostfixNode(const JSTokenLocation&, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
622
623     private:
624         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
625         virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0);
626         virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0);
627         virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0);
628
629         ExpressionNode* m_expr;
630         Operator m_operator;
631     };
632
633     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
634     public:
635         DeleteResolveNode(const JSTokenLocation&, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
636
637     private:
638         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
639
640         const Identifier& m_ident;
641     };
642
643     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
644     public:
645         DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
646
647     private:
648         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
649
650         ExpressionNode* m_base;
651         ExpressionNode* m_subscript;
652     };
653
654     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
655     public:
656         DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
657
658     private:
659         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
660
661         ExpressionNode* m_base;
662         const Identifier& m_ident;
663     };
664
665     class DeleteValueNode : public ExpressionNode {
666     public:
667         DeleteValueNode(const JSTokenLocation&, ExpressionNode*);
668
669     private:
670         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
671
672         ExpressionNode* m_expr;
673     };
674
675     class VoidNode : public ExpressionNode {
676     public:
677         VoidNode(const JSTokenLocation&, ExpressionNode*);
678
679     private:
680         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
681
682         ExpressionNode* m_expr;
683     };
684
685     class TypeOfResolveNode : public ExpressionNode {
686     public:
687         TypeOfResolveNode(const JSTokenLocation&, const Identifier&);
688
689         const Identifier& identifier() const { return m_ident; }
690
691     private:
692         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
693
694         const Identifier& m_ident;
695     };
696
697     class TypeOfValueNode : public ExpressionNode {
698     public:
699         TypeOfValueNode(const JSTokenLocation&, ExpressionNode*);
700
701     private:
702         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
703
704         ExpressionNode* m_expr;
705     };
706
707     class PrefixNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
708     public:
709         PrefixNode(const JSTokenLocation&, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
710
711     private:
712         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
713         virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0);
714         virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0);
715         virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0);
716
717         ExpressionNode* m_expr;
718         Operator m_operator;
719     };
720
721     class UnaryOpNode : public ExpressionNode {
722     public:
723         UnaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode*, OpcodeID);
724
725     protected:
726         ExpressionNode* expr() { return m_expr; }
727         const ExpressionNode* expr() const { return m_expr; }
728
729     private:
730         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
731
732         OpcodeID opcodeID() const { return m_opcodeID; }
733
734         ExpressionNode* m_expr;
735         OpcodeID m_opcodeID;
736     };
737
738     class UnaryPlusNode : public UnaryOpNode {
739     public:
740         UnaryPlusNode(const JSTokenLocation&, ExpressionNode*);
741
742     private:
743         virtual ExpressionNode* stripUnaryPlus() { return expr(); }
744     };
745
746     class NegateNode : public UnaryOpNode {
747     public:
748         NegateNode(const JSTokenLocation&, ExpressionNode*);
749     };
750
751     class BitwiseNotNode : public ExpressionNode {
752     public:
753         BitwiseNotNode(const JSTokenLocation&, ExpressionNode*);
754
755     protected:
756         ExpressionNode* expr() { return m_expr; }
757         const ExpressionNode* expr() const { return m_expr; }
758
759     private:
760         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
761
762         ExpressionNode* m_expr;
763     };
764  
765     class LogicalNotNode : public UnaryOpNode {
766     public:
767         LogicalNotNode(const JSTokenLocation&, ExpressionNode*);
768     private:
769         void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);
770         virtual bool hasConditionContextCodegen() const { return expr()->hasConditionContextCodegen(); }
771     };
772
773     class BinaryOpNode : public ExpressionNode {
774     public:
775         BinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
776         BinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
777
778         RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);
779
780         ExpressionNode* lhs() { return m_expr1; };
781         ExpressionNode* rhs() { return m_expr2; };
782
783     private:
784         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
785
786     protected:
787         OpcodeID opcodeID() const { return m_opcodeID; }
788
789     protected:
790         ExpressionNode* m_expr1;
791         ExpressionNode* m_expr2;
792     private:
793         OpcodeID m_opcodeID;
794     protected:
795         bool m_rightHasAssignments;
796     };
797
798     class MultNode : public BinaryOpNode {
799     public:
800         MultNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
801     };
802
803     class DivNode : public BinaryOpNode {
804     public:
805         DivNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
806     };
807
808     class ModNode : public BinaryOpNode {
809     public:
810         ModNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
811     };
812
813     class AddNode : public BinaryOpNode {
814     public:
815         AddNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
816
817         virtual bool isAdd() const { return true; }
818     };
819
820     class SubNode : public BinaryOpNode {
821     public:
822         SubNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
823
824         virtual bool isSubtract() const { return true; }
825     };
826
827     class LeftShiftNode : public BinaryOpNode {
828     public:
829         LeftShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
830     };
831
832     class RightShiftNode : public BinaryOpNode {
833     public:
834         RightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
835     };
836
837     class UnsignedRightShiftNode : public BinaryOpNode {
838     public:
839         UnsignedRightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
840     };
841
842     class LessNode : public BinaryOpNode {
843     public:
844         LessNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
845     };
846
847     class GreaterNode : public BinaryOpNode {
848     public:
849         GreaterNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
850     };
851
852     class LessEqNode : public BinaryOpNode {
853     public:
854         LessEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
855     };
856
857     class GreaterEqNode : public BinaryOpNode {
858     public:
859         GreaterEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
860     };
861
862     class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
863     public:
864         ThrowableBinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
865         ThrowableBinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
866
867     private:
868         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
869     };
870     
871     class InstanceOfNode : public ThrowableBinaryOpNode {
872     public:
873         InstanceOfNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
874
875     private:
876         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
877     };
878
879     class InNode : public ThrowableBinaryOpNode {
880     public:
881         InNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
882     };
883
884     class EqualNode : public BinaryOpNode {
885     public:
886         EqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
887
888     private:
889         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
890     };
891
892     class NotEqualNode : public BinaryOpNode {
893     public:
894         NotEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
895     };
896
897     class StrictEqualNode : public BinaryOpNode {
898     public:
899         StrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
900
901     private:
902         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
903     };
904
905     class NotStrictEqualNode : public BinaryOpNode {
906     public:
907         NotStrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
908     };
909
910     class BitAndNode : public BinaryOpNode {
911     public:
912         BitAndNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
913     };
914
915     class BitOrNode : public BinaryOpNode {
916     public:
917         BitOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
918     };
919
920     class BitXOrNode : public BinaryOpNode {
921     public:
922         BitXOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
923     };
924
925     // m_expr1 && m_expr2, m_expr1 || m_expr2
926     class LogicalOpNode : public ExpressionNode {
927     public:
928         LogicalOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);
929
930     private:
931         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
932         void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);
933         virtual bool hasConditionContextCodegen() const { return true; }
934
935         ExpressionNode* m_expr1;
936         ExpressionNode* m_expr2;
937         LogicalOperator m_operator;
938     };
939
940     // The ternary operator, "m_logical ? m_expr1 : m_expr2"
941     class ConditionalNode : public ExpressionNode {
942     public:
943         ConditionalNode(const JSTokenLocation&, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);
944
945     private:
946         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
947
948         ExpressionNode* m_logical;
949         ExpressionNode* m_expr1;
950         ExpressionNode* m_expr2;
951     };
952
953     class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
954     public:
955         ReadModifyResolveNode(const JSTokenLocation&, const Identifier&, Operator, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
956
957     private:
958         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
959
960         const Identifier& m_ident;
961         ExpressionNode* m_right;
962         Operator m_operator;
963         bool m_rightHasAssignments;
964     };
965
966     class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
967     public:
968         AssignResolveNode(const JSTokenLocation&, const Identifier&, ExpressionNode* right);
969
970     private:
971         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
972
973         const Identifier& m_ident;
974         ExpressionNode* m_right;
975     };
976
977     class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
978     public:
979         ReadModifyBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
980
981     private:
982         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
983
984         ExpressionNode* m_base;
985         ExpressionNode* m_subscript;
986         ExpressionNode* m_right;
987         Operator m_operator : 30;
988         bool m_subscriptHasAssignments : 1;
989         bool m_rightHasAssignments : 1;
990     };
991
992     class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
993     public:
994         AssignBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
995
996     private:
997         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
998
999         ExpressionNode* m_base;
1000         ExpressionNode* m_subscript;
1001         ExpressionNode* m_right;
1002         bool m_subscriptHasAssignments : 1;
1003         bool m_rightHasAssignments : 1;
1004     };
1005
1006     class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
1007     public:
1008         AssignDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
1009
1010     private:
1011         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1012
1013         ExpressionNode* m_base;
1014         const Identifier& m_ident;
1015         ExpressionNode* m_right;
1016         bool m_rightHasAssignments;
1017     };
1018
1019     class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
1020     public:
1021         ReadModifyDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
1022
1023     private:
1024         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1025
1026         ExpressionNode* m_base;
1027         const Identifier& m_ident;
1028         ExpressionNode* m_right;
1029         Operator m_operator : 31;
1030         bool m_rightHasAssignments : 1;
1031     };
1032
1033     class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
1034     public:
1035         AssignErrorNode(const JSTokenLocation&, unsigned divot, unsigned startOffset, unsigned endOffset);
1036
1037     private:
1038         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1039     };
1040     
1041     typedef Vector<ExpressionNode*, 8> ExpressionVector;
1042
1043     class CommaNode : public ExpressionNode, public ParserArenaDeletable {
1044     public:
1045         CommaNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2);
1046
1047         using ParserArenaDeletable::operator new;
1048
1049         void append(ExpressionNode* expr) { m_expressions.append(expr); }
1050
1051     private:
1052         virtual bool isCommaNode() const { return true; }
1053         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1054
1055         ExpressionVector m_expressions;
1056     };
1057     
1058     class ConstDeclNode : public ExpressionNode {
1059     public:
1060         ConstDeclNode(const JSTokenLocation&, const Identifier&, ExpressionNode*);
1061
1062         bool hasInitializer() const { return m_init; }
1063         const Identifier& ident() { return m_ident; }
1064
1065     private:
1066         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1067         virtual RegisterID* emitCodeSingle(BytecodeGenerator&);
1068
1069         const Identifier& m_ident;
1070
1071     public:
1072         ConstDeclNode* m_next;
1073
1074     private:
1075         ExpressionNode* m_init;
1076     };
1077
1078     class ConstStatementNode : public StatementNode {
1079     public:
1080         ConstStatementNode(const JSTokenLocation&, ConstDeclNode* next);
1081
1082     private:
1083         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1084
1085         ConstDeclNode* m_next;
1086     };
1087
1088     class SourceElements : public ParserArenaDeletable {
1089     public:
1090         SourceElements();
1091
1092         void append(StatementNode*);
1093
1094         StatementNode* singleStatement() const;
1095         StatementNode* lastStatement() const;
1096
1097         void emitBytecode(BytecodeGenerator&, RegisterID* destination);
1098
1099     private:
1100         Vector<StatementNode*> m_statements;
1101     };
1102
1103     class BlockNode : public StatementNode {
1104     public:
1105         BlockNode(const JSTokenLocation&, SourceElements* = 0);
1106
1107         StatementNode* singleStatement() const;
1108         StatementNode* lastStatement() const;
1109
1110     private:
1111         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1112
1113         virtual bool isBlock() const { return true; }
1114
1115         SourceElements* m_statements;
1116     };
1117
1118     class EmptyStatementNode : public StatementNode {
1119     public:
1120         EmptyStatementNode(const JSTokenLocation&);
1121
1122     private:
1123         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1124
1125         virtual bool isEmptyStatement() const { return true; }
1126     };
1127     
1128     class DebuggerStatementNode : public StatementNode {
1129     public:
1130         DebuggerStatementNode(const JSTokenLocation&);
1131         
1132     private:
1133         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1134     };
1135
1136     class ExprStatementNode : public StatementNode {
1137     public:
1138         ExprStatementNode(const JSTokenLocation&, ExpressionNode*);
1139
1140         ExpressionNode* expr() const { return m_expr; }
1141
1142     private:
1143         virtual bool isExprStatement() const { return true; }
1144
1145         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1146
1147         ExpressionNode* m_expr;
1148     };
1149
1150     class VarStatementNode : public StatementNode {
1151     public:
1152         VarStatementNode(const JSTokenLocation&, ExpressionNode*);
1153     private:
1154         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1155
1156         ExpressionNode* m_expr;
1157     };
1158
1159     class IfNode : public StatementNode {
1160     public:
1161         IfNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock);
1162
1163     protected:
1164         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1165
1166         ExpressionNode* m_condition;
1167         StatementNode* m_ifBlock;
1168     };
1169
1170     class IfElseNode : public IfNode {
1171     public:
1172         IfElseNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
1173
1174     private:
1175         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1176
1177         StatementNode* m_elseBlock;
1178     };
1179
1180     class DoWhileNode : public StatementNode {
1181     public:
1182         DoWhileNode(const JSTokenLocation&, StatementNode*, ExpressionNode*);
1183
1184     private:
1185         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1186
1187         StatementNode* m_statement;
1188         ExpressionNode* m_expr;
1189     };
1190
1191     class WhileNode : public StatementNode {
1192     public:
1193         WhileNode(const JSTokenLocation&, ExpressionNode*, StatementNode*);
1194
1195     private:
1196         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1197
1198         ExpressionNode* m_expr;
1199         StatementNode* m_statement;
1200     };
1201
1202     class ForNode : public StatementNode {
1203     public:
1204         ForNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode*);
1205
1206     private:
1207         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1208
1209         ExpressionNode* m_expr1;
1210         ExpressionNode* m_expr2;
1211         ExpressionNode* m_expr3;
1212         StatementNode* m_statement;
1213     };
1214
1215     class ForInNode : public StatementNode, public ThrowableExpressionData {
1216     public:
1217         ForInNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
1218         ForInNode(JSGlobalData*, const JSTokenLocation&, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset);
1219
1220     private:
1221         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1222
1223         ExpressionNode* m_init;
1224         ExpressionNode* m_lexpr;
1225         ExpressionNode* m_expr;
1226         StatementNode* m_statement;
1227         bool m_identIsVarDecl;
1228     };
1229
1230     class ContinueNode : public StatementNode, public ThrowableExpressionData {
1231     public:
1232         ContinueNode(JSGlobalData*, const JSTokenLocation&);
1233         ContinueNode(const JSTokenLocation&, const Identifier&);
1234         
1235     private:
1236         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1237
1238         const Identifier& m_ident;
1239     };
1240
1241     class BreakNode : public StatementNode, public ThrowableExpressionData {
1242     public:
1243         BreakNode(JSGlobalData*, const JSTokenLocation&);
1244         BreakNode(const JSTokenLocation&, const Identifier&);
1245         
1246     private:
1247         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1248
1249         const Identifier& m_ident;
1250     };
1251
1252     class ReturnNode : public StatementNode, public ThrowableExpressionData {
1253     public:
1254         ReturnNode(const JSTokenLocation&, ExpressionNode* value);
1255
1256         ExpressionNode* value() { return m_value; }
1257
1258     private:
1259         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1260
1261         virtual bool isReturnNode() const { return true; }
1262
1263         ExpressionNode* m_value;
1264     };
1265
1266     class WithNode : public StatementNode {
1267     public:
1268         WithNode(const JSTokenLocation&, ExpressionNode*, StatementNode*, uint32_t divot, uint32_t expressionLength);
1269
1270     private:
1271         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1272
1273         ExpressionNode* m_expr;
1274         StatementNode* m_statement;
1275         uint32_t m_divot;
1276         uint32_t m_expressionLength;
1277     };
1278
1279     class LabelNode : public StatementNode, public ThrowableExpressionData {
1280     public:
1281         LabelNode(const JSTokenLocation&, const Identifier& name, StatementNode*);
1282
1283     private:
1284         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1285
1286         const Identifier& m_name;
1287         StatementNode* m_statement;
1288     };
1289
1290     class ThrowNode : public StatementNode, public ThrowableExpressionData {
1291     public:
1292         ThrowNode(const JSTokenLocation&, ExpressionNode*);
1293
1294     private:
1295         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1296
1297         ExpressionNode* m_expr;
1298     };
1299
1300     class TryNode : public StatementNode {
1301     public:
1302         TryNode(const JSTokenLocation&, StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock);
1303
1304     private:
1305         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1306
1307         StatementNode* m_tryBlock;
1308         const Identifier& m_exceptionIdent;
1309         StatementNode* m_catchBlock;
1310         StatementNode* m_finallyBlock;
1311     };
1312
1313     class ParameterNode : public ParserArenaFreeable {
1314     public:
1315         ParameterNode(const Identifier&);
1316         ParameterNode(ParameterNode*, const Identifier&);
1317
1318         const Identifier& ident() const { return m_ident; }
1319         ParameterNode* nextParam() const { return m_next; }
1320
1321     private:
1322         const Identifier& m_ident;
1323         ParameterNode* m_next;
1324     };
1325
1326     class ScopeNode : public StatementNode, public ParserArenaRefCounted {
1327     public:
1328         typedef DeclarationStacks::VarStack VarStack;
1329         typedef DeclarationStacks::FunctionStack FunctionStack;
1330
1331         ScopeNode(JSGlobalData*, const JSTokenLocation&, bool inStrictContext);
1332         ScopeNode(JSGlobalData*, const JSTokenLocation&, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, CodeFeatures, int numConstants);
1333
1334         using ParserArenaRefCounted::operator new;
1335
1336         void destroyData()
1337         {
1338             m_arena.reset();
1339             m_varStack.clear();
1340             m_functionStack.clear();
1341             m_statements = 0;
1342             m_capturedVariables.clear();
1343         }
1344
1345         const SourceCode& source() const { return m_source; }
1346         const String& sourceURL() const { return m_source.provider()->url(); }
1347         intptr_t sourceID() const { return m_source.providerID(); }
1348
1349         void setFeatures(CodeFeatures features) { m_features = features; }
1350         CodeFeatures features() { return m_features; }
1351
1352         bool usesEval() const { return m_features & EvalFeature; }
1353         bool usesArguments() const { return (m_features & ArgumentsFeature) && !(m_features & ShadowsArgumentsFeature); }
1354         bool isStrictMode() const { return m_features & StrictModeFeature; }
1355         void setUsesArguments() { m_features |= ArgumentsFeature; }
1356         bool usesThis() const { return m_features & ThisFeature; }
1357         bool needsActivationForMoreThanVariables() const { return m_features & (EvalFeature | WithFeature | CatchFeature); }
1358         bool needsActivation() const { return (hasCapturedVariables()) || (m_features & (EvalFeature | WithFeature | CatchFeature)); }
1359         bool hasCapturedVariables() const { return !!m_capturedVariables.size(); }
1360         size_t capturedVariableCount() const { return m_capturedVariables.size(); }
1361         bool captures(const Identifier& ident) { return m_capturedVariables.contains(ident.impl()); }
1362
1363         VarStack& varStack() { return m_varStack; }
1364         FunctionStack& functionStack() { return m_functionStack; }
1365
1366         int neededConstants()
1367         {
1368             // We may need 2 more constants than the count given by the parser,
1369             // because of the various uses of jsUndefined() and jsNull().
1370             return m_numConstants + 2;
1371         }
1372
1373         StatementNode* singleStatement() const;
1374
1375         void emitStatementsBytecode(BytecodeGenerator&, RegisterID* destination);
1376
1377     protected:
1378         void setSource(const SourceCode& source) { m_source = source; }
1379         ParserArena m_arena;
1380
1381     private:
1382         CodeFeatures m_features;
1383         SourceCode m_source;
1384         VarStack m_varStack;
1385         FunctionStack m_functionStack;
1386         int m_numConstants;
1387         SourceElements* m_statements;
1388         IdentifierSet m_capturedVariables;
1389     };
1390
1391     class ProgramNode : public ScopeNode {
1392     public:
1393         static const bool isFunctionNode = false;
1394         static PassRefPtr<ProgramNode> create(JSGlobalData*, const JSTokenLocation&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1395
1396         static const bool scopeIsFunction = false;
1397
1398     private:
1399         ProgramNode(JSGlobalData*, const JSTokenLocation&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1400
1401         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1402     };
1403
1404     class EvalNode : public ScopeNode {
1405     public:
1406         static const bool isFunctionNode = false;
1407         static PassRefPtr<EvalNode> create(JSGlobalData*, const JSTokenLocation&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1408
1409         static const bool scopeIsFunction = false;
1410
1411     private:
1412         EvalNode(JSGlobalData*, const JSTokenLocation&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1413
1414         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1415     };
1416
1417     class FunctionParameters : public Vector<Identifier>, public RefCounted<FunctionParameters> {
1418         WTF_MAKE_FAST_ALLOCATED;
1419     public:
1420         static PassRefPtr<FunctionParameters> create(ParameterNode* firstParameter) { return adoptRef(new FunctionParameters(firstParameter)); }
1421
1422     private:
1423         FunctionParameters(ParameterNode*);
1424     };
1425
1426     enum FunctionNameIsInScopeToggle { FunctionNameIsNotInScope, FunctionNameIsInScope };
1427     class FunctionBodyNode : public ScopeNode {
1428     public:
1429         static const bool isFunctionNode = true;
1430         static FunctionBodyNode* create(JSGlobalData*, const JSTokenLocation&, bool isStrictMode);
1431         static PassRefPtr<FunctionBodyNode> create(JSGlobalData*, const JSTokenLocation&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1432
1433         FunctionParameters* parameters() const { return m_parameters.get(); }
1434         size_t parameterCount() const { return m_parameters->size(); }
1435
1436         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1437
1438         void finishParsing(const SourceCode&, ParameterNode*, const Identifier&, FunctionNameIsInScopeToggle);
1439         void finishParsing(PassRefPtr<FunctionParameters>, const Identifier&, FunctionNameIsInScopeToggle);
1440         
1441         const Identifier& ident() { return m_ident; }
1442         void setInferredName(const Identifier& inferredName) { ASSERT(!inferredName.isNull()); m_inferredName = inferredName; }
1443         const Identifier& inferredName() { return m_inferredName.isEmpty() ? m_ident : m_inferredName; }
1444
1445         bool functionNameIsInScope() { return m_functionNameIsInScopeToggle == FunctionNameIsInScope; }
1446         FunctionNameIsInScopeToggle functionNameIsInScopeToggle() { return m_functionNameIsInScopeToggle; }
1447
1448         static const bool scopeIsFunction = true;
1449
1450     private:
1451         FunctionBodyNode(JSGlobalData*, const JSTokenLocation&, bool inStrictContext);
1452         FunctionBodyNode(JSGlobalData*, const JSTokenLocation&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1453
1454         Identifier m_ident;
1455         Identifier m_inferredName;
1456         FunctionNameIsInScopeToggle m_functionNameIsInScopeToggle;
1457         RefPtr<FunctionParameters> m_parameters;
1458     };
1459
1460     class FuncExprNode : public ExpressionNode {
1461     public:
1462         FuncExprNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
1463
1464         FunctionBodyNode* body() { return m_body; }
1465
1466     private:
1467         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1468
1469         virtual bool isFuncExprNode() const { return true; } 
1470
1471         FunctionBodyNode* m_body;
1472     };
1473
1474     class FuncDeclNode : public StatementNode {
1475     public:
1476         FuncDeclNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
1477
1478         FunctionBodyNode* body() { return m_body; }
1479
1480     private:
1481         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1482
1483         FunctionBodyNode* m_body;
1484     };
1485
1486     class CaseClauseNode : public ParserArenaFreeable {
1487     public:
1488         CaseClauseNode(ExpressionNode*, SourceElements* = 0);
1489
1490         ExpressionNode* expr() const { return m_expr; }
1491
1492         void emitBytecode(BytecodeGenerator&, RegisterID* destination);
1493
1494     private:
1495         ExpressionNode* m_expr;
1496         SourceElements* m_statements;
1497     };
1498
1499     class ClauseListNode : public ParserArenaFreeable {
1500     public:
1501         ClauseListNode(CaseClauseNode*);
1502         ClauseListNode(ClauseListNode*, CaseClauseNode*);
1503
1504         CaseClauseNode* getClause() const { return m_clause; }
1505         ClauseListNode* getNext() const { return m_next; }
1506
1507     private:
1508         CaseClauseNode* m_clause;
1509         ClauseListNode* m_next;
1510     };
1511
1512     class CaseBlockNode : public ParserArenaFreeable {
1513     public:
1514         CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2);
1515
1516         RegisterID* emitBytecodeForBlock(BytecodeGenerator&, RegisterID* input, RegisterID* destination);
1517
1518     private:
1519         SwitchInfo::SwitchType tryOptimizedSwitch(Vector<ExpressionNode*, 8>& literalVector, int32_t& min_num, int32_t& max_num);
1520         ClauseListNode* m_list1;
1521         CaseClauseNode* m_defaultClause;
1522         ClauseListNode* m_list2;
1523     };
1524
1525     class SwitchNode : public StatementNode {
1526     public:
1527         SwitchNode(const JSTokenLocation&, ExpressionNode*, CaseBlockNode*);
1528
1529     private:
1530         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
1531
1532         ExpressionNode* m_expr;
1533         CaseBlockNode* m_block;
1534     };
1535
1536     struct ElementList {
1537         ElementNode* head;
1538         ElementNode* tail;
1539     };
1540
1541     struct PropertyList {
1542         PropertyListNode* head;
1543         PropertyListNode* tail;
1544     };
1545
1546     struct ArgumentList {
1547         ArgumentListNode* head;
1548         ArgumentListNode* tail;
1549     };
1550
1551     struct ConstDeclList {
1552         ConstDeclNode* head;
1553         ConstDeclNode* tail;
1554     };
1555
1556     struct ParameterList {
1557         ParameterNode* head;
1558         ParameterNode* tail;
1559     };
1560
1561     struct ClauseList {
1562         ClauseListNode* head;
1563         ClauseListNode* tail;
1564     };
1565
1566 } // namespace JSC
1567
1568 #endif // Nodes_h