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