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