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