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