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