Changeset 43311 in webkit for trunk/JavaScriptCore/parser


Ignore:
Timestamp:
May 6, 2009, 10:10:22 AM (16 years ago)
Author:
Darin Adler
Message:

2009-05-06 Darin Adler <Darin Adler>

Working with Sam Weinig.

Redo parse tree constructor optimization without breaking the Windows
build the way I did yesterday. The previous try broke the build by adding
an include of Lexer.h and all its dependencies that had to work outside
the JavaScriptCore project.

  • GNUmakefile.am: Added NodeConstructors.h.
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: Ditto.
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCoreCommon.vsprops: Removed byteocde directory -- we no longer are trying to include Lexer.h outside JavaScriptCore.
  • JavaScriptCore.xcodeproj/project.pbxproj: Change SegmentedVector.h and Lexer.h back to internal files. Added NodeConstructors.h.
  • parser/Grammar.y: Added include of NodeConstructors.h. Changed use of ConstDeclNode to use public functions.
  • parser/NodeConstructors.h: Copied from parser/Nodes.h. Just contains the inlined constructors now.
  • parser/Nodes.cpp: Added include of NodeConstructors.h. Moved node constructors into the header. (JSC::FunctionBodyNode::FunctionBodyNode): Removed m_refCount initialization.
  • parser/Nodes.h: Removed all the constructor definitions, and also removed the JSC_FAST_CALL from them since these are all inlined, so the calling convention is irrelevant. Made more things private. Used a data member for operator opcodes instead of a virtual function. Removed the special FunctionBodyNode::ref/deref functions since the default functions are now just as fast.
  • runtime/FunctionConstructor.cpp: (JSC::extractFunctionBody): Fixed types here so we don't typecast until after we do type checking.
Location:
trunk/JavaScriptCore/parser
Files:
3 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/parser/Grammar.y

    r43156 r43311  
    3030#include "JSValue.h"
    3131#include "JSObject.h"
    32 #include "Nodes.h"
     32#include "NodeConstructors.h"
    3333#include "Lexer.h"
    3434#include "JSString.h"
    … …  
    148148{
    149149    unsigned attrs = DeclarationStacks::IsConstant;
    150     if (decl->m_init)
     150    if (decl->hasInitializer())
    151151        attrs |= DeclarationStacks::HasInitializer;       
    152     appendToVarDeclarationList(globalPtr, varDecls, decl->m_ident, attrs);
     152    appendToVarDeclarationList(globalPtr, varDecls, decl->ident(), attrs);
    153153}
    154154

  • trunk/JavaScriptCore/parser/NodeConstructors.h

    r43276 r43311  
    11/*
    2  *  Copyright (C) 1999-2000 Harri Porten ([email protected])
    3  *  Copyright (C) 2001 Peter Kelly ([email protected])
    4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
    5  *  Copyright (C) 2007 Cameron Zwarich ([email protected])
    6  *  Copyright (C) 2007 Maks Orlovich
    7  *  Copyright (C) 2007 Eric Seidel <[email protected]>
     2 *  Copyright (C) 2009 Apple Inc. All rights reserved.
    83 *
    94 *  This library is free software; you can redistribute it and/or
    … …  
    2419 */
    2520
    26 #ifndef NODES_H_
    27 #define NODES_H_
    28 
    29 #include "Error.h"
    30 #include "JITCode.h"
    31 #include "Opcode.h"
    32 #include "ResultType.h"
    33 #include "SourceCode.h"
    34 #include "SymbolTable.h"
    35 #include <wtf/MathExtras.h>
    36 #include <wtf/OwnPtr.h>
    37 
    38 #if PLATFORM(X86) && COMPILER(GCC)
    39 #define JSC_FAST_CALL __attribute__((regparm(3)))
    40 #else
    41 #define JSC_FAST_CALL
    42 #endif
     21#ifndef NodeConstructors_h
     22#define NodeConstructors_h
     23
     24#include "Nodes.h"
     25#include "Lexer.h"
    4326
    4427namespace JSC {
    45 
    46     class ArgumentListNode;
    47     class CodeBlock;
    48     class BytecodeGenerator;
    49     class FuncDeclNode;
    50     class EvalCodeBlock;
    51     class JSFunction;
    52     class NodeReleaser;
    53     class ProgramCodeBlock;
    54     class PropertyListNode;
    55     class RegisterID;
    56     class ScopeChainNode;
    57 
    58     typedef unsigned CodeFeatures;
    59 
    60     const CodeFeatures NoFeatures = 0;
    61     const CodeFeatures EvalFeature = 1 << 0;
    62     const CodeFeatures ClosureFeature = 1 << 1;
    63     const CodeFeatures AssignFeature = 1 << 2;
    64     const CodeFeatures ArgumentsFeature = 1 << 3;
    65     const CodeFeatures WithFeature = 1 << 4;
    66     const CodeFeatures CatchFeature = 1 << 5;
    67     const CodeFeatures ThisFeature = 1 << 6;
    68     const CodeFeatures AllFeatures = EvalFeature | ClosureFeature | AssignFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature;
    69 
    70     enum Operator {
    71         OpEqual,
    72         OpPlusEq,
    73         OpMinusEq,
    74         OpMultEq,
    75         OpDivEq,
    76         OpPlusPlus,
    77         OpMinusMinus,
    78         OpAndEq,
    79         OpXOrEq,
    80         OpOrEq,
    81         OpModEq,
    82         OpLShift,
    83         OpRShift,
    84         OpURShift
    85     };
    86    
    87     enum LogicalOperator {
    88         OpLogicalAnd,
    89         OpLogicalOr
    90     };
    91 
    92     namespace DeclarationStacks {
    93         enum VarAttrs { IsConstant = 1, HasInitializer = 2 };
    94         typedef Vector<std::pair<Identifier, unsigned> > VarStack;
    95         typedef Vector<RefPtr<FuncDeclNode> > FunctionStack;
    96     }
    97 
    98     struct SwitchInfo {
    99         enum SwitchType { SwitchNone, SwitchImmediate, SwitchCharacter, SwitchString };
    100         uint32_t bytecodeOffset;
    101         SwitchType switchType;
    102     };
    103 
    104     class ParserRefCounted : public RefCounted<ParserRefCounted> {
    105     protected:
    106         ParserRefCounted(JSGlobalData*) JSC_FAST_CALL;
    107 
    108     public:
    109         virtual ~ParserRefCounted();
    110 
    111         // Nonrecursive destruction.
    112         virtual void releaseNodes(NodeReleaser&);
    113     };
    11428
    11529#ifdef NDEBUG
    … …  
    11832        globalData->parserObjects.append(adoptRef(this));
    11933    }
    120 
    121     inline ParserRefCounted::~ParserRefCounted()
    122     {
    123     }
    12434#endif
    12535
    126     class Node : public ParserRefCounted {
    127     public:
    128         Node(JSGlobalData* globalData) JSC_FAST_CALL;
    129 
    130         /*
    131             Return value: The register holding the production's value.
    132                      dst: An optional parameter specifying the most efficient
    133                           destination at which to store the production's value.
    134                           The callee must honor dst.
    135 
    136             dst provides for a crude form of copy propagation. For example,
    137 
    138             x = 1
    139 
    140             becomes
    141            
    142             load r[x], 1
    143            
    144             instead of
    145 
    146             load r0, 1
    147             mov r[x], r0
    148            
    149             because the assignment node, "x =", passes r[x] as dst to the number
    150             node, "1".
    151         */
    152         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* dst = 0) JSC_FAST_CALL = 0;
    153 
    154         int lineNo() const { return m_line; }
    155 
    156     protected:
    157         int m_line;
    158     };
    159 
    160     class ExpressionNode : public Node {
    161     public:
    162         ExpressionNode(JSGlobalData* globalData, ResultType resultDesc = ResultType::unknownType()) JSC_FAST_CALL
    163             : Node(globalData)
    164             , m_resultDesc(resultDesc)
    165         {
     36    inline Node::Node(JSGlobalData* globalData)
     37        : ParserRefCounted(globalData)
     38        , m_line(globalData->lexer->lineNumber())
     39    {
     40    }
     41
     42
     43    inline ExpressionNode::ExpressionNode(JSGlobalData* globalData, ResultType resultType)
     44        : Node(globalData)
     45        , m_resultType(resultType)
     46    {
     47    }
     48
     49    inline StatementNode::StatementNode(JSGlobalData* globalData)
     50        : Node(globalData)
     51        , m_lastLine(-1)
     52    {
     53    }
     54
     55    inline NullNode::NullNode(JSGlobalData* globalData)
     56        : ExpressionNode(globalData, ResultType::nullType())
     57    {
     58    }
     59
     60    inline BooleanNode::BooleanNode(JSGlobalData* globalData, bool value)
     61        : ExpressionNode(globalData, ResultType::booleanType())
     62        , m_value(value)
     63    {
     64    }
     65
     66    inline NumberNode::NumberNode(JSGlobalData* globalData, double v)
     67        : ExpressionNode(globalData, ResultType::numberType())
     68        , m_double(v)
     69    {
     70    }
     71
     72    inline StringNode::StringNode(JSGlobalData* globalData, const Identifier& v)
     73        : ExpressionNode(globalData, ResultType::stringType())
     74        , m_value(v)
     75    {
     76    }
     77
     78    inline RegExpNode::RegExpNode(JSGlobalData* globalData, const UString& pattern, const UString& flags)
     79        : ExpressionNode(globalData)
     80        , m_pattern(pattern)
     81        , m_flags(flags)
     82    {
     83    }
     84
     85    inline ThisNode::ThisNode(JSGlobalData* globalData)
     86        : ExpressionNode(globalData)
     87    {
     88    }
     89
     90    inline ResolveNode::ResolveNode(JSGlobalData* globalData, const Identifier& ident, int startOffset)
     91        : ExpressionNode(globalData)
     92        , m_ident(ident)
     93        , m_startOffset(startOffset)
     94    {
     95    }
     96
     97    inline ElementNode::ElementNode(JSGlobalData* globalData, int elision, ExpressionNode* node)
     98        : ParserRefCounted(globalData)
     99        , m_elision(elision)
     100        , m_node(node)
     101    {
     102    }
     103
     104    inline ElementNode::ElementNode(JSGlobalData* globalData, ElementNode* l, int elision, ExpressionNode* node)
     105        : ParserRefCounted(globalData)
     106        , m_elision(elision)
     107        , m_node(node)
     108    {
     109        l->m_next = this;
     110    }
     111
     112    inline ArrayNode::ArrayNode(JSGlobalData* globalData, int elision)
     113        : ExpressionNode(globalData)
     114        , m_elision(elision)
     115        , m_optional(true)
     116    {
     117    }
     118
     119    inline ArrayNode::ArrayNode(JSGlobalData* globalData, ElementNode* element)
     120        : ExpressionNode(globalData)
     121        , m_element(element)
     122        , m_elision(0)
     123        , m_optional(false)
     124    {
     125    }
     126
     127    inline ArrayNode::ArrayNode(JSGlobalData* globalData, int elision, ElementNode* element)
     128        : ExpressionNode(globalData)
     129        , m_element(element)
     130        , m_elision(elision)
     131        , m_optional(true)
     132    {
     133    }
     134
     135    inline PropertyNode::PropertyNode(JSGlobalData* globalData, const Identifier& name, ExpressionNode* assign, Type type)
     136        : ParserRefCounted(globalData)
     137        , m_name(name)
     138        , m_assign(assign)
     139        , m_type(type)
     140    {
     141    }
     142
     143    inline PropertyListNode::PropertyListNode(JSGlobalData* globalData, PropertyNode* node)
     144        : Node(globalData)
     145        , m_node(node)
     146    {
     147    }
     148
     149    inline PropertyListNode::PropertyListNode(JSGlobalData* globalData, PropertyNode* node, PropertyListNode* list)
     150        : Node(globalData)
     151        , m_node(node)
     152    {
     153        list->m_next = this;
     154    }
     155
     156    inline ObjectLiteralNode::ObjectLiteralNode(JSGlobalData* globalData)
     157        : ExpressionNode(globalData)
     158    {
     159    }
     160
     161    inline ObjectLiteralNode::ObjectLiteralNode(JSGlobalData* globalData, PropertyListNode* list)
     162        : ExpressionNode(globalData)
     163        , m_list(list)
     164    {
     165    }
     166
     167    inline BracketAccessorNode::BracketAccessorNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments)
     168        : ExpressionNode(globalData)
     169        , m_base(base)
     170        , m_subscript(subscript)
     171        , m_subscriptHasAssignments(subscriptHasAssignments)
     172    {
     173    }
     174
     175    inline DotAccessorNode::DotAccessorNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident)
     176        : ExpressionNode(globalData)
     177        , m_base(base)
     178        , m_ident(ident)
     179    {
     180    }
     181
     182    inline ArgumentListNode::ArgumentListNode(JSGlobalData* globalData, ExpressionNode* expr)
     183        : Node(globalData)
     184        , m_expr(expr)
     185    {
     186    }
     187
     188    inline ArgumentListNode::ArgumentListNode(JSGlobalData* globalData, ArgumentListNode* listNode, ExpressionNode* expr)
     189        : Node(globalData)
     190        , m_expr(expr)
     191    {
     192        listNode->m_next = this;
     193    }
     194
     195    inline ArgumentsNode::ArgumentsNode(JSGlobalData* globalData)
     196        : ParserRefCounted(globalData)
     197    {
     198    }
     199
     200    inline ArgumentsNode::ArgumentsNode(JSGlobalData* globalData, ArgumentListNode* listNode)
     201        : ParserRefCounted(globalData)
     202        , m_listNode(listNode)
     203    {
     204    }
     205
     206    inline NewExprNode::NewExprNode(JSGlobalData* globalData, ExpressionNode* expr)
     207        : ExpressionNode(globalData)
     208        , m_expr(expr)
     209    {
     210    }
     211
     212    inline NewExprNode::NewExprNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args)
     213        : ExpressionNode(globalData)
     214        , m_expr(expr)
     215        , m_args(args)
     216    {
     217    }
     218
     219    inline EvalFunctionCallNode::EvalFunctionCallNode(JSGlobalData* globalData, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
     220        : ExpressionNode(globalData)
     221        , ThrowableExpressionData(divot, startOffset, endOffset)
     222        , m_args(args)
     223    {
     224    }
     225
     226    inline FunctionCallValueNode::FunctionCallValueNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
     227        : ExpressionNode(globalData)
     228        , ThrowableExpressionData(divot, startOffset, endOffset)
     229        , m_expr(expr)
     230        , m_args(args)
     231    {
     232    }
     233
     234    inline FunctionCallResolveNode::FunctionCallResolveNode(JSGlobalData* globalData, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
     235        : ExpressionNode(globalData)
     236        , ThrowableExpressionData(divot, startOffset, endOffset)
     237        , m_ident(ident)
     238        , m_args(args)
     239    {
     240    }
     241
     242    inline FunctionCallBracketNode::FunctionCallBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
     243        : ExpressionNode(globalData)
     244        , ThrowableSubExpressionData(divot, startOffset, endOffset)
     245        , m_base(base)
     246        , m_subscript(subscript)
     247        , m_args(args)
     248    {
     249    }
     250
     251    inline FunctionCallDotNode::FunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
     252        : ExpressionNode(globalData)
     253        , ThrowableSubExpressionData(divot, startOffset, endOffset)
     254        , m_base(base)
     255        , m_ident(ident)
     256        , m_args(args)
     257    {
     258    }
     259
     260    inline CallFunctionCallDotNode::CallFunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
     261        : FunctionCallDotNode(globalData, base, ident, args, divot, startOffset, endOffset)
     262    {
     263    }
     264
     265    inline ApplyFunctionCallDotNode::ApplyFunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset)
     266        : FunctionCallDotNode(globalData, base, ident, args, divot, startOffset, endOffset)
     267    {
     268    }
     269
     270    inline PrePostResolveNode::PrePostResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
     271        : ExpressionNode(globalData, ResultType::numberType()) // could be reusable for pre?
     272        , ThrowableExpressionData(divot, startOffset, endOffset)
     273        , m_ident(ident)
     274    {
     275    }
     276
     277    inline PostfixResolveNode::PostfixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     278        : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
     279        , m_operator(oper)
     280    {
     281    }
     282
     283    inline PostfixBracketNode::PostfixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     284        : ExpressionNode(globalData)
     285        , ThrowableSubExpressionData(divot, startOffset, endOffset)
     286        , m_base(base)
     287        , m_subscript(subscript)
     288        , m_operator(oper)
     289    {
     290    }
     291
     292    inline PostfixDotNode::PostfixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     293        : ExpressionNode(globalData)
     294        , ThrowableSubExpressionData(divot, startOffset, endOffset)
     295        , m_base(base)
     296        , m_ident(ident)
     297        , m_operator(oper)
     298    {
     299    }
     300
     301    inline PostfixErrorNode::PostfixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     302        : ExpressionNode(globalData)
     303        , ThrowableSubExpressionData(divot, startOffset, endOffset)
     304        , m_expr(expr)
     305        , m_operator(oper)
     306    {
     307    }
     308
     309    inline DeleteResolveNode::DeleteResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
     310        : ExpressionNode(globalData)
     311        , ThrowableExpressionData(divot, startOffset, endOffset)
     312        , m_ident(ident)
     313    {
     314    }
     315
     316    inline DeleteBracketNode::DeleteBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset)
     317        : ExpressionNode(globalData)
     318        , ThrowableExpressionData(divot, startOffset, endOffset)
     319        , m_base(base)
     320        , m_subscript(subscript)
     321    {
     322    }
     323
     324    inline DeleteDotNode::DeleteDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset)
     325        : ExpressionNode(globalData)
     326        , ThrowableExpressionData(divot, startOffset, endOffset)
     327        , m_base(base)
     328        , m_ident(ident)
     329    {
     330    }
     331
     332    inline DeleteValueNode::DeleteValueNode(JSGlobalData* globalData, ExpressionNode* expr)
     333        : ExpressionNode(globalData)
     334        , m_expr(expr)
     335    {
     336    }
     337
     338    inline VoidNode::VoidNode(JSGlobalData* globalData, ExpressionNode* expr)
     339        : ExpressionNode(globalData)
     340        , m_expr(expr)
     341    {
     342    }
     343
     344    inline TypeOfResolveNode::TypeOfResolveNode(JSGlobalData* globalData, const Identifier& ident)
     345        : ExpressionNode(globalData, ResultType::stringType())
     346        , m_ident(ident)
     347    {
     348    }
     349
     350    inline TypeOfValueNode::TypeOfValueNode(JSGlobalData* globalData, ExpressionNode* expr)
     351        : ExpressionNode(globalData, ResultType::stringType())
     352        , m_expr(expr)
     353    {
     354    }
     355
     356    inline PrefixResolveNode::PrefixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     357        : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
     358        , m_operator(oper)
     359    {
     360    }
     361
     362    inline PrefixBracketNode::PrefixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     363        : ExpressionNode(globalData)
     364        , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
     365        , m_base(base)
     366        , m_subscript(subscript)
     367        , m_operator(oper)
     368    {
     369    }
     370
     371    inline PrefixDotNode::PrefixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     372        : ExpressionNode(globalData)
     373        , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
     374        , m_base(base)
     375        , m_ident(ident)
     376        , m_operator(oper)
     377    {
     378    }
     379
     380    inline PrefixErrorNode::PrefixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset)
     381        : ExpressionNode(globalData)
     382        , ThrowableExpressionData(divot, startOffset, endOffset)
     383        , m_expr(expr)
     384        , m_operator(oper)
     385    {
     386    }
     387
     388    inline UnaryOpNode::UnaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr, OpcodeID opcodeID)
     389        : ExpressionNode(globalData, type)
     390        , m_expr(expr)
     391        , m_opcodeID(opcodeID)
     392    {
     393    }
     394
     395    inline UnaryPlusNode::UnaryPlusNode(JSGlobalData* globalData, ExpressionNode* expr)
     396        : UnaryOpNode(globalData, ResultType::numberType(), expr, op_to_jsnumber)
     397    {
     398    }
     399
     400    inline NegateNode::NegateNode(JSGlobalData* globalData, ExpressionNode* expr)
     401        : UnaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr, op_negate)
     402    {
     403    }
     404
     405    inline BitwiseNotNode::BitwiseNotNode(JSGlobalData* globalData, ExpressionNode* expr)
     406        : UnaryOpNode(globalData, ResultType::forBitOp(), expr, op_bitnot)
     407    {
     408    }
     409
     410    inline LogicalNotNode::LogicalNotNode(JSGlobalData* globalData, ExpressionNode* expr)
     411        : UnaryOpNode(globalData, ResultType::booleanType(), expr, op_not)
     412    {
     413    }
     414
     415    inline BinaryOpNode::BinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
     416        : ExpressionNode(globalData)
     417        , m_expr1(expr1)
     418        , m_expr2(expr2)
     419        , m_opcodeID(opcodeID)
     420        , m_rightHasAssignments(rightHasAssignments)
     421    {
     422    }
     423
     424    inline BinaryOpNode::BinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
     425        : ExpressionNode(globalData, type)
     426        , m_expr1(expr1)
     427        , m_expr2(expr2)
     428        , m_opcodeID(opcodeID)
     429        , m_rightHasAssignments(rightHasAssignments)
     430    {
     431    }
     432
     433    inline ReverseBinaryOpNode::ReverseBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
     434        : BinaryOpNode(globalData, expr1, expr2, opcodeID, rightHasAssignments)
     435    {
     436    }
     437
     438    inline ReverseBinaryOpNode::ReverseBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
     439        : BinaryOpNode(globalData, type, expr1, expr2, opcodeID, rightHasAssignments)
     440    {
     441    }
     442
     443    inline MultNode::MultNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     444        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_mul, rightHasAssignments)
     445    {
     446    }
     447
     448    inline DivNode::DivNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     449        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_div, rightHasAssignments)
     450    {
     451    }
     452
     453
     454    inline ModNode::ModNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     455        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_mod, rightHasAssignments)
     456    {
     457    }
     458
     459    inline AddNode::AddNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     460        : BinaryOpNode(globalData, ResultType::forAdd(expr1->resultDescriptor(), expr2->resultDescriptor()), expr1, expr2, op_add, rightHasAssignments)
     461    {
     462    }
     463
     464    inline SubNode::SubNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     465        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_sub, rightHasAssignments)
     466    {
     467    }
     468
     469    inline LeftShiftNode::LeftShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     470        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_lshift, rightHasAssignments)
     471    {
     472    }
     473
     474    inline RightShiftNode::RightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     475        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_rshift, rightHasAssignments)
     476    {
     477    }
     478
     479    inline UnsignedRightShiftNode::UnsignedRightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     480        : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, op_urshift, rightHasAssignments)
     481    {
     482    }
     483
     484    inline LessNode::LessNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     485        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_less, rightHasAssignments)
     486    {
     487    }
     488
     489    inline GreaterNode::GreaterNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     490        : ReverseBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_less, rightHasAssignments)
     491    {
     492    }
     493
     494    inline LessEqNode::LessEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     495        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_lesseq, rightHasAssignments)
     496    {
     497    }
     498
     499    inline GreaterEqNode::GreaterEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     500        : ReverseBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_lesseq, rightHasAssignments)
     501    {
     502    }
     503
     504    inline ThrowableBinaryOpNode::ThrowableBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
     505        : BinaryOpNode(globalData, type, expr1, expr2, opcodeID, rightHasAssignments)
     506    {
     507    }
     508
     509    inline ThrowableBinaryOpNode::ThrowableBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID opcodeID, bool rightHasAssignments)
     510        : BinaryOpNode(globalData, expr1, expr2, opcodeID, rightHasAssignments)
     511    {
     512    }
     513
     514    inline InstanceOfNode::InstanceOfNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     515        : ThrowableBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_instanceof, rightHasAssignments)
     516    {
     517    }
     518
     519    inline InNode::InNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     520        : ThrowableBinaryOpNode(globalData, expr1, expr2, op_in, rightHasAssignments)
     521    {
     522    }
     523
     524    inline EqualNode::EqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     525        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_eq, rightHasAssignments)
     526    {
     527    }
     528
     529    inline NotEqualNode::NotEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     530        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_neq, rightHasAssignments)
     531    {
     532    }
     533
     534    inline StrictEqualNode::StrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     535        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_stricteq, rightHasAssignments)
     536    {
     537    }
     538
     539    inline NotStrictEqualNode::NotStrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     540        : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, op_nstricteq, rightHasAssignments)
     541    {
     542    }
     543
     544    inline BitAndNode::BitAndNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     545        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_bitand, rightHasAssignments)
     546    {
     547    }
     548
     549    inline BitOrNode::BitOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     550        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_bitor, rightHasAssignments)
     551    {
     552    }
     553
     554    inline BitXOrNode::BitXOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     555        : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, op_bitxor, rightHasAssignments)
     556    {
     557    }
     558
     559    inline LogicalOpNode::LogicalOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator oper)
     560        : ExpressionNode(globalData, ResultType::booleanType())
     561        , m_expr1(expr1)
     562        , m_expr2(expr2)
     563        , m_operator(oper)
     564    {
     565    }
     566
     567    inline ConditionalNode::ConditionalNode(JSGlobalData* globalData, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2)
     568        : ExpressionNode(globalData)
     569        , m_logical(logical)
     570        , m_expr1(expr1)
     571        , m_expr2(expr2)
     572    {
     573    }
     574
     575    inline ReadModifyResolveNode::ReadModifyResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
     576        : ExpressionNode(globalData)
     577        , ThrowableExpressionData(divot, startOffset, endOffset)
     578        , m_ident(ident)
     579        , m_right(right)
     580        , m_operator(oper)
     581        , m_rightHasAssignments(rightHasAssignments)
     582    {
     583    }
     584
     585    inline AssignResolveNode::AssignResolveNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments)
     586        : ExpressionNode(globalData)
     587        , m_ident(ident)
     588        , m_right(right)
     589        , m_rightHasAssignments(rightHasAssignments)
     590    {
     591    }
     592
     593    inline ReadModifyBracketNode::ReadModifyBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
     594        : ExpressionNode(globalData)
     595        , ThrowableSubExpressionData(divot, startOffset, endOffset)
     596        , m_base(base)
     597        , m_subscript(subscript)
     598        , m_right(right)
     599        , m_operator(oper)
     600        , m_subscriptHasAssignments(subscriptHasAssignments)
     601        , m_rightHasAssignments(rightHasAssignments)
     602    {
     603    }
     604
     605    inline AssignBracketNode::AssignBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
     606        : ExpressionNode(globalData)
     607        , ThrowableExpressionData(divot, startOffset, endOffset)
     608        , m_base(base)
     609        , m_subscript(subscript)
     610        , m_right(right)
     611        , m_subscriptHasAssignments(subscriptHasAssignments)
     612        , m_rightHasAssignments(rightHasAssignments)
     613    {
     614    }
     615
     616    inline AssignDotNode::AssignDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
     617        : ExpressionNode(globalData)
     618        , ThrowableExpressionData(divot, startOffset, endOffset)
     619        , m_base(base)
     620        , m_ident(ident)
     621        , m_right(right)
     622        , m_rightHasAssignments(rightHasAssignments)
     623    {
     624    }
     625
     626    inline ReadModifyDotNode::ReadModifyDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset)
     627        : ExpressionNode(globalData)
     628        , ThrowableSubExpressionData(divot, startOffset, endOffset)
     629        , m_base(base)
     630        , m_ident(ident)
     631        , m_right(right)
     632        , m_operator(oper)
     633        , m_rightHasAssignments(rightHasAssignments)
     634    {
     635    }
     636
     637    inline AssignErrorNode::AssignErrorNode(JSGlobalData* globalData, ExpressionNode* left, Operator oper, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset)
     638        : ExpressionNode(globalData)
     639        , ThrowableExpressionData(divot, startOffset, endOffset)
     640        , m_left(left)
     641        , m_operator(oper)
     642        , m_right(right)
     643    {
     644    }
     645
     646    inline CommaNode::CommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2)
     647        : ExpressionNode(globalData)
     648        , m_expr1(expr1)
     649        , m_expr2(expr2)
     650    {
     651    }
     652
     653    inline VarDeclCommaNode::VarDeclCommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2)
     654        : CommaNode(globalData, expr1, expr2)
     655    {
     656    }
     657
     658    inline ConstStatementNode::ConstStatementNode(JSGlobalData* globalData, ConstDeclNode* next)
     659        : StatementNode(globalData)
     660        , m_next(next)
     661    {
     662    }
     663
     664    inline SourceElements::SourceElements(JSGlobalData* globalData)
     665        : ParserRefCounted(globalData)
     666    {
     667    }
     668
     669    inline EmptyStatementNode::EmptyStatementNode(JSGlobalData* globalData)
     670        : StatementNode(globalData)
     671    {
     672    }
     673
     674    inline DebuggerStatementNode::DebuggerStatementNode(JSGlobalData* globalData)
     675        : StatementNode(globalData)
     676    {
     677    }
     678   
     679    inline ExprStatementNode::ExprStatementNode(JSGlobalData* globalData, ExpressionNode* expr)
     680        : StatementNode(globalData)
     681        , m_expr(expr)
     682    {
     683    }
     684
     685    inline VarStatementNode::VarStatementNode(JSGlobalData* globalData, ExpressionNode* expr)
     686        : StatementNode(globalData)
     687        , m_expr(expr)
     688    {
     689    }
     690   
     691    inline IfNode::IfNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock)
     692        : StatementNode(globalData)
     693        , m_condition(condition)
     694        , m_ifBlock(ifBlock)
     695    {
     696    }
     697
     698    inline IfElseNode::IfElseNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock)
     699        : IfNode(globalData, condition, ifBlock)
     700        , m_elseBlock(elseBlock)
     701    {
     702    }
     703
     704    inline DoWhileNode::DoWhileNode(JSGlobalData* globalData, StatementNode* statement, ExpressionNode* expr)
     705        : StatementNode(globalData)
     706        , m_statement(statement)
     707        , m_expr(expr)
     708    {
     709    }
     710
     711    inline WhileNode::WhileNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement)
     712        : StatementNode(globalData)
     713        , m_expr(expr)
     714        , m_statement(statement)
     715    {
     716    }
     717
     718    inline ForNode::ForNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl)
     719        : StatementNode(globalData)
     720        , m_expr1(expr1)
     721        , m_expr2(expr2)
     722        , m_expr3(expr3)
     723        , m_statement(statement)
     724        , m_expr1WasVarDecl(expr1 && expr1WasVarDecl)
     725    {
     726        ASSERT(statement);
     727    }
     728
     729    inline ContinueNode::ContinueNode(JSGlobalData* globalData)
     730        : StatementNode(globalData)
     731    {
     732    }
     733
     734    inline ContinueNode::ContinueNode(JSGlobalData* globalData, const Identifier& ident)
     735        : StatementNode(globalData)
     736        , m_ident(ident)
     737    {
     738    }
     739   
     740    inline BreakNode::BreakNode(JSGlobalData* globalData)
     741        : StatementNode(globalData)
     742    {
     743    }
     744
     745    inline BreakNode::BreakNode(JSGlobalData* globalData, const Identifier& ident)
     746        : StatementNode(globalData)
     747        , m_ident(ident)
     748    {
     749    }
     750   
     751    inline ReturnNode::ReturnNode(JSGlobalData* globalData, ExpressionNode* value)
     752        : StatementNode(globalData)
     753        , m_value(value)
     754    {
     755    }
     756
     757    inline WithNode::WithNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement, uint32_t divot, uint32_t expressionLength)
     758        : StatementNode(globalData)
     759        , m_expr(expr)
     760        , m_statement(statement)
     761        , m_divot(divot)
     762        , m_expressionLength(expressionLength)
     763    {
     764    }
     765
     766    inline LabelNode::LabelNode(JSGlobalData* globalData, const Identifier& name, StatementNode* statement)
     767        : StatementNode(globalData)
     768        , m_name(name)
     769        , m_statement(statement)
     770    {
     771    }
     772
     773    inline ThrowNode::ThrowNode(JSGlobalData* globalData, ExpressionNode* expr)
     774        : StatementNode(globalData)
     775        , m_expr(expr)
     776    {
     777    }
     778
     779    inline TryNode::TryNode(JSGlobalData* globalData, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock)
     780        : StatementNode(globalData)
     781        , m_tryBlock(tryBlock)
     782        , m_exceptionIdent(exceptionIdent)
     783        , m_catchBlock(catchBlock)
     784        , m_finallyBlock(finallyBlock)
     785        , m_catchHasEval(catchHasEval)
     786    {
     787    }
     788
     789    inline ParameterNode::ParameterNode(JSGlobalData* globalData, const Identifier& ident)
     790        : ParserRefCounted(globalData)
     791        , m_ident(ident)
     792    {
     793    }
     794
     795    inline ParameterNode::ParameterNode(JSGlobalData* globalData, ParameterNode* l, const Identifier& ident)
     796        : ParserRefCounted(globalData)
     797        , m_ident(ident)
     798    {
     799        l->m_next = this;
     800    }
     801
     802       
     803    inline FuncExprNode::FuncExprNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
     804        : ExpressionNode(globalData)
     805        , m_ident(ident)
     806        , m_parameter(parameter)
     807        , m_body(body)
     808    {
     809        m_body->finishParsing(source, m_parameter.get());
     810    }
     811
     812    inline FuncDeclNode::FuncDeclNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter)
     813        : StatementNode(globalData)
     814        , m_ident(ident)
     815        , m_parameter(parameter)
     816        , m_body(body)
     817    {
     818        m_body->finishParsing(source, m_parameter.get());
     819    }
     820
     821    inline CaseClauseNode::CaseClauseNode(JSGlobalData* globalData, ExpressionNode* expr)
     822        : ParserRefCounted(globalData)
     823        , m_expr(expr)
     824    {
     825    }
     826
     827    inline CaseClauseNode::CaseClauseNode(JSGlobalData* globalData, ExpressionNode* expr, SourceElements* children)
     828        : ParserRefCounted(globalData)
     829        , m_expr(expr)
     830    {
     831        if (children)
     832            children->releaseContentsIntoVector(m_children);
     833    }
     834
     835    inline ClauseListNode::ClauseListNode(JSGlobalData* globalData, CaseClauseNode* clause)
     836        : ParserRefCounted(globalData)
     837        , m_clause(clause)
     838    {
     839    }
     840
     841    inline ClauseListNode::ClauseListNode(JSGlobalData* globalData, ClauseListNode* clauseList, CaseClauseNode* clause)
     842        : ParserRefCounted(globalData)
     843        , m_clause(clause)
     844    {
     845        clauseList->m_next = this;
     846    }
     847
     848    inline CaseBlockNode::CaseBlockNode(JSGlobalData* globalData, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2)
     849        : ParserRefCounted(globalData)
     850        , m_list1(list1)
     851        , m_defaultClause(defaultClause)
     852        , m_list2(list2)
     853    {
     854    }
     855
     856    inline SwitchNode::SwitchNode(JSGlobalData* globalData, ExpressionNode* expr, CaseBlockNode* block)
     857        : StatementNode(globalData)
     858        , m_expr(expr)
     859        , m_block(block)
     860    {
     861    }
     862
     863    inline ConstDeclNode::ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* init)
     864        : ExpressionNode(globalData)
     865        , m_ident(ident)
     866        , m_init(init)
     867    {
     868    }
     869
     870    inline BlockNode::BlockNode(JSGlobalData* globalData, SourceElements* children)
     871        : StatementNode(globalData)
     872    {
     873        if (children)
     874            children->releaseContentsIntoVector(m_children);
     875    }
     876
     877    inline ForInNode::ForInNode(JSGlobalData* globalData, ExpressionNode* l, ExpressionNode* expr, StatementNode* statement)
     878        : StatementNode(globalData)
     879        , m_init(0)
     880        , m_lexpr(l)
     881        , m_expr(expr)
     882        , m_statement(statement)
     883        , m_identIsVarDecl(false)
     884    {
     885    }
     886
     887    inline ForInNode::ForInNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in, ExpressionNode* expr, StatementNode* statement, int divot, int startOffset, int endOffset)
     888        : StatementNode(globalData)
     889        , m_ident(ident)
     890        , m_lexpr(new ResolveNode(globalData, ident, divot - startOffset))
     891        , m_expr(expr)
     892        , m_statement(statement)
     893        , m_identIsVarDecl(true)
     894    {
     895        if (in) {
     896            AssignResolveNode* node = new AssignResolveNode(globalData, ident, in, true);
     897            node->setExceptionSourceCode(divot, divot - startOffset, endOffset - divot);
     898            m_init = node;
    166899        }
    167 
    168         virtual bool isNumber() const JSC_FAST_CALL { return false; }
    169         virtual bool isString() const JSC_FAST_CALL { return false; }
    170         virtual bool isNull() const JSC_FAST_CALL { return false; }
    171         virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return false; }       
    172         virtual bool isLocation() const JSC_FAST_CALL { return false; }
    173         virtual bool isResolveNode() const JSC_FAST_CALL { return false; }
    174         virtual bool isBracketAccessorNode() const JSC_FAST_CALL { return false; }
    175         virtual bool isDotAccessorNode() const JSC_FAST_CALL { return false; }
    176         virtual bool isFuncExprNode() const JSC_FAST_CALL { return false; }
    177         virtual bool isSimpleArray() const JSC_FAST_CALL { return false; }
    178 
    179         virtual ExpressionNode* stripUnaryPlus() { return this; }
    180 
    181         ResultType resultDescriptor() const JSC_FAST_CALL { return m_resultDesc; }
    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_resultDesc;
    188     };
    189 
    190     class StatementNode : public Node {
    191     public:
    192         StatementNode(JSGlobalData*) JSC_FAST_CALL;
    193         void setLoc(int line0, int line1) JSC_FAST_CALL;
    194         int firstLine() const JSC_FAST_CALL { return lineNo(); }
    195         int lastLine() const JSC_FAST_CALL { return m_lastLine; }
    196 
    197         virtual bool isEmptyStatement() const JSC_FAST_CALL { return false; }
    198         virtual bool isReturnNode() const JSC_FAST_CALL { return false; }
    199         virtual bool isExprStatement() const JSC_FAST_CALL { return false; }
    200 
    201         virtual bool isBlock() const JSC_FAST_CALL { return false; }
    202 
    203     private:
    204         int m_lastLine;
    205     };
    206 
    207     class NullNode : public ExpressionNode {
    208     public:
    209         NullNode(JSGlobalData* globalData) JSC_FAST_CALL
    210             : ExpressionNode(globalData, ResultType::nullType())
    211         {
    212         }
    213 
    214         virtual bool isNull() const JSC_FAST_CALL { return true; }
    215 
    216         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    217     };
    218 
    219     class BooleanNode : public ExpressionNode {
    220     public:
    221         BooleanNode(JSGlobalData* globalData, bool value) JSC_FAST_CALL
    222             : ExpressionNode(globalData, ResultType::booleanType())
    223             , m_value(value)
    224         {
    225         }
    226 
    227         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    228 
    229         virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; }
    230 
    231     private:
    232         bool m_value;
    233     };
    234 
    235     class NumberNode : public ExpressionNode {
    236     public:
    237         NumberNode(JSGlobalData* globalData, double v) JSC_FAST_CALL
    238             : ExpressionNode(globalData, ResultType::numberType())
    239             , m_double(v)
    240         {
    241         }
    242 
    243         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    244 
    245         virtual bool isNumber() const JSC_FAST_CALL { return true; }
    246         virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; }
    247         double value() const JSC_FAST_CALL { return m_double; }
    248         void setValue(double d) JSC_FAST_CALL { m_double = d; }
    249 
    250     private:
    251         double m_double;
    252     };
    253 
    254     class StringNode : public ExpressionNode {
    255     public:
    256         StringNode(JSGlobalData* globalData, const Identifier& v) JSC_FAST_CALL
    257             : ExpressionNode(globalData, ResultType::stringType())
    258             , m_value(v)
    259         {
    260         }
    261 
    262         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    263        
    264         virtual bool isString() const JSC_FAST_CALL { return true; }
    265         const Identifier& value() { return m_value; }
    266         virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; }
    267 
    268     private:
    269         Identifier m_value;
    270     };
    271    
    272     class ThrowableExpressionData {
    273     public:
    274         ThrowableExpressionData()
    275             : m_divot(static_cast<uint32_t>(-1))
    276             , m_startOffset(static_cast<uint16_t>(-1))
    277             , m_endOffset(static_cast<uint16_t>(-1))
    278         {
    279         }
    280        
    281         ThrowableExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
    282             : m_divot(divot)
    283             , m_startOffset(startOffset)
    284             , m_endOffset(endOffset)
    285         {
    286         }
    287        
    288         void setExceptionSourceCode(unsigned divot, unsigned startOffset, unsigned endOffset)
    289         {
    290             m_divot = divot;
    291             m_startOffset = startOffset;
    292             m_endOffset = endOffset;
    293         }
    294 
    295         uint32_t divot() const { return m_divot; }
    296         uint16_t startOffset() const { return m_startOffset; }
    297         uint16_t endOffset() const { return m_endOffset; }
    298 
    299     protected:
    300         RegisterID* emitThrowError(BytecodeGenerator&, ErrorType, const char* msg);
    301         RegisterID* emitThrowError(BytecodeGenerator&, ErrorType, const char* msg, const Identifier&);
    302 
    303     private:
    304         uint32_t m_divot;
    305         uint16_t m_startOffset;
    306         uint16_t m_endOffset;
    307     };
    308 
    309     class ThrowableSubExpressionData : public ThrowableExpressionData {
    310     public:
    311         ThrowableSubExpressionData()
    312             : ThrowableExpressionData()
    313             , m_subexpressionDivotOffset(0)
    314             , m_subexpressionEndOffset(0)
    315         {
    316         }
    317 
    318         ThrowableSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
    319             : ThrowableExpressionData(divot, startOffset, endOffset)
    320             , m_subexpressionDivotOffset(0)
    321             , m_subexpressionEndOffset(0)
    322         {
    323         }
    324 
    325         void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)
    326         {
    327             ASSERT(subexpressionDivot <= divot());
    328             if ((divot() - subexpressionDivot) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot
    329                 return;
    330             m_subexpressionDivotOffset = divot() - subexpressionDivot;
    331             m_subexpressionEndOffset = subexpressionOffset;
    332         }
    333 
    334     protected:
    335         uint16_t m_subexpressionDivotOffset;
    336         uint16_t m_subexpressionEndOffset;
    337     };
    338    
    339     class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {
    340     public:
    341         ThrowablePrefixedSubExpressionData()
    342             : ThrowableExpressionData()
    343             , m_subexpressionDivotOffset(0)
    344             , m_subexpressionStartOffset(0)
    345         {
    346         }
    347 
    348         ThrowablePrefixedSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
    349             : ThrowableExpressionData(divot, startOffset, endOffset)
    350             , m_subexpressionDivotOffset(0)
    351             , m_subexpressionStartOffset(0)
    352         {
    353         }
    354 
    355         void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)
    356         {
    357             ASSERT(subexpressionDivot >= divot());
    358             if ((subexpressionDivot - divot()) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot
    359                 return;
    360             m_subexpressionDivotOffset = subexpressionDivot - divot();
    361             m_subexpressionStartOffset = subexpressionOffset;
    362         }
    363 
    364     protected:
    365         uint16_t m_subexpressionDivotOffset;
    366         uint16_t m_subexpressionStartOffset;
    367     };
    368 
    369     class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
    370     public:
    371         RegExpNode(JSGlobalData* globalData, const UString& pattern, const UString& flags) JSC_FAST_CALL
    372             : ExpressionNode(globalData)
    373             , m_pattern(pattern)
    374             , m_flags(flags)
    375         {
    376         }
    377 
    378         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    379 
    380     private:
    381         UString m_pattern;
    382         UString m_flags;
    383     };
    384 
    385     class ThisNode : public ExpressionNode {
    386     public:
    387         ThisNode(JSGlobalData* globalData) JSC_FAST_CALL
    388             : ExpressionNode(globalData)
    389         {
    390         }
    391 
    392         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    393     };
    394 
    395     class ResolveNode : public ExpressionNode {
    396     public:
    397         ResolveNode(JSGlobalData* globalData, const Identifier& ident, int startOffset) JSC_FAST_CALL
    398             : ExpressionNode(globalData)
    399             , m_ident(ident)
    400             , m_startOffset(startOffset)
    401         {
    402         }
    403 
    404         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    405 
    406         virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL;
    407         virtual bool isLocation() const JSC_FAST_CALL { return true; }
    408         virtual bool isResolveNode() const JSC_FAST_CALL { return true; }
    409         const Identifier& identifier() const JSC_FAST_CALL { return m_ident; }
    410 
    411     private:
    412         Identifier m_ident;
    413         int32_t m_startOffset;
    414     };
    415 
    416     class ElementNode : public ParserRefCounted {
    417     public:
    418         ElementNode(JSGlobalData* globalData, int elision, ExpressionNode* node) JSC_FAST_CALL
    419             : ParserRefCounted(globalData)
    420             , m_elision(elision)
    421             , m_node(node)
    422         {
    423         }
    424 
    425         ElementNode(JSGlobalData* globalData, ElementNode* l, int elision, ExpressionNode* node) JSC_FAST_CALL
    426             : ParserRefCounted(globalData)
    427             , m_elision(elision)
    428             , m_node(node)
    429         {
    430             l->m_next = this;
    431         }
    432 
    433         virtual ~ElementNode();
    434         virtual void releaseNodes(NodeReleaser&);
    435 
    436         int elision() const { return m_elision; }
    437         ExpressionNode* value() { return m_node.get(); }
    438 
    439         ElementNode* next() { return m_next.get(); }
    440 
    441     private:
    442         RefPtr<ElementNode> m_next;
    443         int m_elision;
    444         RefPtr<ExpressionNode> m_node;
    445     };
    446 
    447     class ArrayNode : public ExpressionNode {
    448     public:
    449         ArrayNode(JSGlobalData* globalData, int elision) JSC_FAST_CALL
    450             : ExpressionNode(globalData)
    451             , m_elision(elision)
    452             , m_optional(true)
    453         {
    454         }
    455 
    456         ArrayNode(JSGlobalData* globalData, ElementNode* element) JSC_FAST_CALL
    457             : ExpressionNode(globalData)
    458             , m_element(element)
    459             , m_elision(0)
    460             , m_optional(false)
    461         {
    462         }
    463 
    464         ArrayNode(JSGlobalData* globalData, int elision, ElementNode* element) JSC_FAST_CALL
    465             : ExpressionNode(globalData)
    466             , m_element(element)
    467             , m_elision(elision)
    468             , m_optional(true)
    469         {
    470         }
    471 
    472         virtual ~ArrayNode();
    473         virtual void releaseNodes(NodeReleaser&);
    474 
    475         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    476 
    477         virtual bool isSimpleArray() const JSC_FAST_CALL;
    478         PassRefPtr<ArgumentListNode> toArgumentList(JSGlobalData*) const;
    479     private:
    480         RefPtr<ElementNode> m_element;
    481         int m_elision;
    482         bool m_optional;
    483     };
    484 
    485     class PropertyNode : public ParserRefCounted {
    486     public:
    487         enum Type { Constant, Getter, Setter };
    488 
    489         PropertyNode(JSGlobalData* globalData, const Identifier& name, ExpressionNode* assign, Type type) JSC_FAST_CALL
    490             : ParserRefCounted(globalData)
    491             , m_name(name)
    492             , m_assign(assign)
    493             , m_type(type)
    494         {
    495         }
    496 
    497         virtual ~PropertyNode();
    498         virtual void releaseNodes(NodeReleaser&);
    499 
    500         const Identifier& name() const { return m_name; }
    501 
    502     private:
    503         friend class PropertyListNode;
    504         Identifier m_name;
    505         RefPtr<ExpressionNode> m_assign;
    506         Type m_type;
    507     };
    508 
    509     class PropertyListNode : public Node {
    510     public:
    511         PropertyListNode(JSGlobalData* globalData, PropertyNode* node) JSC_FAST_CALL
    512             : Node(globalData)
    513             , m_node(node)
    514         {
    515         }
    516 
    517         PropertyListNode(JSGlobalData* globalData, PropertyNode* node, PropertyListNode* list) JSC_FAST_CALL
    518             : Node(globalData)
    519             , m_node(node)
    520         {
    521             list->m_next = this;
    522         }
    523 
    524         virtual ~PropertyListNode();
    525         virtual void releaseNodes(NodeReleaser&);
    526 
    527         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    528 
    529     private:
    530         RefPtr<PropertyNode> m_node;
    531         RefPtr<PropertyListNode> m_next;
    532     };
    533 
    534     class ObjectLiteralNode : public ExpressionNode {
    535     public:
    536         ObjectLiteralNode(JSGlobalData* globalData) JSC_FAST_CALL
    537             : ExpressionNode(globalData)
    538         {
    539         }
    540 
    541         ObjectLiteralNode(JSGlobalData* globalData, PropertyListNode* list) JSC_FAST_CALL
    542             : ExpressionNode(globalData)
    543             , m_list(list)
    544         {
    545         }
    546 
    547         virtual ~ObjectLiteralNode();
    548         virtual void releaseNodes(NodeReleaser&);
    549 
    550         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    551 
    552     private:
    553         RefPtr<PropertyListNode> m_list;
    554     };
    555    
    556     class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
    557     public:
    558         BracketAccessorNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments) JSC_FAST_CALL
    559             : ExpressionNode(globalData)
    560             , m_base(base)
    561             , m_subscript(subscript)
    562             , m_subscriptHasAssignments(subscriptHasAssignments)
    563         {
    564         }
    565 
    566         virtual ~BracketAccessorNode();
    567         virtual void releaseNodes(NodeReleaser&);
    568 
    569         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    570 
    571         virtual bool isLocation() const JSC_FAST_CALL { return true; }
    572         virtual bool isBracketAccessorNode() const JSC_FAST_CALL { return true; }
    573         ExpressionNode* base() JSC_FAST_CALL { return m_base.get(); }
    574         ExpressionNode* subscript() JSC_FAST_CALL { return m_subscript.get(); }
    575 
    576     private:
    577         RefPtr<ExpressionNode> m_base;
    578         RefPtr<ExpressionNode> m_subscript;
    579         bool m_subscriptHasAssignments;
    580     };
    581 
    582     class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
    583     public:
    584         DotAccessorNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident) JSC_FAST_CALL
    585             : ExpressionNode(globalData)
    586             , m_base(base)
    587             , m_ident(ident)
    588         {
    589         }
    590 
    591         virtual ~DotAccessorNode();
    592         virtual void releaseNodes(NodeReleaser&);
    593 
    594         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    595 
    596         virtual bool isLocation() const JSC_FAST_CALL { return true; }
    597         virtual bool isDotAccessorNode() const JSC_FAST_CALL { return true; }
    598         ExpressionNode* base() const JSC_FAST_CALL { return m_base.get(); }
    599         const Identifier& identifier() const JSC_FAST_CALL { return m_ident; }
    600 
    601     private:
    602         RefPtr<ExpressionNode> m_base;
    603         Identifier m_ident;
    604     };
    605 
    606     class ArgumentListNode : public Node {
    607     public:
    608         ArgumentListNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    609             : Node(globalData)
    610             , m_expr(expr)
    611         {
    612         }
    613 
    614         ArgumentListNode(JSGlobalData* globalData, ArgumentListNode* listNode, ExpressionNode* expr) JSC_FAST_CALL
    615             : Node(globalData)
    616             , m_expr(expr)
    617         {
    618             listNode->m_next = this;
    619         }
    620 
    621         virtual ~ArgumentListNode();
    622         virtual void releaseNodes(NodeReleaser&);
    623 
    624         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    625 
    626         RefPtr<ArgumentListNode> m_next;
    627         RefPtr<ExpressionNode> m_expr;
    628     };
    629 
    630     class ArgumentsNode : public ParserRefCounted {
    631     public:
    632         ArgumentsNode(JSGlobalData* globalData) JSC_FAST_CALL
    633             : ParserRefCounted(globalData)
    634         {
    635         }
    636 
    637         ArgumentsNode(JSGlobalData* globalData, ArgumentListNode* listNode) JSC_FAST_CALL
    638             : ParserRefCounted(globalData)
    639             , m_listNode(listNode)
    640         {
    641         }
    642 
    643         virtual ~ArgumentsNode();
    644         virtual void releaseNodes(NodeReleaser&);
    645 
    646         RefPtr<ArgumentListNode> m_listNode;
    647     };
    648 
    649     class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
    650     public:
    651         NewExprNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    652             : ExpressionNode(globalData)
    653             , m_expr(expr)
    654         {
    655         }
    656 
    657         NewExprNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args) JSC_FAST_CALL
    658             : ExpressionNode(globalData)
    659             , m_expr(expr)
    660             , m_args(args)
    661         {
    662         }
    663 
    664         virtual ~NewExprNode();
    665         virtual void releaseNodes(NodeReleaser&);
    666 
    667         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    668 
    669     private:
    670         RefPtr<ExpressionNode> m_expr;
    671         RefPtr<ArgumentsNode> m_args;
    672     };
    673 
    674     class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
    675     public:
    676         EvalFunctionCallNode(JSGlobalData* globalData, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    677             : ExpressionNode(globalData)
    678             , ThrowableExpressionData(divot, startOffset, endOffset)
    679             , m_args(args)
    680         {
    681         }
    682 
    683         virtual ~EvalFunctionCallNode();
    684         virtual void releaseNodes(NodeReleaser&);
    685 
    686         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    687 
    688     private:
    689         RefPtr<ArgumentsNode> m_args;
    690     };
    691 
    692     class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
    693     public:
    694         FunctionCallValueNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    695             : ExpressionNode(globalData)
    696             , ThrowableExpressionData(divot, startOffset, endOffset)
    697             , m_expr(expr)
    698             , m_args(args)
    699         {
    700         }
    701 
    702         virtual ~FunctionCallValueNode();
    703         virtual void releaseNodes(NodeReleaser&);
    704 
    705         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    706 
    707     private:
    708         RefPtr<ExpressionNode> m_expr;
    709         RefPtr<ArgumentsNode> m_args;
    710     };
    711 
    712     class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
    713     public:
    714         FunctionCallResolveNode(JSGlobalData* globalData, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    715             : ExpressionNode(globalData)
    716             , ThrowableExpressionData(divot, startOffset, endOffset)
    717             , m_ident(ident)
    718             , m_args(args)
    719         {
    720         }
    721 
    722         virtual ~FunctionCallResolveNode();
    723         virtual void releaseNodes(NodeReleaser&);
    724 
    725         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    726 
    727     private:
    728         Identifier m_ident;
    729         RefPtr<ArgumentsNode> m_args;
    730         size_t m_index; // Used by LocalVarFunctionCallNode.
    731         size_t m_scopeDepth; // Used by ScopedVarFunctionCallNode and NonLocalVarFunctionCallNode
    732     };
    733    
    734     class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
    735     public:
    736         FunctionCallBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    737             : ExpressionNode(globalData)
    738             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    739             , m_base(base)
    740             , m_subscript(subscript)
    741             , m_args(args)
    742         {
    743         }
    744 
    745         virtual ~FunctionCallBracketNode();
    746         virtual void releaseNodes(NodeReleaser&);
    747 
    748         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    749 
    750     private:
    751         RefPtr<ExpressionNode> m_base;
    752         RefPtr<ExpressionNode> m_subscript;
    753         RefPtr<ArgumentsNode> m_args;
    754     };
    755 
    756     class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
    757     public:
    758         FunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    759             : ExpressionNode(globalData)
    760             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    761             , m_base(base)
    762             , m_ident(ident)
    763             , m_args(args)
    764         {
    765         }
    766 
    767         virtual ~FunctionCallDotNode();
    768         virtual void releaseNodes(NodeReleaser&);
    769 
    770         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    771 
    772     protected:
    773         RefPtr<ExpressionNode> m_base;
    774         Identifier m_ident;
    775         RefPtr<ArgumentsNode> m_args;
    776     };
    777 
    778     class CallFunctionCallDotNode : public FunctionCallDotNode {
    779     public:
    780         CallFunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    781             : FunctionCallDotNode(globalData, base, ident, args, divot, startOffset, endOffset)
    782         {
    783         }
    784         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    785     };
    786    
    787     class ApplyFunctionCallDotNode : public FunctionCallDotNode {
    788     public:
    789         ApplyFunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    790         : FunctionCallDotNode(globalData, base, ident, args, divot, startOffset, endOffset)
    791         {
    792         }
    793         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    794     };
    795 
    796     class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {
    797     public:
    798         PrePostResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    799             : ExpressionNode(globalData, ResultType::numberType()) // could be reusable for pre?
    800             , ThrowableExpressionData(divot, startOffset, endOffset)
    801             , m_ident(ident)
    802         {
    803         }
    804 
    805     protected:
    806         Identifier m_ident;
    807     };
    808 
    809     class PostfixResolveNode : public PrePostResolveNode {
    810     public:
    811         PostfixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    812             : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
    813             , m_operator(oper)
    814         {
    815         }
    816 
    817         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    818 
    819     private:
    820         Operator m_operator;
    821     };
    822 
    823     class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
    824     public:
    825         PostfixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    826             : ExpressionNode(globalData)
    827             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    828             , m_base(base)
    829             , m_subscript(subscript)
    830             , m_operator(oper)
    831         {
    832         }
    833 
    834         virtual ~PostfixBracketNode();
    835         virtual void releaseNodes(NodeReleaser&);
    836 
    837         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    838 
    839     private:
    840         RefPtr<ExpressionNode> m_base;
    841         RefPtr<ExpressionNode> m_subscript;
    842         Operator m_operator;
    843     };
    844 
    845     class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {
    846     public:
    847         PostfixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    848             : ExpressionNode(globalData)
    849             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    850             , m_base(base)
    851             , m_ident(ident)
    852             , m_operator(oper)
    853         {
    854         }
    855 
    856         virtual ~PostfixDotNode();
    857         virtual void releaseNodes(NodeReleaser&);
    858 
    859         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    860 
    861     private:
    862         RefPtr<ExpressionNode> m_base;
    863         Identifier m_ident;
    864         Operator m_operator;
    865     };
    866 
    867     class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {
    868     public:
    869         PostfixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    870             : ExpressionNode(globalData)
    871             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    872             , m_expr(expr)
    873             , m_operator(oper)
    874         {
    875         }
    876 
    877         virtual ~PostfixErrorNode();
    878         virtual void releaseNodes(NodeReleaser&);
    879 
    880         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    881 
    882     private:
    883         RefPtr<ExpressionNode> m_expr;
    884         Operator m_operator;
    885     };
    886 
    887     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
    888     public:
    889         DeleteResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    890             : ExpressionNode(globalData)
    891             , ThrowableExpressionData(divot, startOffset, endOffset)
    892             , m_ident(ident)
    893         {
    894         }
    895 
    896         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    897 
    898     private:
    899         Identifier m_ident;
    900     };
    901 
    902     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
    903     public:
    904         DeleteBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    905             : ExpressionNode(globalData)
    906             , ThrowableExpressionData(divot, startOffset, endOffset)
    907             , m_base(base)
    908             , m_subscript(subscript)
    909         {
    910         }
    911 
    912         virtual ~DeleteBracketNode();
    913         virtual void releaseNodes(NodeReleaser&);
    914 
    915         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    916 
    917     private:
    918         RefPtr<ExpressionNode> m_base;
    919         RefPtr<ExpressionNode> m_subscript;
    920     };
    921 
    922     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
    923     public:
    924         DeleteDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    925             : ExpressionNode(globalData)
    926             , ThrowableExpressionData(divot, startOffset, endOffset)
    927             , m_base(base)
    928             , m_ident(ident)
    929         {
    930         }
    931 
    932         virtual ~DeleteDotNode();
    933         virtual void releaseNodes(NodeReleaser&);
    934 
    935         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    936 
    937     private:
    938         RefPtr<ExpressionNode> m_base;
    939         Identifier m_ident;
    940     };
    941 
    942     class DeleteValueNode : public ExpressionNode {
    943     public:
    944         DeleteValueNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    945             : ExpressionNode(globalData)
    946             , m_expr(expr)
    947         {
    948         }
    949 
    950         virtual ~DeleteValueNode();
    951         virtual void releaseNodes(NodeReleaser&);
    952 
    953         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    954 
    955     private:
    956         RefPtr<ExpressionNode> m_expr;
    957     };
    958 
    959     class VoidNode : public ExpressionNode {
    960     public:
    961         VoidNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    962             : ExpressionNode(globalData)
    963             , m_expr(expr)
    964         {
    965         }
    966 
    967         virtual ~VoidNode();
    968         virtual void releaseNodes(NodeReleaser&);
    969 
    970         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    971 
    972     private:
    973         RefPtr<ExpressionNode> m_expr;
    974     };
    975 
    976     class TypeOfResolveNode : public ExpressionNode {
    977     public:
    978         TypeOfResolveNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL
    979             : ExpressionNode(globalData, ResultType::stringType())
    980             , m_ident(ident)
    981         {
    982         }
    983 
    984         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    985 
    986         const Identifier& identifier() const JSC_FAST_CALL { return m_ident; }
    987 
    988     private:
    989         Identifier m_ident;
    990     };
    991 
    992     class TypeOfValueNode : public ExpressionNode {
    993     public:
    994         TypeOfValueNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    995             : ExpressionNode(globalData, ResultType::stringType())
    996             , m_expr(expr)
    997         {
    998         }
    999 
    1000         virtual ~TypeOfValueNode();
    1001         virtual void releaseNodes(NodeReleaser&);
    1002 
    1003         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1004 
    1005     private:
    1006         RefPtr<ExpressionNode> m_expr;
    1007     };
    1008 
    1009     class PrefixResolveNode : public PrePostResolveNode {
    1010     public:
    1011         PrefixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1012             : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
    1013             , m_operator(oper)
    1014         {
    1015         }
    1016 
    1017         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1018 
    1019     private:
    1020         Operator m_operator;
    1021     };
    1022 
    1023     class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
    1024     public:
    1025         PrefixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1026             : ExpressionNode(globalData)
    1027             , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
    1028             , m_base(base)
    1029             , m_subscript(subscript)
    1030             , m_operator(oper)
    1031         {
    1032         }
    1033 
    1034         virtual ~PrefixBracketNode();
    1035         virtual void releaseNodes(NodeReleaser&);
    1036 
    1037         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1038 
    1039     private:
    1040         RefPtr<ExpressionNode> m_base;
    1041         RefPtr<ExpressionNode> m_subscript;
    1042         Operator m_operator;
    1043     };
    1044 
    1045     class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
    1046     public:
    1047         PrefixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1048             : ExpressionNode(globalData)
    1049             , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
    1050             , m_base(base)
    1051             , m_ident(ident)
    1052             , m_operator(oper)
    1053         {
    1054         }
    1055 
    1056         virtual ~PrefixDotNode();
    1057         virtual void releaseNodes(NodeReleaser&);
    1058 
    1059         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1060 
    1061     private:
    1062         RefPtr<ExpressionNode> m_base;
    1063         Identifier m_ident;
    1064         Operator m_operator;
    1065     };
    1066 
    1067     class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {
    1068     public:
    1069         PrefixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1070             : ExpressionNode(globalData)
    1071             , ThrowableExpressionData(divot, startOffset, endOffset)
    1072             , m_expr(expr)
    1073             , m_operator(oper)
    1074         {
    1075         }
    1076 
    1077         virtual ~PrefixErrorNode();
    1078         virtual void releaseNodes(NodeReleaser&);
    1079 
    1080         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1081 
    1082     private:
    1083         RefPtr<ExpressionNode> m_expr;
    1084         Operator m_operator;
    1085     };
    1086 
    1087     class UnaryOpNode : public ExpressionNode {
    1088     public:
    1089         UnaryOpNode(JSGlobalData* globalData, ExpressionNode* expr)
    1090             : ExpressionNode(globalData)
    1091             , m_expr(expr)
    1092         {
    1093         }
    1094 
    1095         UnaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr)
    1096             : ExpressionNode(globalData, type)
    1097             , m_expr(expr)
    1098         {
    1099         }
    1100 
    1101         virtual ~UnaryOpNode();
    1102         virtual void releaseNodes(NodeReleaser&);
    1103 
    1104         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1105         virtual OpcodeID opcodeID() const JSC_FAST_CALL = 0;
    1106 
    1107     protected:
    1108         RefPtr<ExpressionNode> m_expr;
    1109     };
    1110 
    1111     class UnaryPlusNode : public UnaryOpNode {
    1112     public:
    1113         UnaryPlusNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1114             : UnaryOpNode(globalData, ResultType::numberType(), expr)
    1115         {
    1116         }
    1117 
    1118         virtual ExpressionNode* stripUnaryPlus() { return m_expr.get(); }
    1119 
    1120         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_to_jsnumber; }
    1121     };
    1122 
    1123     class NegateNode : public UnaryOpNode {
    1124     public:
    1125         NegateNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1126             : UnaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr)
    1127         {
    1128         }
    1129 
    1130         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_negate; }
    1131     };
    1132 
    1133     class BitwiseNotNode : public UnaryOpNode {
    1134     public:
    1135         BitwiseNotNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1136             : UnaryOpNode(globalData, ResultType::forBitOp(), expr)
    1137         {
    1138         }
    1139 
    1140         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitnot; }
    1141     };
    1142 
    1143     class LogicalNotNode : public UnaryOpNode {
    1144     public:
    1145         LogicalNotNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1146             : UnaryOpNode(globalData, ResultType::booleanType(), expr)
    1147         {
    1148         }
    1149 
    1150         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_not; }
    1151     };
    1152 
    1153     class BinaryOpNode : public ExpressionNode {
    1154     public:
    1155         BinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1156             : ExpressionNode(globalData)
    1157             , m_expr1(expr1)
    1158             , m_expr2(expr2)
    1159             , m_rightHasAssignments(rightHasAssignments)
    1160         {
    1161         }
    1162 
    1163         BinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1164             : ExpressionNode(globalData, type)
    1165             , m_expr1(expr1)
    1166             , m_expr2(expr2)
    1167             , m_rightHasAssignments(rightHasAssignments)
    1168         {
    1169         }
    1170 
    1171         virtual ~BinaryOpNode();
    1172         virtual void releaseNodes(NodeReleaser&);
    1173 
    1174         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1175         virtual OpcodeID opcodeID() const JSC_FAST_CALL = 0;
    1176 
    1177     protected:
    1178         RefPtr<ExpressionNode> m_expr1;
    1179         RefPtr<ExpressionNode> m_expr2;
    1180         bool m_rightHasAssignments;
    1181     };
    1182 
    1183     class ReverseBinaryOpNode : public BinaryOpNode {
    1184     public:
    1185         ReverseBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1186             : BinaryOpNode(globalData, expr1, expr2, rightHasAssignments)
    1187         {
    1188         }
    1189 
    1190         ReverseBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1191             : BinaryOpNode(globalData, type, expr1, expr2, rightHasAssignments)
    1192         {
    1193         }
    1194 
    1195         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1196     };
    1197 
    1198     class MultNode : public BinaryOpNode {
    1199     public:
    1200         MultNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1201             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1202         {
    1203         }
    1204 
    1205         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_mul; }
    1206     };
    1207 
    1208     class DivNode : public BinaryOpNode {
    1209     public:
    1210         DivNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1211             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1212         {
    1213         }
    1214 
    1215         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_div; }
    1216     };
    1217 
    1218     class ModNode : public BinaryOpNode {
    1219     public:
    1220         ModNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1221             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1222         {
    1223         }
    1224 
    1225         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_mod; }
    1226     };
    1227 
    1228     class AddNode : public BinaryOpNode {
    1229     public:
    1230         AddNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1231             : BinaryOpNode(globalData, ResultType::forAdd(expr1->resultDescriptor(), expr2->resultDescriptor()), expr1, expr2, rightHasAssignments)
    1232         {
    1233         }
    1234 
    1235         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_add; }
    1236     };
    1237 
    1238     class SubNode : public BinaryOpNode {
    1239     public:
    1240         SubNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1241             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1242         {
    1243         }
    1244 
    1245         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_sub; }
    1246     };
    1247 
    1248     class LeftShiftNode : public BinaryOpNode {
    1249     public:
    1250         LeftShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1251             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1252         {
    1253         }
    1254 
    1255         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lshift; }
    1256     };
    1257 
    1258     class RightShiftNode : public BinaryOpNode {
    1259     public:
    1260         RightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1261             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1262         {
    1263         }
    1264 
    1265         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_rshift; }
    1266     };
    1267 
    1268     class UnsignedRightShiftNode : public BinaryOpNode {
    1269     public:
    1270         UnsignedRightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1271             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1272         {
    1273         }
    1274 
    1275         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_urshift; }
    1276     };
    1277 
    1278     class LessNode : public BinaryOpNode {
    1279     public:
    1280         LessNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1281             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1282         {
    1283         }
    1284 
    1285         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_less; }
    1286     };
    1287 
    1288     class GreaterNode : public ReverseBinaryOpNode {
    1289     public:
    1290         GreaterNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1291             : ReverseBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1292         {
    1293         }
    1294 
    1295         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_less; }
    1296     };
    1297 
    1298     class LessEqNode : public BinaryOpNode {
    1299     public:
    1300         LessEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1301             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1302         {
    1303         }
    1304 
    1305         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lesseq; }
    1306     };
    1307 
    1308     class GreaterEqNode : public ReverseBinaryOpNode {
    1309     public:
    1310         GreaterEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1311             : ReverseBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1312         {
    1313         }
    1314 
    1315         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lesseq; }
    1316     };
    1317 
    1318     class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
    1319     public:
    1320         ThrowableBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1321             : BinaryOpNode(globalData, type, expr1, expr2, rightHasAssignments)
    1322         {
    1323         }
    1324         ThrowableBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1325             : BinaryOpNode(globalData, expr1, expr2, rightHasAssignments)
    1326         {
    1327         }
    1328         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1329     };
    1330    
    1331     class InstanceOfNode : public ThrowableBinaryOpNode {
    1332     public:
    1333         InstanceOfNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1334             : ThrowableBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1335         {
    1336         }
    1337 
    1338         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_instanceof; }
    1339 
    1340         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1341     };
    1342 
    1343     class InNode : public ThrowableBinaryOpNode {
    1344     public:
    1345         InNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1346             : ThrowableBinaryOpNode(globalData, expr1, expr2, rightHasAssignments)
    1347         {
    1348         }
    1349 
    1350         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_in; }
    1351     };
    1352 
    1353     class EqualNode : public BinaryOpNode {
    1354     public:
    1355         EqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1356             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1357         {
    1358         }
    1359 
    1360         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1361         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_eq; }
    1362     };
    1363 
    1364     class NotEqualNode : public BinaryOpNode {
    1365     public:
    1366         NotEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1367             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1368         {
    1369         }
    1370 
    1371         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_neq; }
    1372     };
    1373 
    1374     class StrictEqualNode : public BinaryOpNode {
    1375     public:
    1376         StrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1377             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1378         {
    1379         }
    1380 
    1381         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1382         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_stricteq; }
    1383     };
    1384 
    1385     class NotStrictEqualNode : public BinaryOpNode {
    1386     public:
    1387         NotStrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1388             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1389         {
    1390         }
    1391 
    1392         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_nstricteq; }
    1393     };
    1394 
    1395     class BitAndNode : public BinaryOpNode {
    1396     public:
    1397         BitAndNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1398             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1399         {
    1400         }
    1401 
    1402         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitand; }
    1403     };
    1404 
    1405     class BitOrNode : public BinaryOpNode {
    1406     public:
    1407         BitOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1408             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1409         {
    1410         }
    1411 
    1412         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitor; }
    1413     };
    1414 
    1415     class BitXOrNode : public BinaryOpNode {
    1416     public:
    1417         BitXOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1418             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1419         {
    1420         }
    1421 
    1422         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitxor; }
    1423     };
    1424 
    1425     /**
    1426      * m_expr1 && m_expr2, m_expr1 || m_expr2
    1427      */
    1428     class LogicalOpNode : public ExpressionNode {
    1429     public:
    1430         LogicalOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator oper) JSC_FAST_CALL
    1431             : ExpressionNode(globalData, ResultType::booleanType())
    1432             , m_expr1(expr1)
    1433             , m_expr2(expr2)
    1434             , m_operator(oper)
    1435         {
    1436         }
    1437 
    1438         virtual ~LogicalOpNode();
    1439         virtual void releaseNodes(NodeReleaser&);
    1440 
    1441         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1442 
    1443     private:
    1444         RefPtr<ExpressionNode> m_expr1;
    1445         RefPtr<ExpressionNode> m_expr2;
    1446         LogicalOperator m_operator;
    1447     };
    1448 
    1449     /**
    1450      * The ternary operator, "m_logical ? m_expr1 : m_expr2"
    1451      */
    1452     class ConditionalNode : public ExpressionNode {
    1453     public:
    1454         ConditionalNode(JSGlobalData* globalData, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL
    1455             : ExpressionNode(globalData)
    1456             , m_logical(logical)
    1457             , m_expr1(expr1)
    1458             , m_expr2(expr2)
    1459         {
    1460         }
    1461 
    1462         virtual ~ConditionalNode();
    1463         virtual void releaseNodes(NodeReleaser&);
    1464 
    1465         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1466 
    1467     private:
    1468         RefPtr<ExpressionNode> m_logical;
    1469         RefPtr<ExpressionNode> m_expr1;
    1470         RefPtr<ExpressionNode> m_expr2;
    1471     };
    1472 
    1473     class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
    1474     public:
    1475         ReadModifyResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1476             : ExpressionNode(globalData)
    1477             , ThrowableExpressionData(divot, startOffset, endOffset)
    1478             , m_ident(ident)
    1479             , m_right(right)
    1480             , m_operator(oper)
    1481             , m_rightHasAssignments(rightHasAssignments)
    1482         {
    1483         }
    1484 
    1485         virtual ~ReadModifyResolveNode();
    1486         virtual void releaseNodes(NodeReleaser&);
    1487 
    1488         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1489 
    1490     private:
    1491         Identifier m_ident;
    1492         RefPtr<ExpressionNode> m_right;
    1493         size_t m_index; // Used by ReadModifyLocalVarNode.
    1494         Operator m_operator : 31;
    1495         bool m_rightHasAssignments : 1;
    1496     };
    1497 
    1498     class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
    1499     public:
    1500         AssignResolveNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) JSC_FAST_CALL
    1501             : ExpressionNode(globalData)
    1502             , m_ident(ident)
    1503             , m_right(right)
    1504             , m_rightHasAssignments(rightHasAssignments)
    1505         {
    1506         }
    1507 
    1508         virtual ~AssignResolveNode();
    1509         virtual void releaseNodes(NodeReleaser&);
    1510 
    1511         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1512 
    1513     private:
    1514         Identifier m_ident;
    1515         RefPtr<ExpressionNode> m_right;
    1516         size_t m_index; // Used by ReadModifyLocalVarNode.
    1517         bool m_rightHasAssignments;
    1518     };
    1519 
    1520     class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
    1521     public:
    1522         ReadModifyBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1523             : ExpressionNode(globalData)
    1524             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    1525             , m_base(base)
    1526             , m_subscript(subscript)
    1527             , m_right(right)
    1528             , m_operator(oper)
    1529             , m_subscriptHasAssignments(subscriptHasAssignments)
    1530             , m_rightHasAssignments(rightHasAssignments)
    1531         {
    1532         }
    1533 
    1534         virtual ~ReadModifyBracketNode();
    1535         virtual void releaseNodes(NodeReleaser&);
    1536 
    1537         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1538 
    1539     private:
    1540         RefPtr<ExpressionNode> m_base;
    1541         RefPtr<ExpressionNode> m_subscript;
    1542         RefPtr<ExpressionNode> m_right;
    1543         Operator m_operator : 30;
    1544         bool m_subscriptHasAssignments : 1;
    1545         bool m_rightHasAssignments : 1;
    1546     };
    1547 
    1548     class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
    1549     public:
    1550         AssignBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1551             : ExpressionNode(globalData)
    1552             , ThrowableExpressionData(divot, startOffset, endOffset)
    1553             , m_base(base)
    1554             , m_subscript(subscript)
    1555             , m_right(right)
    1556             , m_subscriptHasAssignments(subscriptHasAssignments)
    1557             , m_rightHasAssignments(rightHasAssignments)
    1558         {
    1559         }
    1560 
    1561         virtual ~AssignBracketNode();
    1562         virtual void releaseNodes(NodeReleaser&);
    1563 
    1564         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1565 
    1566     private:
    1567         RefPtr<ExpressionNode> m_base;
    1568         RefPtr<ExpressionNode> m_subscript;
    1569         RefPtr<ExpressionNode> m_right;
    1570         bool m_subscriptHasAssignments : 1;
    1571         bool m_rightHasAssignments : 1;
    1572     };
    1573 
    1574     class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
    1575     public:
    1576         AssignDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1577             : ExpressionNode(globalData)
    1578             , ThrowableExpressionData(divot, startOffset, endOffset)
    1579             , m_base(base)
    1580             , m_ident(ident)
    1581             , m_right(right)
    1582             , m_rightHasAssignments(rightHasAssignments)
    1583         {
    1584         }
    1585 
    1586         virtual ~AssignDotNode();
    1587         virtual void releaseNodes(NodeReleaser&);
    1588 
    1589         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1590 
    1591     private:
    1592         RefPtr<ExpressionNode> m_base;
    1593         Identifier m_ident;
    1594         RefPtr<ExpressionNode> m_right;
    1595         bool m_rightHasAssignments;
    1596     };
    1597 
    1598     class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
    1599     public:
    1600         ReadModifyDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1601             : ExpressionNode(globalData)
    1602             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    1603             , m_base(base)
    1604             , m_ident(ident)
    1605             , m_right(right)
    1606             , m_operator(oper)
    1607             , m_rightHasAssignments(rightHasAssignments)
    1608         {
    1609         }
    1610 
    1611         virtual ~ReadModifyDotNode();
    1612         virtual void releaseNodes(NodeReleaser&);
    1613 
    1614         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1615 
    1616     private:
    1617         RefPtr<ExpressionNode> m_base;
    1618         Identifier m_ident;
    1619         RefPtr<ExpressionNode> m_right;
    1620         Operator m_operator : 31;
    1621         bool m_rightHasAssignments : 1;
    1622     };
    1623 
    1624     class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
    1625     public:
    1626         AssignErrorNode(JSGlobalData* globalData, ExpressionNode* left, Operator oper, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1627             : ExpressionNode(globalData)
    1628             , ThrowableExpressionData(divot, startOffset, endOffset)
    1629             , m_left(left)
    1630             , m_operator(oper)
    1631             , m_right(right)
    1632         {
    1633         }
    1634 
    1635         virtual ~AssignErrorNode();
    1636         virtual void releaseNodes(NodeReleaser&);
    1637 
    1638         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1639 
    1640     private:
    1641         RefPtr<ExpressionNode> m_left;
    1642         Operator m_operator;
    1643         RefPtr<ExpressionNode> m_right;
    1644     };
    1645 
    1646     class CommaNode : public ExpressionNode {
    1647     public:
    1648         CommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL
    1649             : ExpressionNode(globalData)
    1650             , m_expr1(expr1)
    1651             , m_expr2(expr2)
    1652         {
    1653         }
    1654 
    1655         virtual ~CommaNode();
    1656         virtual void releaseNodes(NodeReleaser&);
    1657 
    1658         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1659 
    1660     private:
    1661         RefPtr<ExpressionNode> m_expr1;
    1662         RefPtr<ExpressionNode> m_expr2;
    1663     };
    1664    
    1665     class VarDeclCommaNode : public CommaNode {
    1666     public:
    1667         VarDeclCommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL
    1668             : CommaNode(globalData, expr1, expr2)
    1669         {
    1670         }
    1671     };
    1672 
    1673     class ConstDeclNode : public ExpressionNode {
    1674     public:
    1675         ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in) JSC_FAST_CALL;
    1676 
    1677         virtual ~ConstDeclNode();
    1678         virtual void releaseNodes(NodeReleaser&);
    1679 
    1680         Identifier m_ident;
    1681         RefPtr<ConstDeclNode> m_next;
    1682         RefPtr<ExpressionNode> m_init;
    1683        
    1684         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1685         virtual RegisterID* emitCodeSingle(BytecodeGenerator&) JSC_FAST_CALL;
    1686     };
    1687 
    1688     class ConstStatementNode : public StatementNode {
    1689     public:
    1690         ConstStatementNode(JSGlobalData* globalData, ConstDeclNode* next) JSC_FAST_CALL
    1691             : StatementNode(globalData)
    1692             , m_next(next)
    1693         {
    1694         }
    1695 
    1696         virtual ~ConstStatementNode();
    1697         virtual void releaseNodes(NodeReleaser&);
    1698 
    1699         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1700 
    1701     private:
    1702         RefPtr<ConstDeclNode> m_next;
    1703     };
    1704 
    1705     typedef Vector<RefPtr<StatementNode> > StatementVector;
    1706 
    1707     class SourceElements : public ParserRefCounted {
    1708     public:
    1709         SourceElements(JSGlobalData* globalData) : ParserRefCounted(globalData) {}
    1710 
    1711         void append(PassRefPtr<StatementNode>);
    1712         void releaseContentsIntoVector(StatementVector& destination)
    1713         {
    1714             ASSERT(destination.isEmpty());
    1715             m_statements.swap(destination);
    1716             destination.shrinkToFit();
    1717         }
    1718 
    1719     private:
    1720         StatementVector m_statements;
    1721     };
    1722 
    1723     class BlockNode : public StatementNode {
    1724     public:
    1725         BlockNode(JSGlobalData*, SourceElements* children) JSC_FAST_CALL;
    1726 
    1727         virtual ~BlockNode();
    1728         virtual void releaseNodes(NodeReleaser&);
    1729 
    1730         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1731 
    1732         StatementVector& children() { return m_children; }
    1733 
    1734         virtual bool isBlock() const JSC_FAST_CALL { return true; }
    1735 
    1736     private:
    1737         StatementVector m_children;
    1738     };
    1739 
    1740     class EmptyStatementNode : public StatementNode {
    1741     public:
    1742         EmptyStatementNode(JSGlobalData* globalData) JSC_FAST_CALL // debug
    1743             : StatementNode(globalData)
    1744         {
    1745         }
    1746 
    1747         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1748 
    1749         virtual bool isEmptyStatement() const JSC_FAST_CALL { return true; }
    1750     };
    1751    
    1752     class DebuggerStatementNode : public StatementNode {
    1753     public:
    1754         DebuggerStatementNode(JSGlobalData* globalData) JSC_FAST_CALL
    1755             : StatementNode(globalData)
    1756         {
    1757         }
    1758        
    1759         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1760     };
    1761 
    1762     class ExprStatementNode : public StatementNode {
    1763     public:
    1764         ExprStatementNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1765             : StatementNode(globalData)
    1766             , m_expr(expr)
    1767         {
    1768         }
    1769 
    1770         virtual bool isExprStatement() const JSC_FAST_CALL { return true; }
    1771 
    1772         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1773 
    1774         ExpressionNode* expr() const { return m_expr.get(); }
    1775 
    1776     private:
    1777         RefPtr<ExpressionNode> m_expr;
    1778     };
    1779 
    1780     class VarStatementNode : public StatementNode {
    1781     public:
    1782         VarStatementNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1783             : StatementNode(globalData)
    1784             , m_expr(expr)
    1785         {
    1786         }
    1787        
    1788         virtual ~VarStatementNode();
    1789         virtual void releaseNodes(NodeReleaser&);
    1790 
    1791         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1792 
    1793     private:
    1794         RefPtr<ExpressionNode> m_expr;
    1795     };
    1796 
    1797     class IfNode : public StatementNode {
    1798     public:
    1799         IfNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock) JSC_FAST_CALL
    1800             : StatementNode(globalData)
    1801             , m_condition(condition)
    1802             , m_ifBlock(ifBlock)
    1803         {
    1804         }
    1805 
    1806         virtual ~IfNode();
    1807         virtual void releaseNodes(NodeReleaser&);
    1808 
    1809         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1810 
    1811     protected:
    1812         RefPtr<ExpressionNode> m_condition;
    1813         RefPtr<StatementNode> m_ifBlock;
    1814     };
    1815 
    1816     class IfElseNode : public IfNode {
    1817     public:
    1818         IfElseNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock) JSC_FAST_CALL
    1819             : IfNode(globalData, condition, ifBlock)
    1820             , m_elseBlock(elseBlock)
    1821         {
    1822         }
    1823 
    1824         virtual ~IfElseNode();
    1825         virtual void releaseNodes(NodeReleaser&);
    1826 
    1827         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1828 
    1829     private:
    1830         RefPtr<StatementNode> m_elseBlock;
    1831     };
    1832 
    1833     class DoWhileNode : public StatementNode {
    1834     public:
    1835         DoWhileNode(JSGlobalData* globalData, StatementNode* statement, ExpressionNode* expr) JSC_FAST_CALL
    1836             : StatementNode(globalData)
    1837             , m_statement(statement)
    1838             , m_expr(expr)
    1839         {
    1840         }
    1841 
    1842         virtual ~DoWhileNode();
    1843         virtual void releaseNodes(NodeReleaser&);
    1844 
    1845         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1846 
    1847     private:
    1848         RefPtr<StatementNode> m_statement;
    1849         RefPtr<ExpressionNode> m_expr;
    1850     };
    1851 
    1852     class WhileNode : public StatementNode {
    1853     public:
    1854         WhileNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement) JSC_FAST_CALL
    1855             : StatementNode(globalData)
    1856             , m_expr(expr)
    1857             , m_statement(statement)
    1858         {
    1859         }
    1860 
    1861         virtual ~WhileNode();
    1862         virtual void releaseNodes(NodeReleaser&);
    1863 
    1864         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1865 
    1866     private:
    1867         RefPtr<ExpressionNode> m_expr;
    1868         RefPtr<StatementNode> m_statement;
    1869     };
    1870 
    1871     class ForNode : public StatementNode {
    1872     public:
    1873         ForNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) JSC_FAST_CALL
    1874             : StatementNode(globalData)
    1875             , m_expr1(expr1)
    1876             , m_expr2(expr2)
    1877             , m_expr3(expr3)
    1878             , m_statement(statement)
    1879             , m_expr1WasVarDecl(expr1 && expr1WasVarDecl)
    1880         {
    1881             ASSERT(statement);
    1882         }
    1883 
    1884         virtual ~ForNode();
    1885         virtual void releaseNodes(NodeReleaser&);
    1886 
    1887         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1888 
    1889     private:
    1890         RefPtr<ExpressionNode> m_expr1;
    1891         RefPtr<ExpressionNode> m_expr2;
    1892         RefPtr<ExpressionNode> m_expr3;
    1893         RefPtr<StatementNode> m_statement;
    1894         bool m_expr1WasVarDecl;
    1895     };
    1896 
    1897     class ForInNode : public StatementNode, public ThrowableExpressionData {
    1898     public:
    1899         ForInNode(JSGlobalData*, ExpressionNode*, ExpressionNode*, StatementNode*) JSC_FAST_CALL;
    1900         ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset) JSC_FAST_CALL;
    1901        
    1902         virtual ~ForInNode();
    1903         virtual void releaseNodes(NodeReleaser&);
    1904 
    1905         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1906 
    1907     private:
    1908         Identifier m_ident;
    1909         RefPtr<ExpressionNode> m_init;
    1910         RefPtr<ExpressionNode> m_lexpr;
    1911         RefPtr<ExpressionNode> m_expr;
    1912         RefPtr<StatementNode> m_statement;
    1913         bool m_identIsVarDecl;
    1914     };
    1915 
    1916     class ContinueNode : public StatementNode, public ThrowableExpressionData {
    1917     public:
    1918         ContinueNode(JSGlobalData* globalData) JSC_FAST_CALL
    1919             : StatementNode(globalData)
    1920         {
    1921         }
    1922 
    1923         ContinueNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL
    1924             : StatementNode(globalData)
    1925             , m_ident(ident)
    1926         {
    1927         }
    1928        
    1929         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1930 
    1931     private:
    1932         Identifier m_ident;
    1933     };
    1934 
    1935     class BreakNode : public StatementNode, public ThrowableExpressionData {
    1936     public:
    1937         BreakNode(JSGlobalData* globalData) JSC_FAST_CALL
    1938             : StatementNode(globalData)
    1939         {
    1940         }
    1941 
    1942         BreakNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL
    1943             : StatementNode(globalData)
    1944             , m_ident(ident)
    1945         {
    1946         }
    1947        
    1948         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1949 
    1950     private:
    1951         Identifier m_ident;
    1952     };
    1953 
    1954     class ReturnNode : public StatementNode, public ThrowableExpressionData {
    1955     public:
    1956         ReturnNode(JSGlobalData* globalData, ExpressionNode* value) JSC_FAST_CALL
    1957             : StatementNode(globalData)
    1958             , m_value(value)
    1959         {
    1960         }
    1961 
    1962         virtual ~ReturnNode();
    1963         virtual void releaseNodes(NodeReleaser&);
    1964 
    1965         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1966         virtual bool isReturnNode() const JSC_FAST_CALL { return true; }
    1967 
    1968     private:
    1969         RefPtr<ExpressionNode> m_value;
    1970     };
    1971 
    1972     class WithNode : public StatementNode {
    1973     public:
    1974         WithNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement, uint32_t divot, uint32_t expressionLength) JSC_FAST_CALL
    1975             : StatementNode(globalData)
    1976             , m_expr(expr)
    1977             , m_statement(statement)
    1978             , m_divot(divot)
    1979             , m_expressionLength(expressionLength)
    1980         {
    1981         }
    1982 
    1983         virtual ~WithNode();
    1984         virtual void releaseNodes(NodeReleaser&);
    1985 
    1986         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1987 
    1988     private:
    1989         RefPtr<ExpressionNode> m_expr;
    1990         RefPtr<StatementNode> m_statement;
    1991         uint32_t m_divot;
    1992         uint32_t m_expressionLength;
    1993     };
    1994 
    1995     class LabelNode : public StatementNode, public ThrowableExpressionData {
    1996     public:
    1997         LabelNode(JSGlobalData* globalData, const Identifier& name, StatementNode* statement) JSC_FAST_CALL
    1998             : StatementNode(globalData)
    1999             , m_name(name)
    2000             , m_statement(statement)
    2001         {
    2002         }
    2003 
    2004         virtual ~LabelNode();
    2005         virtual void releaseNodes(NodeReleaser&);
    2006 
    2007         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2008 
    2009     private:
    2010         Identifier m_name;
    2011         RefPtr<StatementNode> m_statement;
    2012     };
    2013 
    2014     class ThrowNode : public StatementNode, public ThrowableExpressionData {
    2015     public:
    2016         ThrowNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    2017             : StatementNode(globalData)
    2018             , m_expr(expr)
    2019         {
    2020         }
    2021 
    2022         virtual ~ThrowNode();
    2023         virtual void releaseNodes(NodeReleaser&);
    2024 
    2025         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2026 
    2027     private:
    2028         RefPtr<ExpressionNode> m_expr;
    2029     };
    2030 
    2031     class TryNode : public StatementNode {
    2032     public:
    2033         TryNode(JSGlobalData* globalData, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock) JSC_FAST_CALL
    2034             : StatementNode(globalData)
    2035             , m_tryBlock(tryBlock)
    2036             , m_exceptionIdent(exceptionIdent)
    2037             , m_catchBlock(catchBlock)
    2038             , m_finallyBlock(finallyBlock)
    2039             , m_catchHasEval(catchHasEval)
    2040         {
    2041         }
    2042 
    2043         virtual ~TryNode();
    2044         virtual void releaseNodes(NodeReleaser&);
    2045 
    2046         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* dst = 0) JSC_FAST_CALL;
    2047 
    2048     private:
    2049         RefPtr<StatementNode> m_tryBlock;
    2050         Identifier m_exceptionIdent;
    2051         RefPtr<StatementNode> m_catchBlock;
    2052         RefPtr<StatementNode> m_finallyBlock;
    2053         bool m_catchHasEval;
    2054     };
    2055 
    2056     class ParameterNode : public ParserRefCounted {
    2057     public:
    2058         ParameterNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL
    2059             : ParserRefCounted(globalData)
    2060             , m_ident(ident)
    2061         {
    2062         }
    2063 
    2064         ParameterNode(JSGlobalData* globalData, ParameterNode* l, const Identifier& ident) JSC_FAST_CALL
    2065             : ParserRefCounted(globalData)
    2066             , m_ident(ident)
    2067         {
    2068             l->m_next = this;
    2069         }
    2070 
    2071         virtual ~ParameterNode();
    2072         virtual void releaseNodes(NodeReleaser&);
    2073 
    2074         const Identifier& ident() const JSC_FAST_CALL { return m_ident; }
    2075         ParameterNode* nextParam() const JSC_FAST_CALL { return m_next.get(); }
    2076 
    2077     private:
    2078         Identifier m_ident;
    2079         RefPtr<ParameterNode> m_next;
    2080     };
    2081 
    2082     struct ScopeNodeData {
    2083         typedef DeclarationStacks::VarStack VarStack;
    2084         typedef DeclarationStacks::FunctionStack FunctionStack;
    2085 
    2086         ScopeNodeData(SourceElements*, VarStack*, FunctionStack*, int numConstants);
    2087 
    2088         VarStack m_varStack;
    2089         FunctionStack m_functionStack;
    2090         int m_numConstants;
    2091         StatementVector m_children;
    2092 
    2093         void mark();
    2094     };
    2095 
    2096     class ScopeNode : public StatementNode {
    2097     public:
    2098         typedef DeclarationStacks::VarStack VarStack;
    2099         typedef DeclarationStacks::FunctionStack FunctionStack;
    2100 
    2101         ScopeNode(JSGlobalData*) JSC_FAST_CALL;
    2102         ScopeNode(JSGlobalData*, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, CodeFeatures, int numConstants) JSC_FAST_CALL;
    2103         virtual ~ScopeNode();
    2104         virtual void releaseNodes(NodeReleaser&);
    2105 
    2106         void adoptData(std::auto_ptr<ScopeNodeData> data) { m_data.adopt(data); }
    2107         ScopeNodeData* data() const { return m_data.get(); }
    2108         void destroyData() { m_data.clear(); }
    2109 
    2110         const SourceCode& source() const { return m_source; }
    2111         const UString& sourceURL() const JSC_FAST_CALL { return m_source.provider()->url(); }
    2112         intptr_t sourceID() const { return m_source.provider()->asID(); }
    2113 
    2114         void setFeatures(CodeFeatures features) { m_features = features; }
    2115         CodeFeatures features() { return m_features; }
    2116 
    2117         bool usesEval() const { return m_features & EvalFeature; }
    2118         bool usesArguments() const { return m_features & ArgumentsFeature; }
    2119         void setUsesArguments() { m_features |= ArgumentsFeature; }
    2120         bool usesThis() const { return m_features & ThisFeature; }
    2121         bool needsActivation() const { return m_features & (EvalFeature | ClosureFeature | WithFeature | CatchFeature); }
    2122 
    2123         VarStack& varStack() { ASSERT(m_data); return m_data->m_varStack; }
    2124         FunctionStack& functionStack() { ASSERT(m_data); return m_data->m_functionStack; }
    2125 
    2126         StatementVector& children() { ASSERT(m_data); return m_data->m_children; }
    2127 
    2128         int neededConstants()
    2129         {
    2130             ASSERT(m_data);
    2131             // We may need 2 more constants than the count given by the parser,
    2132             // because of the various uses of jsUndefined() and jsNull().
    2133             return m_data->m_numConstants + 2;
    2134         }
    2135 
    2136         virtual void mark() { }
    2137 
    2138     protected:
    2139         void setSource(const SourceCode& source) { m_source = source; }
    2140 
    2141     private:
    2142         OwnPtr<ScopeNodeData> m_data;
    2143         CodeFeatures m_features;
    2144         SourceCode m_source;
    2145     };
    2146 
    2147     class ProgramNode : public ScopeNode {
    2148     public:
    2149         static ProgramNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL;
    2150 
    2151         ProgramCodeBlock& bytecode(ScopeChainNode* scopeChain) JSC_FAST_CALL
    2152         {
    2153             if (!m_code)
    2154                 generateBytecode(scopeChain);
    2155             return *m_code;
    2156         }
    2157 
    2158     private:
    2159         ProgramNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL;
    2160 
    2161         void generateBytecode(ScopeChainNode*) JSC_FAST_CALL;
    2162         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2163 
    2164         OwnPtr<ProgramCodeBlock> m_code;
    2165     };
    2166 
    2167     class EvalNode : public ScopeNode {
    2168     public:
    2169         static EvalNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL;
    2170 
    2171         EvalCodeBlock& bytecode(ScopeChainNode* scopeChain) JSC_FAST_CALL
    2172         {
    2173             if (!m_code)
    2174                 generateBytecode(scopeChain);
    2175             return *m_code;
    2176         }
    2177 
    2178         EvalCodeBlock& bytecodeForExceptionInfoReparse(ScopeChainNode*, CodeBlock*) JSC_FAST_CALL;
    2179 
    2180         virtual void mark();
    2181 
    2182     private:
    2183         EvalNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL;
    2184 
    2185         void generateBytecode(ScopeChainNode*) JSC_FAST_CALL;
    2186         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2187        
    2188         OwnPtr<EvalCodeBlock> m_code;
    2189     };
    2190 
    2191     class FunctionBodyNode : public ScopeNode {
    2192         friend class JIT;
    2193     public:
    2194 #if ENABLE(JIT)
    2195         static PassRefPtr<FunctionBodyNode> createNativeThunk(JSGlobalData*) JSC_FAST_CALL;
    2196 #endif
    2197         static FunctionBodyNode* create(JSGlobalData*) JSC_FAST_CALL;
    2198         static FunctionBodyNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL;
    2199         virtual ~FunctionBodyNode();
    2200 
    2201         const Identifier* parameters() const JSC_FAST_CALL { return m_parameters; }
    2202         size_t parameterCount() const { return m_parameterCount; }
    2203         UString paramString() const JSC_FAST_CALL;
    2204         Identifier* copyParameters();
    2205 
    2206         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2207 
    2208         bool isGenerated() JSC_FAST_CALL
    2209         {
    2210             return m_code;
    2211         }
    2212 
    2213 #if ENABLE(JIT)
    2214         bool isHostFunction() const JSC_FAST_CALL
    2215         {
    2216             return m_jitCode && !m_code;
    2217         }
    2218 #else
    2219         bool isHostFunction() const JSC_FAST_CALL
    2220         {
    2221             return true;
    2222         }
    2223 #endif
    2224 
    2225         virtual void mark();
    2226 
    2227         void finishParsing(const SourceCode&, ParameterNode*);
    2228         void finishParsing(Identifier* parameters, size_t parameterCount);
    2229        
    2230         UString toSourceString() const JSC_FAST_CALL { return source().toString(); }
    2231 
    2232         // These objects are ref/deref'd a lot in the scope chain, so this is a faster ref/deref.
    2233         // If the virtual machine changes so this doesn't happen as much we can change back.
    2234         void ref()
    2235         {
    2236             if (++m_refCount == 1)
    2237                 ScopeNode::ref();
    2238         }
    2239         void deref()
    2240         {
    2241             ASSERT(m_refCount);
    2242             if (!--m_refCount)
    2243                 ScopeNode::deref();
    2244         }
    2245 
    2246         CodeBlock& bytecodeForExceptionInfoReparse(ScopeChainNode*, CodeBlock*) JSC_FAST_CALL;
    2247 #if ENABLE(JIT)
    2248         JITCode generatedJITCode()
    2249         {
    2250             ASSERT(m_jitCode);
    2251             return m_jitCode;
    2252         }
    2253 
    2254         JITCode jitCode(ScopeChainNode* scopeChain)
    2255         {
    2256             if (!m_jitCode)
    2257                 generateJITCode(scopeChain);
    2258             return m_jitCode;
    2259         }
    2260 #endif
    2261         CodeBlock& bytecode(ScopeChainNode* scopeChain) JSC_FAST_CALL
    2262         {
    2263             ASSERT(scopeChain);
    2264             if (!m_code)
    2265                 generateBytecode(scopeChain);
    2266             return *m_code;
    2267         }
    2268        
    2269         CodeBlock& generatedBytecode() JSC_FAST_CALL
    2270         {
    2271             ASSERT(m_code);
    2272             return *m_code;
    2273         }
    2274        
    2275     private:
    2276         FunctionBodyNode(JSGlobalData*) JSC_FAST_CALL;
    2277         FunctionBodyNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL;
    2278 
    2279         void generateBytecode(ScopeChainNode*) JSC_FAST_CALL;
    2280 #if ENABLE(JIT)
    2281         void generateJITCode(ScopeChainNode*) JSC_FAST_CALL;
    2282        
    2283         JITCode m_jitCode;
    2284 #endif
    2285         Identifier* m_parameters;
    2286         size_t m_parameterCount;
    2287         OwnPtr<CodeBlock> m_code;
    2288         unsigned m_refCount;
    2289     };
    2290 
    2291     class FuncExprNode : public ExpressionNode {
    2292     public:
    2293         FuncExprNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0) JSC_FAST_CALL
    2294             : ExpressionNode(globalData)
    2295             , m_ident(ident)
    2296             , m_parameter(parameter)
    2297             , m_body(body)
    2298         {
    2299             m_body->finishParsing(source, m_parameter.get());
    2300         }
    2301 
    2302         virtual ~FuncExprNode();
    2303         virtual void releaseNodes(NodeReleaser&);
    2304 
    2305         virtual bool isFuncExprNode() const JSC_FAST_CALL { return true; }
    2306 
    2307         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2308         JSFunction* makeFunction(ExecState*, ScopeChainNode*) JSC_FAST_CALL;
    2309 
    2310         FunctionBodyNode* body() { return m_body.get(); }
    2311 
    2312     private:
    2313         Identifier m_ident;
    2314         RefPtr<ParameterNode> m_parameter;
    2315         RefPtr<FunctionBodyNode> m_body;
    2316     };
    2317 
    2318     class FuncDeclNode : public StatementNode {
    2319     public:
    2320         FuncDeclNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0) JSC_FAST_CALL
    2321             : StatementNode(globalData)
    2322             , m_ident(ident)
    2323             , m_parameter(parameter)
    2324             , m_body(body)
    2325         {
    2326             m_body->finishParsing(source, m_parameter.get());
    2327         }
    2328 
    2329         virtual ~FuncDeclNode();
    2330         virtual void releaseNodes(NodeReleaser&);
    2331 
    2332         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2333 
    2334         JSFunction* makeFunction(ExecState*, ScopeChainNode*) JSC_FAST_CALL;
    2335 
    2336         Identifier m_ident;
    2337 
    2338         FunctionBodyNode* body() { return m_body.get(); }
    2339 
    2340     private:
    2341         RefPtr<ParameterNode> m_parameter;
    2342         RefPtr<FunctionBodyNode> m_body;
    2343     };
    2344 
    2345     class CaseClauseNode : public ParserRefCounted {
    2346     public:
    2347         CaseClauseNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    2348             : ParserRefCounted(globalData)
    2349             , m_expr(expr)
    2350         {
    2351         }
    2352 
    2353         CaseClauseNode(JSGlobalData* globalData, ExpressionNode* expr, SourceElements* children) JSC_FAST_CALL
    2354             : ParserRefCounted(globalData)
    2355             , m_expr(expr)
    2356         {
    2357             if (children)
    2358                 children->releaseContentsIntoVector(m_children);
    2359         }
    2360 
    2361         virtual ~CaseClauseNode();
    2362         virtual void releaseNodes(NodeReleaser&);
    2363 
    2364         ExpressionNode* expr() const { return m_expr.get(); }
    2365         StatementVector& children() { return m_children; }
    2366 
    2367     private:
    2368         RefPtr<ExpressionNode> m_expr;
    2369         StatementVector m_children;
    2370     };
    2371 
    2372     class ClauseListNode : public ParserRefCounted {
    2373     public:
    2374         ClauseListNode(JSGlobalData* globalData, CaseClauseNode* clause) JSC_FAST_CALL
    2375             : ParserRefCounted(globalData)
    2376             , m_clause(clause)
    2377         {
    2378         }
    2379 
    2380         ClauseListNode(JSGlobalData* globalData, ClauseListNode* clauseList, CaseClauseNode* clause) JSC_FAST_CALL
    2381             : ParserRefCounted(globalData)
    2382             , m_clause(clause)
    2383         {
    2384             clauseList->m_next = this;
    2385         }
    2386 
    2387         virtual ~ClauseListNode();
    2388         virtual void releaseNodes(NodeReleaser&);
    2389 
    2390         CaseClauseNode* getClause() const JSC_FAST_CALL { return m_clause.get(); }
    2391         ClauseListNode* getNext() const JSC_FAST_CALL { return m_next.get(); }
    2392 
    2393     private:
    2394         RefPtr<CaseClauseNode> m_clause;
    2395         RefPtr<ClauseListNode> m_next;
    2396     };
    2397 
    2398     class CaseBlockNode : public ParserRefCounted {
    2399     public:
    2400         CaseBlockNode(JSGlobalData* globalData, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) JSC_FAST_CALL
    2401             : ParserRefCounted(globalData)
    2402             , m_list1(list1)
    2403             , m_defaultClause(defaultClause)
    2404             , m_list2(list2)
    2405         {
    2406         }
    2407 
    2408         virtual ~CaseBlockNode();
    2409         virtual void releaseNodes(NodeReleaser&);
    2410 
    2411         RegisterID* emitBytecodeForBlock(BytecodeGenerator&, RegisterID* input, RegisterID* dst = 0) JSC_FAST_CALL;
    2412 
    2413     private:
    2414         SwitchInfo::SwitchType tryOptimizedSwitch(Vector<ExpressionNode*, 8>& literalVector, int32_t& min_num, int32_t& max_num);
    2415         RefPtr<ClauseListNode> m_list1;
    2416         RefPtr<CaseClauseNode> m_defaultClause;
    2417         RefPtr<ClauseListNode> m_list2;
    2418     };
    2419 
    2420     class SwitchNode : public StatementNode {
    2421     public:
    2422         SwitchNode(JSGlobalData* globalData, ExpressionNode* expr, CaseBlockNode* block) JSC_FAST_CALL
    2423             : StatementNode(globalData)
    2424             , m_expr(expr)
    2425             , m_block(block)
    2426         {
    2427         }
    2428 
    2429         virtual ~SwitchNode();
    2430         virtual void releaseNodes(NodeReleaser&);
    2431 
    2432         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2433 
    2434     private:
    2435         RefPtr<ExpressionNode> m_expr;
    2436         RefPtr<CaseBlockNode> m_block;
    2437     };
    2438 
    2439     struct ElementList {
    2440         ElementNode* head;
    2441         ElementNode* tail;
    2442     };
    2443 
    2444     struct PropertyList {
    2445         PropertyListNode* head;
    2446         PropertyListNode* tail;
    2447     };
    2448 
    2449     struct ArgumentList {
    2450         ArgumentListNode* head;
    2451         ArgumentListNode* tail;
    2452     };
    2453 
    2454     struct ConstDeclList {
    2455         ConstDeclNode* head;
    2456         ConstDeclNode* tail;
    2457     };
    2458 
    2459     struct ParameterList {
    2460         ParameterNode* head;
    2461         ParameterNode* tail;
    2462     };
    2463 
    2464     struct ClauseList {
    2465         ClauseListNode* head;
    2466         ClauseListNode* tail;
    2467     };
     900        // for( var foo = bar in baz )
     901    }
    2468902
    2469903} // namespace JSC
    2470904
    2471 #endif // NODES_H_
     905#endif // NodeConstructors_h

  • trunk/JavaScriptCore/parser/Nodes.cpp

    r43270 r43311  
    2626#include "config.h"
    2727#include "Nodes.h"
     28#include "NodeConstructors.h"
    2829
    2930#include "BytecodeGenerator.h"
    … …  
    138139}
    139140
    140 // ------------------------------ Node -------------------------------------------------
    141 
    142 Node::Node(JSGlobalData* globalData)
    143     : ParserRefCounted(globalData)
    144     , m_line(globalData->lexer->lineNumber())
    145 {
    146 }
    147 
    148141// ------------------------------ ThrowableExpressionData --------------------------------
    149142
    … …  
    177170   
    178171// ------------------------------ StatementNode --------------------------------
    179 
    180 StatementNode::StatementNode(JSGlobalData* globalData)
    181     : Node(globalData)
    182     , m_lastLine(-1)
    183 {
    184 }
    185172
    186173void StatementNode::setLoc(int firstLine, int lastLine)
    … …  
    15841571}
    15851572
    1586 ConstDeclNode::ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* init)
    1587     : ExpressionNode(globalData)
    1588     , m_ident(ident)
    1589     , m_init(init)
    1590 {
    1591 }
    1592 
    15931573RegisterID* ConstDeclNode::emitCodeSingle(BytecodeGenerator& generator)
    15941574{
    … …  
    16601640}
    16611641
    1662 BlockNode::BlockNode(JSGlobalData* globalData, SourceElements* children)
    1663     : StatementNode(globalData)
    1664 {
    1665     if (children)
    1666         children->releaseContentsIntoVector(m_children);
    1667 }
    1668 
    16691642RegisterID* BlockNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
    16701643{
    … …  
    19131886    releaser.release(m_expr);
    19141887    releaser.release(m_statement);
    1915 }
    1916 
    1917 ForInNode::ForInNode(JSGlobalData* globalData, ExpressionNode* l, ExpressionNode* expr, StatementNode* statement)
    1918     : StatementNode(globalData)
    1919     , m_init(0L)
    1920     , m_lexpr(l)
    1921     , m_expr(expr)
    1922     , m_statement(statement)
    1923     , m_identIsVarDecl(false)
    1924 {
    1925 }
    1926 
    1927 ForInNode::ForInNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in, ExpressionNode* expr, StatementNode* statement, int divot, int startOffset, int endOffset)
    1928     : StatementNode(globalData)
    1929     , m_ident(ident)
    1930     , m_lexpr(new ResolveNode(globalData, ident, divot - startOffset))
    1931     , m_expr(expr)
    1932     , m_statement(statement)
    1933     , m_identIsVarDecl(true)
    1934 {
    1935     if (in) {
    1936         AssignResolveNode* node = new AssignResolveNode(globalData, ident, in, true);
    1937         node->setExceptionSourceCode(divot, divot - startOffset, endOffset - divot);
    1938         m_init = node;
    1939     }
    1940     // for( var foo = bar in baz )
    19411888}
    19421889
    … …  
    26182565    , m_parameters(0)
    26192566    , m_parameterCount(0)
    2620     , m_refCount(0)
    26212567{
    26222568}
    … …  
    26292575    , m_parameters(0)
    26302576    , m_parameterCount(0)
    2631     , m_refCount(0)
    26322577{
    26332578}

  • trunk/JavaScriptCore/parser/Nodes.h

    r43270 r43311  
    2424 */
    2525
    26 #ifndef NODES_H_
    27 #define NODES_H_
     26#ifndef Nodes_h
     27#define Nodes_h
    2828
    2929#include "Error.h"
    … …  
    104104    class ParserRefCounted : public RefCounted<ParserRefCounted> {
    105105    protected:
    106         ParserRefCounted(JSGlobalData*) JSC_FAST_CALL;
     106        ParserRefCounted(JSGlobalData*);
    107107
    108108    public:
    … …  
    114114
    115115#ifdef NDEBUG
    116     inline ParserRefCounted::ParserRefCounted(JSGlobalData* globalData)
    117     {
    118         globalData->parserObjects.append(adoptRef(this));
    119     }
    120 
    121116    inline ParserRefCounted::~ParserRefCounted()
    122117    {
    … …  
    126121    class Node : public ParserRefCounted {
    127122    public:
    128         Node(JSGlobalData* globalData) JSC_FAST_CALL;
     123        Node(JSGlobalData*);
    129124
    130125        /*
    … …  
    160155    class ExpressionNode : public Node {
    161156    public:
    162         ExpressionNode(JSGlobalData* globalData, ResultType resultDesc = ResultType::unknownType()) JSC_FAST_CALL
    163             : Node(globalData)
    164             , m_resultDesc(resultDesc)
    165         {
    166         }
     157        ExpressionNode(JSGlobalData*, ResultType = ResultType::unknownType());
    167158
    168159        virtual bool isNumber() const JSC_FAST_CALL { return false; }
    … …  
    179170        virtual ExpressionNode* stripUnaryPlus() { return this; }
    180171
    181         ResultType resultDescriptor() const JSC_FAST_CALL { return m_resultDesc; }
     172        ResultType resultDescriptor() const JSC_FAST_CALL { return m_resultType; }
    182173
    183174        // This needs to be in public in order to compile using GCC 3.x
    … …  
    185176
    186177    private:
    187         ResultType m_resultDesc;
     178        ResultType m_resultType;
    188179    };
    189180
    190181    class StatementNode : public Node {
    191182    public:
    192         StatementNode(JSGlobalData*) JSC_FAST_CALL;
     183        StatementNode(JSGlobalData*);
     184
    193185        void setLoc(int line0, int line1) JSC_FAST_CALL;
    194186        int firstLine() const JSC_FAST_CALL { return lineNo(); }
    … …  
    207199    class NullNode : public ExpressionNode {
    208200    public:
    209         NullNode(JSGlobalData* globalData) JSC_FAST_CALL
    210             : ExpressionNode(globalData, ResultType::nullType())
    211         {
    212         }
     201        NullNode(JSGlobalData*);
     202
     203    private:
     204        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    213205
    214206        virtual bool isNull() const JSC_FAST_CALL { return true; }
    215 
    216         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    217207    };
    218208
    219209    class BooleanNode : public ExpressionNode {
    220210    public:
    221         BooleanNode(JSGlobalData* globalData, bool value) JSC_FAST_CALL
    222             : ExpressionNode(globalData, ResultType::booleanType())
    223             , m_value(value)
    224         {
    225         }
    226 
     211        BooleanNode(JSGlobalData*, bool value);
     212
     213    private:
    227214        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    228215
    229216        virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; }
    230217
    231     private:
    232218        bool m_value;
    233219    };
    … …  
    235221    class NumberNode : public ExpressionNode {
    236222    public:
    237         NumberNode(JSGlobalData* globalData, double v) JSC_FAST_CALL
    238             : ExpressionNode(globalData, ResultType::numberType())
    239             , m_double(v)
    240         {
    241         }
    242 
     223        NumberNode(JSGlobalData*, double v);
     224
     225        double value() const JSC_FAST_CALL { return m_double; }
     226        void setValue(double d) JSC_FAST_CALL { m_double = d; }
     227
     228    private:
    243229        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    244230
    245231        virtual bool isNumber() const JSC_FAST_CALL { return true; }
    246232        virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; }
    247         double value() const JSC_FAST_CALL { return m_double; }
    248         void setValue(double d) JSC_FAST_CALL { m_double = d; }
    249 
    250     private:
     233
    251234        double m_double;
    252235    };
    … …  
    254237    class StringNode : public ExpressionNode {
    255238    public:
    256         StringNode(JSGlobalData* globalData, const Identifier& v) JSC_FAST_CALL
    257             : ExpressionNode(globalData, ResultType::stringType())
    258             , m_value(v)
    259         {
    260         }
    261 
     239        StringNode(JSGlobalData*, const Identifier& v);
     240
     241        const Identifier& value() { return m_value; }
     242        virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; }
     243
     244    private:
    262245        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    263246       
    264247        virtual bool isString() const JSC_FAST_CALL { return true; }
    265         const Identifier& value() { return m_value; }
    266         virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; }
    267 
    268     private:
     248
    269249        Identifier m_value;
    270250    };
    … …  
    369349    class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
    370350    public:
    371         RegExpNode(JSGlobalData* globalData, const UString& pattern, const UString& flags) JSC_FAST_CALL
    372             : ExpressionNode(globalData)
    373             , m_pattern(pattern)
    374             , m_flags(flags)
    375         {
    376         }
    377 
    378         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    379 
    380     private:
     351        RegExpNode(JSGlobalData*, const UString& pattern, const UString& flags);
     352
     353    private:
     354        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     355
    381356        UString m_pattern;
    382357        UString m_flags;
    … …  
    385360    class ThisNode : public ExpressionNode {
    386361    public:
    387         ThisNode(JSGlobalData* globalData) JSC_FAST_CALL
    388             : ExpressionNode(globalData)
    389         {
    390         }
    391 
     362        ThisNode(JSGlobalData*);
     363
     364    private:
    392365        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    393366    };
    … …  
    395368    class ResolveNode : public ExpressionNode {
    396369    public:
    397         ResolveNode(JSGlobalData* globalData, const Identifier& ident, int startOffset) JSC_FAST_CALL
    398             : ExpressionNode(globalData)
    399             , m_ident(ident)
    400             , m_startOffset(startOffset)
    401         {
    402         }
    403 
     370        ResolveNode(JSGlobalData*, const Identifier&, int startOffset);
     371
     372        const Identifier& identifier() const JSC_FAST_CALL { return m_ident; }
     373
     374    private:
    404375        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    405376
    … …  
    407378        virtual bool isLocation() const JSC_FAST_CALL { return true; }
    408379        virtual bool isResolveNode() const JSC_FAST_CALL { return true; }
    409         const Identifier& identifier() const JSC_FAST_CALL { return m_ident; }
    410 
    411     private:
     380
    412381        Identifier m_ident;
    413382        int32_t m_startOffset;
    … …  
    416385    class ElementNode : public ParserRefCounted {
    417386    public:
    418         ElementNode(JSGlobalData* globalData, int elision, ExpressionNode* node) JSC_FAST_CALL
    419             : ParserRefCounted(globalData)
    420             , m_elision(elision)
    421             , m_node(node)
    422         {
    423         }
    424 
    425         ElementNode(JSGlobalData* globalData, ElementNode* l, int elision, ExpressionNode* node) JSC_FAST_CALL
    426             : ParserRefCounted(globalData)
    427             , m_elision(elision)
    428             , m_node(node)
    429         {
    430             l->m_next = this;
    431         }
    432 
     387        ElementNode(JSGlobalData*, int elision, ExpressionNode*);
     388        ElementNode(JSGlobalData*, ElementNode*, int elision, ExpressionNode*);
    433389        virtual ~ElementNode();
    434390        virtual void releaseNodes(NodeReleaser&);
    … …  
    436392        int elision() const { return m_elision; }
    437393        ExpressionNode* value() { return m_node.get(); }
    438 
    439394        ElementNode* next() { return m_next.get(); }
    440395
    … …  
    447402    class ArrayNode : public ExpressionNode {
    448403    public:
    449         ArrayNode(JSGlobalData* globalData, int elision) JSC_FAST_CALL
    450             : ExpressionNode(globalData)
    451             , m_elision(elision)
    452             , m_optional(true)
    453         {
    454         }
    455 
    456         ArrayNode(JSGlobalData* globalData, ElementNode* element) JSC_FAST_CALL
    457             : ExpressionNode(globalData)
    458             , m_element(element)
    459             , m_elision(0)
    460             , m_optional(false)
    461         {
    462         }
    463 
    464         ArrayNode(JSGlobalData* globalData, int elision, ElementNode* element) JSC_FAST_CALL
    465             : ExpressionNode(globalData)
    466             , m_element(element)
    467             , m_elision(elision)
    468             , m_optional(true)
    469         {
    470         }
    471 
     404        ArrayNode(JSGlobalData*, int elision);
     405        ArrayNode(JSGlobalData*, ElementNode*);
     406        ArrayNode(JSGlobalData*, int elision, ElementNode*);
    472407        virtual ~ArrayNode();
    473408        virtual void releaseNodes(NodeReleaser&);
    474409
     410        PassRefPtr<ArgumentListNode> toArgumentList(JSGlobalData*) const;
     411
     412    private:
    475413        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    476414
    477415        virtual bool isSimpleArray() const JSC_FAST_CALL;
    478         PassRefPtr<ArgumentListNode> toArgumentList(JSGlobalData*) const;
    479     private:
     416
    480417        RefPtr<ElementNode> m_element;
    481418        int m_elision;
    … …  
    487424        enum Type { Constant, Getter, Setter };
    488425
    489         PropertyNode(JSGlobalData* globalData, const Identifier& name, ExpressionNode* assign, Type type) JSC_FAST_CALL
    490             : ParserRefCounted(globalData)
    491             , m_name(name)
    492             , m_assign(assign)
    493             , m_type(type)
    494         {
    495         }
    496 
     426        PropertyNode(JSGlobalData*, const Identifier& name, ExpressionNode* value, Type);
    497427        virtual ~PropertyNode();
    498428        virtual void releaseNodes(NodeReleaser&);
    … …  
    509439    class PropertyListNode : public Node {
    510440    public:
    511         PropertyListNode(JSGlobalData* globalData, PropertyNode* node) JSC_FAST_CALL
    512             : Node(globalData)
    513             , m_node(node)
    514         {
    515         }
    516 
    517         PropertyListNode(JSGlobalData* globalData, PropertyNode* node, PropertyListNode* list) JSC_FAST_CALL
    518             : Node(globalData)
    519             , m_node(node)
    520         {
    521             list->m_next = this;
    522         }
    523 
     441        PropertyListNode(JSGlobalData*, PropertyNode*);
     442        PropertyListNode(JSGlobalData*, PropertyNode*, PropertyListNode*);
    524443        virtual ~PropertyListNode();
    525444        virtual void releaseNodes(NodeReleaser&);
    … …  
    534453    class ObjectLiteralNode : public ExpressionNode {
    535454    public:
    536         ObjectLiteralNode(JSGlobalData* globalData) JSC_FAST_CALL
    537             : ExpressionNode(globalData)
    538         {
    539         }
    540 
    541         ObjectLiteralNode(JSGlobalData* globalData, PropertyListNode* list) JSC_FAST_CALL
    542             : ExpressionNode(globalData)
    543             , m_list(list)
    544         {
    545         }
    546 
     455        ObjectLiteralNode(JSGlobalData*);
     456        ObjectLiteralNode(JSGlobalData*, PropertyListNode*);
    547457        virtual ~ObjectLiteralNode();
    548458        virtual void releaseNodes(NodeReleaser&);
    549459
    550         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    551 
    552     private:
     460    private:
     461        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     462
    553463        RefPtr<PropertyListNode> m_list;
    554464    };
    … …  
    556466    class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
    557467    public:
    558         BracketAccessorNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments) JSC_FAST_CALL
    559             : ExpressionNode(globalData)
    560             , m_base(base)
    561             , m_subscript(subscript)
    562             , m_subscriptHasAssignments(subscriptHasAssignments)
    563         {
    564         }
    565 
     468        BracketAccessorNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);
    566469        virtual ~BracketAccessorNode();
    567470        virtual void releaseNodes(NodeReleaser&);
    568471
     472        ExpressionNode* base() JSC_FAST_CALL { return m_base.get(); }
     473        ExpressionNode* subscript() JSC_FAST_CALL { return m_subscript.get(); }
     474
     475    private:
    569476        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    570477
    571478        virtual bool isLocation() const JSC_FAST_CALL { return true; }
    572479        virtual bool isBracketAccessorNode() const JSC_FAST_CALL { return true; }
    573         ExpressionNode* base() JSC_FAST_CALL { return m_base.get(); }
    574         ExpressionNode* subscript() JSC_FAST_CALL { return m_subscript.get(); }
    575 
    576     private:
     480
    577481        RefPtr<ExpressionNode> m_base;
    578482        RefPtr<ExpressionNode> m_subscript;
    … …  
    582486    class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
    583487    public:
    584         DotAccessorNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident) JSC_FAST_CALL
    585             : ExpressionNode(globalData)
    586             , m_base(base)
    587             , m_ident(ident)
    588         {
    589         }
    590 
     488        DotAccessorNode(JSGlobalData*, ExpressionNode* base, const Identifier&);
    591489        virtual ~DotAccessorNode();
    592490        virtual void releaseNodes(NodeReleaser&);
    593491
     492        ExpressionNode* base() const JSC_FAST_CALL { return m_base.get(); }
     493        const Identifier& identifier() const JSC_FAST_CALL { return m_ident; }
     494
     495    private:
    594496        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    595497
    596498        virtual bool isLocation() const JSC_FAST_CALL { return true; }
    597499        virtual bool isDotAccessorNode() const JSC_FAST_CALL { return true; }
    598         ExpressionNode* base() const JSC_FAST_CALL { return m_base.get(); }
    599         const Identifier& identifier() const JSC_FAST_CALL { return m_ident; }
    600 
    601     private:
     500
    602501        RefPtr<ExpressionNode> m_base;
    603502        Identifier m_ident;
    … …  
    606505    class ArgumentListNode : public Node {
    607506    public:
    608         ArgumentListNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    609             : Node(globalData)
    610             , m_expr(expr)
    611         {
    612         }
    613 
    614         ArgumentListNode(JSGlobalData* globalData, ArgumentListNode* listNode, ExpressionNode* expr) JSC_FAST_CALL
    615             : Node(globalData)
    616             , m_expr(expr)
    617         {
    618             listNode->m_next = this;
    619         }
    620 
     507        ArgumentListNode(JSGlobalData*, ExpressionNode*);
     508        ArgumentListNode(JSGlobalData*, ArgumentListNode*, ExpressionNode*);
    621509        virtual ~ArgumentListNode();
    622510        virtual void releaseNodes(NodeReleaser&);
    623 
    624         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    625511
    626512        RefPtr<ArgumentListNode> m_next;
    627513        RefPtr<ExpressionNode> m_expr;
     514
     515    private:
     516        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    628517    };
    629518
    630519    class ArgumentsNode : public ParserRefCounted {
    631520    public:
    632         ArgumentsNode(JSGlobalData* globalData) JSC_FAST_CALL
    633             : ParserRefCounted(globalData)
    634         {
    635         }
    636 
    637         ArgumentsNode(JSGlobalData* globalData, ArgumentListNode* listNode) JSC_FAST_CALL
    638             : ParserRefCounted(globalData)
    639             , m_listNode(listNode)
    640         {
    641         }
    642 
     521        ArgumentsNode(JSGlobalData*);
     522        ArgumentsNode(JSGlobalData*, ArgumentListNode*);
    643523        virtual ~ArgumentsNode();
    644524        virtual void releaseNodes(NodeReleaser&);
    … …  
    649529    class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
    650530    public:
    651         NewExprNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    652             : ExpressionNode(globalData)
    653             , m_expr(expr)
    654         {
    655         }
    656 
    657         NewExprNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args) JSC_FAST_CALL
    658             : ExpressionNode(globalData)
    659             , m_expr(expr)
    660             , m_args(args)
    661         {
    662         }
    663 
     531        NewExprNode(JSGlobalData*, ExpressionNode*);
     532        NewExprNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*);
    664533        virtual ~NewExprNode();
    665534        virtual void releaseNodes(NodeReleaser&);
    666535
    667         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    668 
    669     private:
     536    private:
     537        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     538
    670539        RefPtr<ExpressionNode> m_expr;
    671540        RefPtr<ArgumentsNode> m_args;
    … …  
    674543    class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
    675544    public:
    676         EvalFunctionCallNode(JSGlobalData* globalData, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    677             : ExpressionNode(globalData)
    678             , ThrowableExpressionData(divot, startOffset, endOffset)
    679             , m_args(args)
    680         {
    681         }
    682 
     545        EvalFunctionCallNode(JSGlobalData*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
    683546        virtual ~EvalFunctionCallNode();
    684547        virtual void releaseNodes(NodeReleaser&);
    685548
    686         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    687 
    688     private:
     549    private:
     550        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     551
    689552        RefPtr<ArgumentsNode> m_args;
    690553    };
    … …  
    692555    class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
    693556    public:
    694         FunctionCallValueNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    695             : ExpressionNode(globalData)
    696             , ThrowableExpressionData(divot, startOffset, endOffset)
    697             , m_expr(expr)
    698             , m_args(args)
    699         {
    700         }
    701 
     557        FunctionCallValueNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
    702558        virtual ~FunctionCallValueNode();
    703559        virtual void releaseNodes(NodeReleaser&);
    704560
    705         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    706 
    707     private:
     561    private:
     562        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     563
    708564        RefPtr<ExpressionNode> m_expr;
    709565        RefPtr<ArgumentsNode> m_args;
    … …  
    712568    class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
    713569    public:
    714         FunctionCallResolveNode(JSGlobalData* globalData, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    715             : ExpressionNode(globalData)
    716             , ThrowableExpressionData(divot, startOffset, endOffset)
    717             , m_ident(ident)
    718             , m_args(args)
    719         {
    720         }
     570        FunctionCallResolveNode(JSGlobalData*, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
    721571
    722572        virtual ~FunctionCallResolveNode();
    723573        virtual void releaseNodes(NodeReleaser&);
    724574
    725         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    726 
    727     private:
     575    private:
     576        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     577
    728578        Identifier m_ident;
    729579        RefPtr<ArgumentsNode> m_args;
    … …  
    734584    class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
    735585    public:
    736         FunctionCallBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    737             : ExpressionNode(globalData)
    738             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    739             , m_base(base)
    740             , m_subscript(subscript)
    741             , m_args(args)
    742         {
    743         }
    744 
     586        FunctionCallBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
    745587        virtual ~FunctionCallBracketNode();
    746588        virtual void releaseNodes(NodeReleaser&);
    747589
    748         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    749 
    750     private:
     590    private:
     591        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     592
    751593        RefPtr<ExpressionNode> m_base;
    752594        RefPtr<ExpressionNode> m_subscript;
    … …  
    756598    class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
    757599    public:
    758         FunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    759             : ExpressionNode(globalData)
    760             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    761             , m_base(base)
    762             , m_ident(ident)
    763             , m_args(args)
    764         {
    765         }
    766 
     600        FunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
    767601        virtual ~FunctionCallDotNode();
    768602        virtual void releaseNodes(NodeReleaser&);
    769603
     604    private:
    770605        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    771606
    772607    protected:
    773608        RefPtr<ExpressionNode> m_base;
    774         Identifier m_ident;
     609        const Identifier m_ident;
    775610        RefPtr<ArgumentsNode> m_args;
    776611    };
    … …  
    778613    class CallFunctionCallDotNode : public FunctionCallDotNode {
    779614    public:
    780         CallFunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    781             : FunctionCallDotNode(globalData, base, ident, args, divot, startOffset, endOffset)
    782         {
    783         }
     615        CallFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
     616
     617    private:
    784618        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    785619    };
    … …  
    787621    class ApplyFunctionCallDotNode : public FunctionCallDotNode {
    788622    public:
    789         ApplyFunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    790         : FunctionCallDotNode(globalData, base, ident, args, divot, startOffset, endOffset)
    791         {
    792         }
     623        ApplyFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
     624
     625    private:
    793626        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    794627    };
    … …  
    796629    class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {
    797630    public:
    798         PrePostResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    799             : ExpressionNode(globalData, ResultType::numberType()) // could be reusable for pre?
    800             , ThrowableExpressionData(divot, startOffset, endOffset)
    801             , m_ident(ident)
    802         {
    803         }
     631        PrePostResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
    804632
    805633    protected:
    806         Identifier m_ident;
     634        const Identifier m_ident;
    807635    };
    808636
    809637    class PostfixResolveNode : public PrePostResolveNode {
    810638    public:
    811         PostfixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    812             : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
    813             , m_operator(oper)
    814         {
    815         }
    816 
    817         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    818 
    819     private:
     639        PostfixResolveNode(JSGlobalData*, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
     640
     641    private:
     642        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     643
    820644        Operator m_operator;
    821645    };
    … …  
    823647    class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
    824648    public:
    825         PostfixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    826             : ExpressionNode(globalData)
    827             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    828             , m_base(base)
    829             , m_subscript(subscript)
    830             , m_operator(oper)
    831         {
    832         }
    833 
     649        PostfixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    834650        virtual ~PostfixBracketNode();
    835651        virtual void releaseNodes(NodeReleaser&);
    836652
    837         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    838 
    839     private:
     653    private:
     654        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     655
    840656        RefPtr<ExpressionNode> m_base;
    841657        RefPtr<ExpressionNode> m_subscript;
    … …  
    845661    class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {
    846662    public:
    847         PostfixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    848             : ExpressionNode(globalData)
    849             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    850             , m_base(base)
    851             , m_ident(ident)
    852             , m_operator(oper)
    853         {
    854         }
    855 
     663        PostfixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    856664        virtual ~PostfixDotNode();
    857665        virtual void releaseNodes(NodeReleaser&);
    858666
    859         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    860 
    861     private:
     667    private:
     668        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     669
    862670        RefPtr<ExpressionNode> m_base;
    863671        Identifier m_ident;
    … …  
    867675    class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {
    868676    public:
    869         PostfixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    870             : ExpressionNode(globalData)
    871             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    872             , m_expr(expr)
    873             , m_operator(oper)
    874         {
    875         }
    876 
     677        PostfixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    877678        virtual ~PostfixErrorNode();
    878679        virtual void releaseNodes(NodeReleaser&);
    879680
    880         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    881 
    882     private:
     681    private:
     682        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     683
    883684        RefPtr<ExpressionNode> m_expr;
    884685        Operator m_operator;
    … …  
    887688    class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
    888689    public:
    889         DeleteResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    890             : ExpressionNode(globalData)
    891             , ThrowableExpressionData(divot, startOffset, endOffset)
    892             , m_ident(ident)
    893         {
    894         }
    895 
    896         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    897 
    898     private:
     690        DeleteResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
     691
     692    private:
     693        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     694
    899695        Identifier m_ident;
    900696    };
    … …  
    902698    class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
    903699    public:
    904         DeleteBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    905             : ExpressionNode(globalData)
    906             , ThrowableExpressionData(divot, startOffset, endOffset)
    907             , m_base(base)
    908             , m_subscript(subscript)
    909         {
    910         }
    911 
     700        DeleteBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
    912701        virtual ~DeleteBracketNode();
    913702        virtual void releaseNodes(NodeReleaser&);
    914703
    915         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    916 
    917     private:
     704    private:
     705        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     706
    918707        RefPtr<ExpressionNode> m_base;
    919708        RefPtr<ExpressionNode> m_subscript;
    … …  
    922711    class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
    923712    public:
    924         DeleteDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    925             : ExpressionNode(globalData)
    926             , ThrowableExpressionData(divot, startOffset, endOffset)
    927             , m_base(base)
    928             , m_ident(ident)
    929         {
    930         }
    931 
     713        DeleteDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
    932714        virtual ~DeleteDotNode();
    933715        virtual void releaseNodes(NodeReleaser&);
    934716
    935         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    936 
    937     private:
     717    private:
     718        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     719
    938720        RefPtr<ExpressionNode> m_base;
    939721        Identifier m_ident;
    … …  
    942724    class DeleteValueNode : public ExpressionNode {
    943725    public:
    944         DeleteValueNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    945             : ExpressionNode(globalData)
    946             , m_expr(expr)
    947         {
    948         }
    949 
     726        DeleteValueNode(JSGlobalData*, ExpressionNode*);
    950727        virtual ~DeleteValueNode();
    951728        virtual void releaseNodes(NodeReleaser&);
    952729
    953         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    954 
    955     private:
     730    private:
     731        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     732
    956733        RefPtr<ExpressionNode> m_expr;
    957734    };
    … …  
    959736    class VoidNode : public ExpressionNode {
    960737    public:
    961         VoidNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    962             : ExpressionNode(globalData)
    963             , m_expr(expr)
    964         {
    965         }
    966 
     738        VoidNode(JSGlobalData*, ExpressionNode*);
    967739        virtual ~VoidNode();
    968740        virtual void releaseNodes(NodeReleaser&);
    969741
    970         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    971 
    972     private:
     742    private:
     743        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     744
    973745        RefPtr<ExpressionNode> m_expr;
    974746    };
    … …  
    976748    class TypeOfResolveNode : public ExpressionNode {
    977749    public:
    978         TypeOfResolveNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL
    979             : ExpressionNode(globalData, ResultType::stringType())
    980             , m_ident(ident)
    981         {
    982         }
    983 
    984         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     750        TypeOfResolveNode(JSGlobalData*, const Identifier&);
    985751
    986752        const Identifier& identifier() const JSC_FAST_CALL { return m_ident; }
    987753
    988754    private:
     755        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     756
    989757        Identifier m_ident;
    990758    };
    … …  
    992760    class TypeOfValueNode : public ExpressionNode {
    993761    public:
    994         TypeOfValueNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    995             : ExpressionNode(globalData, ResultType::stringType())
    996             , m_expr(expr)
    997         {
    998         }
     762        TypeOfValueNode(JSGlobalData*, ExpressionNode*);
    999763
    1000764        virtual ~TypeOfValueNode();
    1001765        virtual void releaseNodes(NodeReleaser&);
    1002766
    1003         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1004 
    1005     private:
     767    private:
     768        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     769
    1006770        RefPtr<ExpressionNode> m_expr;
    1007771    };
    … …  
    1009773    class PrefixResolveNode : public PrePostResolveNode {
    1010774    public:
    1011         PrefixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1012             : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset)
    1013             , m_operator(oper)
    1014         {
    1015         }
    1016 
    1017         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1018 
    1019     private:
     775        PrefixResolveNode(JSGlobalData*, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
     776
     777    private:
     778        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     779
    1020780        Operator m_operator;
    1021781    };
    … …  
    1023783    class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
    1024784    public:
    1025         PrefixBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1026             : ExpressionNode(globalData)
    1027             , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
    1028             , m_base(base)
    1029             , m_subscript(subscript)
    1030             , m_operator(oper)
    1031         {
    1032         }
    1033 
     785        PrefixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    1034786        virtual ~PrefixBracketNode();
    1035787        virtual void releaseNodes(NodeReleaser&);
    1036788
    1037         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1038 
    1039     private:
     789    private:
     790        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     791
    1040792        RefPtr<ExpressionNode> m_base;
    1041793        RefPtr<ExpressionNode> m_subscript;
    … …  
    1045797    class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
    1046798    public:
    1047         PrefixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1048             : ExpressionNode(globalData)
    1049             , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset)
    1050             , m_base(base)
    1051             , m_ident(ident)
    1052             , m_operator(oper)
    1053         {
    1054         }
     799        PrefixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    1055800
    1056801        virtual ~PrefixDotNode();
    1057802        virtual void releaseNodes(NodeReleaser&);
    1058803
    1059         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1060 
    1061     private:
     804    private:
     805        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     806
    1062807        RefPtr<ExpressionNode> m_base;
    1063808        Identifier m_ident;
    … …  
    1067812    class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {
    1068813    public:
    1069         PrefixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1070             : ExpressionNode(globalData)
    1071             , ThrowableExpressionData(divot, startOffset, endOffset)
    1072             , m_expr(expr)
    1073             , m_operator(oper)
    1074         {
    1075         }
     814        PrefixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
    1076815
    1077816        virtual ~PrefixErrorNode();
    1078817        virtual void releaseNodes(NodeReleaser&);
    1079818
    1080         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1081 
    1082     private:
     819    private:
     820        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     821
    1083822        RefPtr<ExpressionNode> m_expr;
    1084823        Operator m_operator;
    … …  
    1087826    class UnaryOpNode : public ExpressionNode {
    1088827    public:
    1089         UnaryOpNode(JSGlobalData* globalData, ExpressionNode* expr)
    1090             : ExpressionNode(globalData)
    1091             , m_expr(expr)
    1092         {
    1093         }
    1094 
    1095         UnaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr)
    1096             : ExpressionNode(globalData, type)
    1097             , m_expr(expr)
    1098         {
    1099         }
    1100 
     828        UnaryOpNode(JSGlobalData*, ResultType, ExpressionNode*, OpcodeID);
    1101829        virtual ~UnaryOpNode();
    1102830        virtual void releaseNodes(NodeReleaser&);
    1103831
    1104         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1105         virtual OpcodeID opcodeID() const JSC_FAST_CALL = 0;
    1106 
    1107832    protected:
     833        ExpressionNode* expr() { return m_expr.get(); }
     834
     835    private:
     836        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     837
     838        OpcodeID opcodeID() const { return m_opcodeID; }
     839
    1108840        RefPtr<ExpressionNode> m_expr;
     841        OpcodeID m_opcodeID;
    1109842    };
    1110843
    1111844    class UnaryPlusNode : public UnaryOpNode {
    1112845    public:
    1113         UnaryPlusNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1114             : UnaryOpNode(globalData, ResultType::numberType(), expr)
    1115         {
    1116         }
    1117 
    1118         virtual ExpressionNode* stripUnaryPlus() { return m_expr.get(); }
    1119 
    1120         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_to_jsnumber; }
     846        UnaryPlusNode(JSGlobalData*, ExpressionNode*);
     847
     848    private:
     849        virtual ExpressionNode* stripUnaryPlus() { return expr(); }
    1121850    };
    1122851
    1123852    class NegateNode : public UnaryOpNode {
    1124853    public:
    1125         NegateNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1126             : UnaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr)
    1127         {
    1128         }
    1129 
    1130         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_negate; }
     854        NegateNode(JSGlobalData*, ExpressionNode*);
    1131855    };
    1132856
    1133857    class BitwiseNotNode : public UnaryOpNode {
    1134858    public:
    1135         BitwiseNotNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1136             : UnaryOpNode(globalData, ResultType::forBitOp(), expr)
    1137         {
    1138         }
    1139 
    1140         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitnot; }
     859        BitwiseNotNode(JSGlobalData*, ExpressionNode*);
    1141860    };
    1142861
    1143862    class LogicalNotNode : public UnaryOpNode {
    1144863    public:
    1145         LogicalNotNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1146             : UnaryOpNode(globalData, ResultType::booleanType(), expr)
    1147         {
    1148         }
    1149 
    1150         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_not; }
     864        LogicalNotNode(JSGlobalData*, ExpressionNode*);
    1151865    };
    1152866
    1153867    class BinaryOpNode : public ExpressionNode {
    1154868    public:
    1155         BinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1156             : ExpressionNode(globalData)
    1157             , m_expr1(expr1)
    1158             , m_expr2(expr2)
    1159             , m_rightHasAssignments(rightHasAssignments)
    1160         {
    1161         }
    1162 
    1163         BinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1164             : ExpressionNode(globalData, type)
    1165             , m_expr1(expr1)
    1166             , m_expr2(expr2)
    1167             , m_rightHasAssignments(rightHasAssignments)
    1168         {
    1169         }
    1170 
     869        BinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
     870        BinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
    1171871        virtual ~BinaryOpNode();
    1172872        virtual void releaseNodes(NodeReleaser&);
    1173873
    1174         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1175         virtual OpcodeID opcodeID() const JSC_FAST_CALL = 0;
     874    private:
     875        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     876
     877    protected:
     878        OpcodeID opcodeID() const { return m_opcodeID; }
    1176879
    1177880    protected:
    1178881        RefPtr<ExpressionNode> m_expr1;
    1179882        RefPtr<ExpressionNode> m_expr2;
     883    private:
     884        OpcodeID m_opcodeID;
     885    protected:
    1180886        bool m_rightHasAssignments;
    1181887    };
    … …  
    1183889    class ReverseBinaryOpNode : public BinaryOpNode {
    1184890    public:
    1185         ReverseBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1186             : BinaryOpNode(globalData, expr1, expr2, rightHasAssignments)
    1187         {
    1188         }
    1189 
    1190         ReverseBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    1191             : BinaryOpNode(globalData, type, expr1, expr2, rightHasAssignments)
    1192         {
    1193         }
     891        ReverseBinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
     892        ReverseBinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
    1194893
    1195894        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    … …  
    1198897    class MultNode : public BinaryOpNode {
    1199898    public:
    1200         MultNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1201             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1202         {
    1203         }
    1204 
    1205         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_mul; }
     899        MultNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1206900    };
    1207901
    1208902    class DivNode : public BinaryOpNode {
    1209903    public:
    1210         DivNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1211             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1212         {
    1213         }
    1214 
    1215         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_div; }
     904        DivNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1216905    };
    1217906
    1218907    class ModNode : public BinaryOpNode {
    1219908    public:
    1220         ModNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1221             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1222         {
    1223         }
    1224 
    1225         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_mod; }
     909        ModNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1226910    };
    1227911
    1228912    class AddNode : public BinaryOpNode {
    1229913    public:
    1230         AddNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1231             : BinaryOpNode(globalData, ResultType::forAdd(expr1->resultDescriptor(), expr2->resultDescriptor()), expr1, expr2, rightHasAssignments)
    1232         {
    1233         }
    1234 
    1235         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_add; }
     914        AddNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1236915    };
    1237916
    1238917    class SubNode : public BinaryOpNode {
    1239918    public:
    1240         SubNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1241             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1242         {
    1243         }
    1244 
    1245         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_sub; }
     919        SubNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1246920    };
    1247921
    1248922    class LeftShiftNode : public BinaryOpNode {
    1249923    public:
    1250         LeftShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1251             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1252         {
    1253         }
    1254 
    1255         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lshift; }
     924        LeftShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1256925    };
    1257926
    1258927    class RightShiftNode : public BinaryOpNode {
    1259928    public:
    1260         RightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1261             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1262         {
    1263         }
    1264 
    1265         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_rshift; }
     929        RightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1266930    };
    1267931
    1268932    class UnsignedRightShiftNode : public BinaryOpNode {
    1269933    public:
    1270         UnsignedRightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1271             : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments)
    1272         {
    1273         }
    1274 
    1275         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_urshift; }
     934        UnsignedRightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1276935    };
    1277936
    1278937    class LessNode : public BinaryOpNode {
    1279938    public:
    1280         LessNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1281             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1282         {
    1283         }
    1284 
    1285         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_less; }
     939        LessNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1286940    };
    1287941
    1288942    class GreaterNode : public ReverseBinaryOpNode {
    1289943    public:
    1290         GreaterNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1291             : ReverseBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1292         {
    1293         }
    1294 
    1295         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_less; }
     944        GreaterNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1296945    };
    1297946
    1298947    class LessEqNode : public BinaryOpNode {
    1299948    public:
    1300         LessEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1301             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1302         {
    1303         }
    1304 
    1305         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lesseq; }
     949        LessEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1306950    };
    1307951
    1308952    class GreaterEqNode : public ReverseBinaryOpNode {
    1309953    public:
    1310         GreaterEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1311             : ReverseBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1312         {
    1313         }
    1314 
    1315         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lesseq; }
     954        GreaterEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1316955    };
    1317956
    1318957    class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
    1319958    public:
    1320         ThrowableBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1321             : BinaryOpNode(globalData, type, expr1, expr2, rightHasAssignments)
    1322         {
    1323         }
    1324         ThrowableBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1325             : BinaryOpNode(globalData, expr1, expr2, rightHasAssignments)
    1326         {
    1327         }
     959        ThrowableBinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
     960        ThrowableBinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
     961
     962    private:
    1328963        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1329964    };
    … …  
    1331966    class InstanceOfNode : public ThrowableBinaryOpNode {
    1332967    public:
    1333         InstanceOfNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1334             : ThrowableBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1335         {
    1336         }
    1337 
    1338         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_instanceof; }
    1339 
     968        InstanceOfNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     969
     970    private:
    1340971        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1341972    };
    … …  
    1343974    class InNode : public ThrowableBinaryOpNode {
    1344975    public:
    1345         InNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1346             : ThrowableBinaryOpNode(globalData, expr1, expr2, rightHasAssignments)
    1347         {
    1348         }
    1349 
    1350         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_in; }
     976        InNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1351977    };
    1352978
    1353979    class EqualNode : public BinaryOpNode {
    1354980    public:
    1355         EqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1356             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1357         {
    1358         }
    1359 
    1360         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1361         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_eq; }
     981        EqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     982
     983    private:
     984        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1362985    };
    1363986
    1364987    class NotEqualNode : public BinaryOpNode {
    1365988    public:
    1366         NotEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1367             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1368         {
    1369         }
    1370 
    1371         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_neq; }
     989        NotEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    1372990    };
    1373991
    1374992    class StrictEqualNode : public BinaryOpNode {
    1375993    public:
    1376         StrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1377             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1378         {
    1379         }
    1380 
    1381         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1382         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_stricteq; }
     994        StrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     995
     996    private:
     997        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1383998    };
    1384999
    13851000    class NotStrictEqualNode : public BinaryOpNode {
    13861001    public:
    1387         NotStrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1388             : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments)
    1389         {
    1390         }
    1391 
    1392         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_nstricteq; }
     1002        NotStrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    13931003    };
    13941004
    13951005    class BitAndNode : public BinaryOpNode {
    13961006    public:
    1397         BitAndNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1398             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1399         {
    1400         }
    1401 
    1402         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitand; }
     1007        BitAndNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    14031008    };
    14041009
    14051010    class BitOrNode : public BinaryOpNode {
    14061011    public:
    1407         BitOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1408             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1409         {
    1410         }
    1411 
    1412         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitor; }
     1012        BitOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
    14131013    };
    14141014
    14151015    class BitXOrNode : public BinaryOpNode {
    14161016    public:
    1417         BitXOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL
    1418             : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments)
    1419         {
    1420         }
    1421 
    1422         virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitxor; }
    1423     };
    1424 
    1425     /**
    1426      * m_expr1 && m_expr2, m_expr1 || m_expr2
    1427      */
     1017        BitXOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
     1018    };
     1019
     1020    // m_expr1 && m_expr2, m_expr1 || m_expr2
    14281021    class LogicalOpNode : public ExpressionNode {
    14291022    public:
    1430         LogicalOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator oper) JSC_FAST_CALL
    1431             : ExpressionNode(globalData, ResultType::booleanType())
    1432             , m_expr1(expr1)
    1433             , m_expr2(expr2)
    1434             , m_operator(oper)
    1435         {
    1436         }
    1437 
     1023        LogicalOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);
    14381024        virtual ~LogicalOpNode();
    14391025        virtual void releaseNodes(NodeReleaser&);
    14401026
    1441         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1442 
    1443     private:
     1027    private:
     1028        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1029
    14441030        RefPtr<ExpressionNode> m_expr1;
    14451031        RefPtr<ExpressionNode> m_expr2;
    … …  
    14471033    };
    14481034
    1449     /**
    1450      * The ternary operator, "m_logical ? m_expr1 : m_expr2"
    1451      */
     1035    // The ternary operator, "m_logical ? m_expr1 : m_expr2"
    14521036    class ConditionalNode : public ExpressionNode {
    14531037    public:
    1454         ConditionalNode(JSGlobalData* globalData, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL
    1455             : ExpressionNode(globalData)
    1456             , m_logical(logical)
    1457             , m_expr1(expr1)
    1458             , m_expr2(expr2)
    1459         {
    1460         }
    1461 
     1038        ConditionalNode(JSGlobalData*, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);
    14621039        virtual ~ConditionalNode();
    14631040        virtual void releaseNodes(NodeReleaser&);
    14641041
    1465         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1466 
    1467     private:
     1042    private:
     1043        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1044
    14681045        RefPtr<ExpressionNode> m_logical;
    14691046        RefPtr<ExpressionNode> m_expr1;
    … …  
    14731050    class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
    14741051    public:
    1475         ReadModifyResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1476             : ExpressionNode(globalData)
    1477             , ThrowableExpressionData(divot, startOffset, endOffset)
    1478             , m_ident(ident)
    1479             , m_right(right)
    1480             , m_operator(oper)
    1481             , m_rightHasAssignments(rightHasAssignments)
    1482         {
    1483         }
    1484 
     1052        ReadModifyResolveNode(JSGlobalData*, const Identifier&, Operator, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
    14851053        virtual ~ReadModifyResolveNode();
    14861054        virtual void releaseNodes(NodeReleaser&);
    14871055
    1488         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1489 
    1490     private:
     1056    private:
     1057        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1058
    14911059        Identifier m_ident;
    14921060        RefPtr<ExpressionNode> m_right;
    14931061        size_t m_index; // Used by ReadModifyLocalVarNode.
    1494         Operator m_operator : 31;
    1495         bool m_rightHasAssignments : 1;
     1062        Operator m_operator;
     1063        bool m_rightHasAssignments;
    14961064    };
    14971065
    14981066    class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
    14991067    public:
    1500         AssignResolveNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) JSC_FAST_CALL
    1501             : ExpressionNode(globalData)
    1502             , m_ident(ident)
    1503             , m_right(right)
    1504             , m_rightHasAssignments(rightHasAssignments)
    1505         {
    1506         }
    1507 
     1068        AssignResolveNode(JSGlobalData*, const Identifier&, ExpressionNode* right, bool rightHasAssignments);
    15081069        virtual ~AssignResolveNode();
    15091070        virtual void releaseNodes(NodeReleaser&);
    15101071
    1511         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1512 
    1513     private:
     1072    private:
     1073        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1074
    15141075        Identifier m_ident;
    15151076        RefPtr<ExpressionNode> m_right;
    … …  
    15201081    class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
    15211082    public:
    1522         ReadModifyBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1523             : ExpressionNode(globalData)
    1524             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    1525             , m_base(base)
    1526             , m_subscript(subscript)
    1527             , m_right(right)
    1528             , m_operator(oper)
    1529             , m_subscriptHasAssignments(subscriptHasAssignments)
    1530             , m_rightHasAssignments(rightHasAssignments)
    1531         {
    1532         }
    1533 
     1083        ReadModifyBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
    15341084        virtual ~ReadModifyBracketNode();
    15351085        virtual void releaseNodes(NodeReleaser&);
    15361086
    1537         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1538 
    1539     private:
     1087    private:
     1088        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1089
    15401090        RefPtr<ExpressionNode> m_base;
    15411091        RefPtr<ExpressionNode> m_subscript;
    … …  
    15481098    class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
    15491099    public:
    1550         AssignBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1551             : ExpressionNode(globalData)
    1552             , ThrowableExpressionData(divot, startOffset, endOffset)
    1553             , m_base(base)
    1554             , m_subscript(subscript)
    1555             , m_right(right)
    1556             , m_subscriptHasAssignments(subscriptHasAssignments)
    1557             , m_rightHasAssignments(rightHasAssignments)
    1558         {
    1559         }
    1560 
     1100        AssignBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
    15611101        virtual ~AssignBracketNode();
    15621102        virtual void releaseNodes(NodeReleaser&);
    15631103
    1564         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1565 
    1566     private:
     1104    private:
     1105        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1106
    15671107        RefPtr<ExpressionNode> m_base;
    15681108        RefPtr<ExpressionNode> m_subscript;
    … …  
    15741114    class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
    15751115    public:
    1576         AssignDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1577             : ExpressionNode(globalData)
    1578             , ThrowableExpressionData(divot, startOffset, endOffset)
    1579             , m_base(base)
    1580             , m_ident(ident)
    1581             , m_right(right)
    1582             , m_rightHasAssignments(rightHasAssignments)
    1583         {
    1584         }
    1585 
     1116        AssignDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
    15861117        virtual ~AssignDotNode();
    15871118        virtual void releaseNodes(NodeReleaser&);
    15881119
    1589         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1590 
    1591     private:
     1120    private:
     1121        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1122
    15921123        RefPtr<ExpressionNode> m_base;
    15931124        Identifier m_ident;
    … …  
    15981129    class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
    15991130    public:
    1600         ReadModifyDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1601             : ExpressionNode(globalData)
    1602             , ThrowableSubExpressionData(divot, startOffset, endOffset)
    1603             , m_base(base)
    1604             , m_ident(ident)
    1605             , m_right(right)
    1606             , m_operator(oper)
    1607             , m_rightHasAssignments(rightHasAssignments)
    1608         {
    1609         }
    1610 
     1131        ReadModifyDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
    16111132        virtual ~ReadModifyDotNode();
    16121133        virtual void releaseNodes(NodeReleaser&);
    16131134
    1614         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1615 
    1616     private:
     1135    private:
     1136        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1137
    16171138        RefPtr<ExpressionNode> m_base;
    16181139        Identifier m_ident;
    … …  
    16241145    class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
    16251146    public:
    1626         AssignErrorNode(JSGlobalData* globalData, ExpressionNode* left, Operator oper, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL
    1627             : ExpressionNode(globalData)
    1628             , ThrowableExpressionData(divot, startOffset, endOffset)
    1629             , m_left(left)
    1630             , m_operator(oper)
    1631             , m_right(right)
    1632         {
    1633         }
    1634 
     1147        AssignErrorNode(JSGlobalData*, ExpressionNode* left, Operator, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset);
    16351148        virtual ~AssignErrorNode();
    16361149        virtual void releaseNodes(NodeReleaser&);
    16371150
    1638         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1639 
    1640     private:
     1151    private:
     1152        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1153
    16411154        RefPtr<ExpressionNode> m_left;
    16421155        Operator m_operator;
    … …  
    16461159    class CommaNode : public ExpressionNode {
    16471160    public:
    1648         CommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL
    1649             : ExpressionNode(globalData)
    1650             , m_expr1(expr1)
    1651             , m_expr2(expr2)
    1652         {
    1653         }
    1654 
     1161        CommaNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2);
    16551162        virtual ~CommaNode();
    16561163        virtual void releaseNodes(NodeReleaser&);
    16571164
    1658         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1659 
    1660     private:
     1165    private:
     1166        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1167
    16611168        RefPtr<ExpressionNode> m_expr1;
    16621169        RefPtr<ExpressionNode> m_expr2;
    … …  
    16651172    class VarDeclCommaNode : public CommaNode {
    16661173    public:
    1667         VarDeclCommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL
    1668             : CommaNode(globalData, expr1, expr2)
    1669         {
    1670         }
     1174        VarDeclCommaNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2);
    16711175    };
    16721176
    16731177    class ConstDeclNode : public ExpressionNode {
    16741178    public:
    1675         ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in) JSC_FAST_CALL;
    1676 
     1179        ConstDeclNode(JSGlobalData*, const Identifier&, ExpressionNode*);
    16771180        virtual ~ConstDeclNode();
    16781181        virtual void releaseNodes(NodeReleaser&);
    16791182
     1183        bool hasInitializer() const { return m_init; }
     1184        const Identifier& ident() { return m_ident; }
     1185
     1186    private:
     1187        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1188        virtual RegisterID* emitCodeSingle(BytecodeGenerator&) JSC_FAST_CALL;
     1189
    16801190        Identifier m_ident;
     1191
     1192    public:
    16811193        RefPtr<ConstDeclNode> m_next;
     1194
     1195    private:
    16821196        RefPtr<ExpressionNode> m_init;
    1683        
    1684         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1685         virtual RegisterID* emitCodeSingle(BytecodeGenerator&) JSC_FAST_CALL;
    16861197    };
    16871198
    16881199    class ConstStatementNode : public StatementNode {
    16891200    public:
    1690         ConstStatementNode(JSGlobalData* globalData, ConstDeclNode* next) JSC_FAST_CALL
    1691             : StatementNode(globalData)
    1692             , m_next(next)
    1693         {
    1694         }
    1695 
     1201        ConstStatementNode(JSGlobalData*, ConstDeclNode* next);
    16961202        virtual ~ConstStatementNode();
    16971203        virtual void releaseNodes(NodeReleaser&);
    16981204
    1699         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1700 
    1701     private:
     1205    private:
     1206        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1207
    17021208        RefPtr<ConstDeclNode> m_next;
    17031209    };
    … …  
    17071213    class SourceElements : public ParserRefCounted {
    17081214    public:
    1709         SourceElements(JSGlobalData* globalData) : ParserRefCounted(globalData) {}
     1215        SourceElements(JSGlobalData*);
    17101216
    17111217        void append(PassRefPtr<StatementNode>);
    … …  
    17231229    class BlockNode : public StatementNode {
    17241230    public:
    1725         BlockNode(JSGlobalData*, SourceElements* children) JSC_FAST_CALL;
     1231        BlockNode(JSGlobalData*, SourceElements* children);
    17261232
    17271233        virtual ~BlockNode();
    17281234        virtual void releaseNodes(NodeReleaser&);
    17291235
    1730         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1731 
    17321236        StatementVector& children() { return m_children; }
    17331237
     1238    private:
     1239        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1240
    17341241        virtual bool isBlock() const JSC_FAST_CALL { return true; }
    17351242
    1736     private:
    17371243        StatementVector m_children;
    17381244    };
    … …  
    17401246    class EmptyStatementNode : public StatementNode {
    17411247    public:
    1742         EmptyStatementNode(JSGlobalData* globalData) JSC_FAST_CALL // debug
    1743             : StatementNode(globalData)
    1744         {
    1745         }
    1746 
     1248        EmptyStatementNode(JSGlobalData*);
     1249
     1250    private:
    17471251        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    17481252
    … …  
    17521256    class DebuggerStatementNode : public StatementNode {
    17531257    public:
    1754         DebuggerStatementNode(JSGlobalData* globalData) JSC_FAST_CALL
    1755             : StatementNode(globalData)
    1756         {
    1757         }
     1258        DebuggerStatementNode(JSGlobalData*);
    17581259       
     1260    private:
    17591261        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    17601262    };
    … …  
    17621264    class ExprStatementNode : public StatementNode {
    17631265    public:
    1764         ExprStatementNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1765             : StatementNode(globalData)
    1766             , m_expr(expr)
    1767         {
    1768         }
    1769 
     1266        ExprStatementNode(JSGlobalData*, ExpressionNode*);
     1267
     1268        ExpressionNode* expr() const { return m_expr.get(); }
     1269
     1270    private:
    17701271        virtual bool isExprStatement() const JSC_FAST_CALL { return true; }
    17711272
    17721273        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    17731274
    1774         ExpressionNode* expr() const { return m_expr.get(); }
    1775 
    1776     private:
    17771275        RefPtr<ExpressionNode> m_expr;
    17781276    };
    … …  
    17801278    class VarStatementNode : public StatementNode {
    17811279    public:
    1782         VarStatementNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    1783             : StatementNode(globalData)
    1784             , m_expr(expr)
    1785         {
    1786         }
    1787        
     1280        VarStatementNode(JSGlobalData*, ExpressionNode*);       
    17881281        virtual ~VarStatementNode();
    17891282        virtual void releaseNodes(NodeReleaser&);
    17901283
    1791         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1792 
    1793     private:
     1284    private:
     1285        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1286
    17941287        RefPtr<ExpressionNode> m_expr;
    17951288    };
    … …  
    17971290    class IfNode : public StatementNode {
    17981291    public:
    1799         IfNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock) JSC_FAST_CALL
    1800             : StatementNode(globalData)
    1801             , m_condition(condition)
    1802             , m_ifBlock(ifBlock)
    1803         {
    1804         }
    1805 
     1292        IfNode(JSGlobalData*, ExpressionNode* condition, StatementNode* ifBlock);
    18061293        virtual ~IfNode();
    18071294        virtual void releaseNodes(NodeReleaser&);
    18081295
    1809         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1810 
    18111296    protected:
     1297        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1298
    18121299        RefPtr<ExpressionNode> m_condition;
    18131300        RefPtr<StatementNode> m_ifBlock;
    … …  
    18161303    class IfElseNode : public IfNode {
    18171304    public:
    1818         IfElseNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock) JSC_FAST_CALL
    1819             : IfNode(globalData, condition, ifBlock)
    1820             , m_elseBlock(elseBlock)
    1821         {
    1822         }
    1823 
     1305        IfElseNode(JSGlobalData*, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
    18241306        virtual ~IfElseNode();
    18251307        virtual void releaseNodes(NodeReleaser&);
    18261308
    1827         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1828 
    1829     private:
     1309    private:
     1310        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1311
    18301312        RefPtr<StatementNode> m_elseBlock;
    18311313    };
    … …  
    18331315    class DoWhileNode : public StatementNode {
    18341316    public:
    1835         DoWhileNode(JSGlobalData* globalData, StatementNode* statement, ExpressionNode* expr) JSC_FAST_CALL
    1836             : StatementNode(globalData)
    1837             , m_statement(statement)
    1838             , m_expr(expr)
    1839         {
    1840         }
    1841 
     1317        DoWhileNode(JSGlobalData*, StatementNode* statement, ExpressionNode*);
    18421318        virtual ~DoWhileNode();
    18431319        virtual void releaseNodes(NodeReleaser&);
    18441320
    1845         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1846 
    1847     private:
     1321    private:
     1322        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1323
    18481324        RefPtr<StatementNode> m_statement;
    18491325        RefPtr<ExpressionNode> m_expr;
    … …  
    18521328    class WhileNode : public StatementNode {
    18531329    public:
    1854         WhileNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement) JSC_FAST_CALL
    1855             : StatementNode(globalData)
    1856             , m_expr(expr)
    1857             , m_statement(statement)
    1858         {
    1859         }
    1860 
     1330        WhileNode(JSGlobalData*, ExpressionNode*, StatementNode* statement);
    18611331        virtual ~WhileNode();
    18621332        virtual void releaseNodes(NodeReleaser&);
    18631333
    1864         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1865 
    1866     private:
     1334    private:
     1335        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1336
    18671337        RefPtr<ExpressionNode> m_expr;
    18681338        RefPtr<StatementNode> m_statement;
    … …  
    18711341    class ForNode : public StatementNode {
    18721342    public:
    1873         ForNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) JSC_FAST_CALL
    1874             : StatementNode(globalData)
    1875             , m_expr1(expr1)
    1876             , m_expr2(expr2)
    1877             , m_expr3(expr3)
    1878             , m_statement(statement)
    1879             , m_expr1WasVarDecl(expr1 && expr1WasVarDecl)
    1880         {
    1881             ASSERT(statement);
    1882         }
    1883 
     1343        ForNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl);
    18841344        virtual ~ForNode();
    18851345        virtual void releaseNodes(NodeReleaser&);
    18861346
    1887         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1888 
    1889     private:
     1347    private:
     1348        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1349
    18901350        RefPtr<ExpressionNode> m_expr1;
    18911351        RefPtr<ExpressionNode> m_expr2;
    … …  
    18971357    class ForInNode : public StatementNode, public ThrowableExpressionData {
    18981358    public:
    1899         ForInNode(JSGlobalData*, ExpressionNode*, ExpressionNode*, StatementNode*) JSC_FAST_CALL;
    1900         ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset) JSC_FAST_CALL;
    1901        
     1359        ForInNode(JSGlobalData*, ExpressionNode*, ExpressionNode*, StatementNode*);
     1360        ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset);
    19021361        virtual ~ForInNode();
    19031362        virtual void releaseNodes(NodeReleaser&);
    19041363
    1905         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1906 
    1907     private:
     1364    private:
     1365        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1366
    19081367        Identifier m_ident;
    19091368        RefPtr<ExpressionNode> m_init;
    … …  
    19161375    class ContinueNode : public StatementNode, public ThrowableExpressionData {
    19171376    public:
    1918         ContinueNode(JSGlobalData* globalData) JSC_FAST_CALL
    1919             : StatementNode(globalData)
    1920         {
    1921         }
    1922 
    1923         ContinueNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL
    1924             : StatementNode(globalData)
    1925             , m_ident(ident)
    1926         {
    1927         }
     1377        ContinueNode(JSGlobalData*);
     1378        ContinueNode(JSGlobalData*, const Identifier&);
    19281379       
    1929         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1930 
    1931     private:
     1380    private:
     1381        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1382
    19321383        Identifier m_ident;
    19331384    };
    … …  
    19351386    class BreakNode : public StatementNode, public ThrowableExpressionData {
    19361387    public:
    1937         BreakNode(JSGlobalData* globalData) JSC_FAST_CALL
    1938             : StatementNode(globalData)
    1939         {
    1940         }
    1941 
    1942         BreakNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL
    1943             : StatementNode(globalData)
    1944             , m_ident(ident)
    1945         {
    1946         }
     1388        BreakNode(JSGlobalData*);
     1389        BreakNode(JSGlobalData*, const Identifier&);
    19471390       
    1948         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1949 
    1950     private:
     1391    private:
     1392        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1393
    19511394        Identifier m_ident;
    19521395    };
    … …  
    19541397    class ReturnNode : public StatementNode, public ThrowableExpressionData {
    19551398    public:
    1956         ReturnNode(JSGlobalData* globalData, ExpressionNode* value) JSC_FAST_CALL
    1957             : StatementNode(globalData)
    1958             , m_value(value)
    1959         {
    1960         }
    1961 
     1399        ReturnNode(JSGlobalData*, ExpressionNode* value);
    19621400        virtual ~ReturnNode();
    19631401        virtual void releaseNodes(NodeReleaser&);
    19641402
    1965         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1403    private:
     1404        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1405
    19661406        virtual bool isReturnNode() const JSC_FAST_CALL { return true; }
    19671407
    1968     private:
    19691408        RefPtr<ExpressionNode> m_value;
    19701409    };
    … …  
    19721411    class WithNode : public StatementNode {
    19731412    public:
    1974         WithNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement, uint32_t divot, uint32_t expressionLength) JSC_FAST_CALL
    1975             : StatementNode(globalData)
    1976             , m_expr(expr)
    1977             , m_statement(statement)
    1978             , m_divot(divot)
    1979             , m_expressionLength(expressionLength)
    1980         {
    1981         }
    1982 
     1413        WithNode(JSGlobalData*, ExpressionNode*, StatementNode*, uint32_t divot, uint32_t expressionLength);
    19831414        virtual ~WithNode();
    19841415        virtual void releaseNodes(NodeReleaser&);
    19851416
    1986         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    1987 
    1988     private:
     1417    private:
     1418        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1419
    19891420        RefPtr<ExpressionNode> m_expr;
    19901421        RefPtr<StatementNode> m_statement;
    … …  
    19951426    class LabelNode : public StatementNode, public ThrowableExpressionData {
    19961427    public:
    1997         LabelNode(JSGlobalData* globalData, const Identifier& name, StatementNode* statement) JSC_FAST_CALL
    1998             : StatementNode(globalData)
    1999             , m_name(name)
    2000             , m_statement(statement)
    2001         {
    2002         }
    2003 
     1428        LabelNode(JSGlobalData*, const Identifier& name, StatementNode*);
    20041429        virtual ~LabelNode();
    20051430        virtual void releaseNodes(NodeReleaser&);
    20061431
    2007         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2008 
    2009     private:
     1432    private:
     1433        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1434
    20101435        Identifier m_name;
    20111436        RefPtr<StatementNode> m_statement;
    … …  
    20141439    class ThrowNode : public StatementNode, public ThrowableExpressionData {
    20151440    public:
    2016         ThrowNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    2017             : StatementNode(globalData)
    2018             , m_expr(expr)
    2019         {
    2020         }
    2021 
     1441        ThrowNode(JSGlobalData*, ExpressionNode*);
    20221442        virtual ~ThrowNode();
    20231443        virtual void releaseNodes(NodeReleaser&);
    20241444
    2025         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2026 
    2027     private:
     1445    private:
     1446        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1447
    20281448        RefPtr<ExpressionNode> m_expr;
    20291449    };
    … …  
    20311451    class TryNode : public StatementNode {
    20321452    public:
    2033         TryNode(JSGlobalData* globalData, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock) JSC_FAST_CALL
    2034             : StatementNode(globalData)
    2035             , m_tryBlock(tryBlock)
    2036             , m_exceptionIdent(exceptionIdent)
    2037             , m_catchBlock(catchBlock)
    2038             , m_finallyBlock(finallyBlock)
    2039             , m_catchHasEval(catchHasEval)
    2040         {
    2041         }
    2042 
     1453        TryNode(JSGlobalData*, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock);
    20431454        virtual ~TryNode();
    20441455        virtual void releaseNodes(NodeReleaser&);
    20451456
     1457    private:
    20461458        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* dst = 0) JSC_FAST_CALL;
    20471459
    2048     private:
    20491460        RefPtr<StatementNode> m_tryBlock;
    20501461        Identifier m_exceptionIdent;
    … …  
    20561467    class ParameterNode : public ParserRefCounted {
    20571468    public:
    2058         ParameterNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL
    2059             : ParserRefCounted(globalData)
    2060             , m_ident(ident)
    2061         {
    2062         }
    2063 
    2064         ParameterNode(JSGlobalData* globalData, ParameterNode* l, const Identifier& ident) JSC_FAST_CALL
    2065             : ParserRefCounted(globalData)
    2066             , m_ident(ident)
    2067         {
    2068             l->m_next = this;
    2069         }
    2070 
     1469        ParameterNode(JSGlobalData*, const Identifier&);
     1470        ParameterNode(JSGlobalData*, ParameterNode*, const Identifier&);
    20711471        virtual ~ParameterNode();
    20721472        virtual void releaseNodes(NodeReleaser&);
    … …  
    22061606        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    22071607
    2208         bool isGenerated() JSC_FAST_CALL
     1608        bool isGenerated() const
    22091609        {
    22101610            return m_code;
    22111611        }
    22121612
     1613        bool isHostFunction() const
     1614        {
    22131615#if ENABLE(JIT)
    2214         bool isHostFunction() const JSC_FAST_CALL
    2215         {
    22161616            return m_jitCode && !m_code;
     1617#else
     1618            return true;
     1619#endif
    22171620        }
    2218 #else
    2219         bool isHostFunction() const JSC_FAST_CALL
    2220         {
    2221             return true;
    2222         }
    2223 #endif
    22241621
    22251622        virtual void mark();
    … …  
    22291626       
    22301627        UString toSourceString() const JSC_FAST_CALL { return source().toString(); }
    2231 
    2232         // These objects are ref/deref'd a lot in the scope chain, so this is a faster ref/deref.
    2233         // If the virtual machine changes so this doesn't happen as much we can change back.
    2234         void ref()
    2235         {
    2236             if (++m_refCount == 1)
    2237                 ScopeNode::ref();
    2238         }
    2239         void deref()
    2240         {
    2241             ASSERT(m_refCount);
    2242             if (!--m_refCount)
    2243                 ScopeNode::deref();
    2244         }
    22451628
    22461629        CodeBlock& bytecodeForExceptionInfoReparse(ScopeChainNode*, CodeBlock*) JSC_FAST_CALL;
    … …  
    22671650        }
    22681651       
    2269         CodeBlock& generatedBytecode() JSC_FAST_CALL
     1652        CodeBlock& generatedBytecode()
    22701653        {
    22711654            ASSERT(m_code);
    … …  
    22861669        size_t m_parameterCount;
    22871670        OwnPtr<CodeBlock> m_code;
    2288         unsigned m_refCount;
    22891671    };
    22901672
    22911673    class FuncExprNode : public ExpressionNode {
    22921674    public:
    2293         FuncExprNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0) JSC_FAST_CALL
    2294             : ExpressionNode(globalData)
    2295             , m_ident(ident)
    2296             , m_parameter(parameter)
    2297             , m_body(body)
    2298         {
    2299             m_body->finishParsing(source, m_parameter.get());
    2300         }
    2301 
     1675        FuncExprNode(JSGlobalData*, const Identifier&, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0);
    23021676        virtual ~FuncExprNode();
    23031677        virtual void releaseNodes(NodeReleaser&);
    23041678
     1679        JSFunction* makeFunction(ExecState*, ScopeChainNode*) JSC_FAST_CALL;
     1680
     1681        FunctionBodyNode* body() { return m_body.get(); }
     1682
     1683    private:
     1684        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1685
    23051686        virtual bool isFuncExprNode() const JSC_FAST_CALL { return true; }
    23061687
    2307         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2308         JSFunction* makeFunction(ExecState*, ScopeChainNode*) JSC_FAST_CALL;
    2309 
    2310         FunctionBodyNode* body() { return m_body.get(); }
    2311 
    2312     private:
    23131688        Identifier m_ident;
    23141689        RefPtr<ParameterNode> m_parameter;
    … …  
    23181693    class FuncDeclNode : public StatementNode {
    23191694    public:
    2320         FuncDeclNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0) JSC_FAST_CALL
    2321             : StatementNode(globalData)
    2322             , m_ident(ident)
    2323             , m_parameter(parameter)
    2324             , m_body(body)
    2325         {
    2326             m_body->finishParsing(source, m_parameter.get());
    2327         }
    2328 
     1695        FuncDeclNode(JSGlobalData*, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
    23291696        virtual ~FuncDeclNode();
    23301697        virtual void releaseNodes(NodeReleaser&);
    23311698
    2332         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2333 
    23341699        JSFunction* makeFunction(ExecState*, ScopeChainNode*) JSC_FAST_CALL;
    23351700
    … …  
    23391704
    23401705    private:
     1706        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1707
    23411708        RefPtr<ParameterNode> m_parameter;
    23421709        RefPtr<FunctionBodyNode> m_body;
    … …  
    23451712    class CaseClauseNode : public ParserRefCounted {
    23461713    public:
    2347         CaseClauseNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL
    2348             : ParserRefCounted(globalData)
    2349             , m_expr(expr)
    2350         {
    2351         }
    2352 
    2353         CaseClauseNode(JSGlobalData* globalData, ExpressionNode* expr, SourceElements* children) JSC_FAST_CALL
    2354             : ParserRefCounted(globalData)
    2355             , m_expr(expr)
    2356         {
    2357             if (children)
    2358                 children->releaseContentsIntoVector(m_children);
    2359         }
    2360 
     1714        CaseClauseNode(JSGlobalData*, ExpressionNode*);
     1715        CaseClauseNode(JSGlobalData*, ExpressionNode*, SourceElements*);
    23611716        virtual ~CaseClauseNode();
    23621717        virtual void releaseNodes(NodeReleaser&);
    … …  
    23721727    class ClauseListNode : public ParserRefCounted {
    23731728    public:
    2374         ClauseListNode(JSGlobalData* globalData, CaseClauseNode* clause) JSC_FAST_CALL
    2375             : ParserRefCounted(globalData)
    2376             , m_clause(clause)
    2377         {
    2378         }
    2379 
    2380         ClauseListNode(JSGlobalData* globalData, ClauseListNode* clauseList, CaseClauseNode* clause) JSC_FAST_CALL
    2381             : ParserRefCounted(globalData)
    2382             , m_clause(clause)
    2383         {
    2384             clauseList->m_next = this;
    2385         }
    2386 
     1729        ClauseListNode(JSGlobalData*, CaseClauseNode*);
     1730        ClauseListNode(JSGlobalData*, ClauseListNode*, CaseClauseNode*);
    23871731        virtual ~ClauseListNode();
    23881732        virtual void releaseNodes(NodeReleaser&);
    … …  
    23981742    class CaseBlockNode : public ParserRefCounted {
    23991743    public:
    2400         CaseBlockNode(JSGlobalData* globalData, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) JSC_FAST_CALL
    2401             : ParserRefCounted(globalData)
    2402             , m_list1(list1)
    2403             , m_defaultClause(defaultClause)
    2404             , m_list2(list2)
    2405         {
    2406         }
    2407 
     1744        CaseBlockNode(JSGlobalData*, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2);
    24081745        virtual ~CaseBlockNode();
    24091746        virtual void releaseNodes(NodeReleaser&);
    … …  
    24201757    class SwitchNode : public StatementNode {
    24211758    public:
    2422         SwitchNode(JSGlobalData* globalData, ExpressionNode* expr, CaseBlockNode* block) JSC_FAST_CALL
    2423             : StatementNode(globalData)
    2424             , m_expr(expr)
    2425             , m_block(block)
    2426         {
    2427         }
    2428 
     1759        SwitchNode(JSGlobalData*, ExpressionNode*, CaseBlockNode*);
    24291760        virtual ~SwitchNode();
    24301761        virtual void releaseNodes(NodeReleaser&);
    24311762
    2432         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
    2433 
    2434     private:
     1763    private:
     1764        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL;
     1765
    24351766        RefPtr<ExpressionNode> m_expr;
    24361767        RefPtr<CaseBlockNode> m_block;
    … …  
    24691800} // namespace JSC
    24701801
    2471 #endif // NODES_H_
     1802#endif // Nodes_h
Note: See TracChangeset for help on using the changeset viewer.