1 /*

     2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)

     3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)

     4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

     5  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)

     6  *  Copyright (C) 2007 Maks Orlovich

     7  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>

     8  *

     9  *  This library is free software; you can redistribute it and/or

    10  *  modify it under the terms of the GNU Library General Public

    11  *  License as published by the Free Software Foundation; either

    12  *  version 2 of the License, or (at your option) any later version.

    13  *

    14  *  This library is distributed in the hope that it will be useful,

    15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    17  *  Library General Public License for more details.

    18  *

    19  *  You should have received a copy of the GNU Library General Public License

    20  *  along with this library; see the file COPYING.LIB.  If not, write to

    21  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    22  *  Boston, MA 02110-1301, USA.

    23  *

    24  */

    25 

    26 #ifndef Nodes_h

    27 #define Nodes_h

    28 

    29 #include "Error.h"

    30 #include "JITCode.h"

    31 #include "Opcode.h"

    32 #include "ParserArena.h"

    33 #include "ResultType.h"

    34 #include "SourceCode.h"

    35 #include "SymbolTable.h"

    36 #include <wtf/MathExtras.h>

    37 

    38 namespace JSC {

    39 

    40     class ArgumentListNode;

    41     class BytecodeGenerator;

    42     class FunctionBodyNode;

    43     class Label;

    44     class PropertyListNode;

    45     class ReadModifyResolveNode;

    46     class RegisterID;

    47     class ScopeChainNode;

    48     class ScopeNode;

    49 

    50     typedef unsigned CodeFeatures;

    51 

    52     const CodeFeatures NoFeatures = 0;

    53     const CodeFeatures EvalFeature = 1 << 0;

    54     const CodeFeatures ClosureFeature = 1 << 1;

    55     const CodeFeatures AssignFeature = 1 << 2;

    56     const CodeFeatures ArgumentsFeature = 1 << 3;

    57     const CodeFeatures WithFeature = 1 << 4;

    58     const CodeFeatures CatchFeature = 1 << 5;

    59     const CodeFeatures ThisFeature = 1 << 6;

    60     const CodeFeatures AllFeatures = EvalFeature | ClosureFeature | AssignFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature;

    61 

    62     enum Operator {

    63         OpEqual,

    64         OpPlusEq,

    65         OpMinusEq,

    66         OpMultEq,

    67         OpDivEq,

    68         OpPlusPlus,

    69         OpMinusMinus,

    70         OpAndEq,

    71         OpXOrEq,

    72         OpOrEq,

    73         OpModEq,

    74         OpLShift,

    75         OpRShift,

    76         OpURShift

    77     };

    78     

    79     enum LogicalOperator {

    80         OpLogicalAnd,

    81         OpLogicalOr

    82     };

    83 

    84     namespace DeclarationStacks {

    85         enum VarAttrs { IsConstant = 1, HasInitializer = 2 };

    86         typedef Vector<std::pair<const Identifier*, unsigned> > VarStack;

    87         typedef Vector<FunctionBodyNode*> FunctionStack;

    88     }

    89 

    90     struct SwitchInfo {

    91         enum SwitchType { SwitchNone, SwitchImmediate, SwitchCharacter, SwitchString };

    92         uint32_t bytecodeOffset;

    93         SwitchType switchType;

    94     };

    95 

    96     class ParserArenaFreeable {

    97     public:

    98         // ParserArenaFreeable objects are are freed when the arena is deleted.

    99         // Destructors are not called. Clients must not call delete on such objects.

   100         void* operator new(size_t, JSGlobalData*);

   101     };

   102 

   103     class ParserArenaDeletable {

   104     public:

   105         virtual ~ParserArenaDeletable() { }

   106 

   107         // ParserArenaDeletable objects are deleted when the arena is deleted.

   108         // Clients must not call delete directly on such objects.

   109         void* operator new(size_t, JSGlobalData*);

   110     };

   111 

   112     class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {

   113     protected:

   114         ParserArenaRefCounted(JSGlobalData*);

   115 

   116     public:

   117         virtual ~ParserArenaRefCounted()

   118         {

   119             ASSERT(deletionHasBegun());

   120         }

   121     };

   122 

   123     class Node : public ParserArenaFreeable {

   124     protected:

   125         Node(JSGlobalData*);

   126 

   127     public:

   128         virtual ~Node() { }

   129 

   130         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;

   131 

   132         int lineNo() const { return m_line; }

   133 

   134     protected:

   135         int m_line;

   136     };

   137 

   138     class ExpressionNode : public Node {

   139     protected:

   140         ExpressionNode(JSGlobalData*, ResultType = ResultType::unknownType());

   141 

   142     public:

   143         virtual bool isNumber() const { return false; }

   144         virtual bool isString() const { return false; }

   145         virtual bool isNull() const { return false; }

   146         virtual bool isPure(BytecodeGenerator&) const { return false; }        

   147         virtual bool isLocation() const { return false; }

   148         virtual bool isResolveNode() const { return false; }

   149         virtual bool isBracketAccessorNode() const { return false; }

   150         virtual bool isDotAccessorNode() const { return false; }

   151         virtual bool isFuncExprNode() const { return false; }

   152         virtual bool isCommaNode() const { return false; }

   153         virtual bool isSimpleArray() const { return false; }

   154         virtual bool isAdd() const { return false; }

   155         virtual bool isSubtract() const { return false; }

   156         virtual bool hasConditionContextCodegen() const { return false; }

   157 

   158         virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, bool) { ASSERT_NOT_REACHED(); }

   159 

   160         virtual ExpressionNode* stripUnaryPlus() { return this; }

   161 

   162         ResultType resultDescriptor() const { return m_resultType; }

   163 

   164     private:

   165         ResultType m_resultType;

   166     };

   167 

   168     class StatementNode : public Node {

   169     protected:

   170         StatementNode(JSGlobalData*);

   171 

   172     public:

   173         void setLoc(int firstLine, int lastLine);

   174         int firstLine() const { return lineNo(); }

   175         int lastLine() const { return m_lastLine; }

   176 

   177         virtual bool isEmptyStatement() const { return false; }

   178         virtual bool isReturnNode() const { return false; }

   179         virtual bool isExprStatement() const { return false; }

   180 

   181         virtual bool isBlock() const { return false; }

   182 

   183     private:

   184         int m_lastLine;

   185     };

   186 

   187     class NullNode : public ExpressionNode {

   188     public:

   189         NullNode(JSGlobalData*);

   190 

   191     private:

   192         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   193 

   194         virtual bool isNull() const { return true; }

   195     };

   196 

   197     class BooleanNode : public ExpressionNode {

   198     public:

   199         BooleanNode(JSGlobalData*, bool value);

   200 

   201     private:

   202         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   203 

   204         virtual bool isPure(BytecodeGenerator&) const { return true; }

   205 

   206         bool m_value;

   207     };

   208 

   209     class NumberNode : public ExpressionNode {

   210     public:

   211         NumberNode(JSGlobalData*, double value);

   212 

   213         double value() const { return m_value; }

   214         void setValue(double value) { m_value = value; }

   215 

   216     private:

   217         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   218 

   219         virtual bool isNumber() const { return true; }

   220         virtual bool isPure(BytecodeGenerator&) const { return true; }

   221 

   222         double m_value;

   223     };

   224 

   225     class StringNode : public ExpressionNode {

   226     public:

   227         StringNode(JSGlobalData*, const Identifier&);

   228 

   229         const Identifier& value() { return m_value; }

   230 

   231     private:

   232         virtual bool isPure(BytecodeGenerator&) const { return true; }

   233 

   234         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   235         

   236         virtual bool isString() const { return true; }

   237 

   238         const Identifier& m_value;

   239     };

   240     

   241     class ThrowableExpressionData {

   242     public:

   243         ThrowableExpressionData()

   244             : m_divot(static_cast<uint32_t>(-1))

   245             , m_startOffset(static_cast<uint16_t>(-1))

   246             , m_endOffset(static_cast<uint16_t>(-1))

   247         {

   248         }

   249         

   250         ThrowableExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

   251             : m_divot(divot)

   252             , m_startOffset(startOffset)

   253             , m_endOffset(endOffset)

   254         {

   255         }

   256         

   257         void setExceptionSourceCode(unsigned divot, unsigned startOffset, unsigned endOffset)

   258         {

   259             m_divot = divot;

   260             m_startOffset = startOffset;

   261             m_endOffset = endOffset;

   262         }

   263 

   264         uint32_t divot() const { return m_divot; }

   265         uint16_t startOffset() const { return m_startOffset; }

   266         uint16_t endOffset() const { return m_endOffset; }

   267 

   268     protected:

   269         RegisterID* emitThrowError(BytecodeGenerator&, bool isReferenceError, const char* message);

   270         RegisterID* emitThrowError(BytecodeGenerator&, bool isReferenceError, const char* message, const UString&);

   271         RegisterID* emitThrowError(BytecodeGenerator&, bool isReferenceError, const char* message, const Identifier&);

   272 

   273     private:

   274         uint32_t m_divot;

   275         uint16_t m_startOffset;

   276         uint16_t m_endOffset;

   277     };

   278 

   279     class ThrowableSubExpressionData : public ThrowableExpressionData {

   280     public:

   281         ThrowableSubExpressionData()

   282             : m_subexpressionDivotOffset(0)

   283             , m_subexpressionEndOffset(0)

   284         {

   285         }

   286 

   287         ThrowableSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

   288             : ThrowableExpressionData(divot, startOffset, endOffset)

   289             , m_subexpressionDivotOffset(0)

   290             , m_subexpressionEndOffset(0)

   291         {

   292         }

   293 

   294         void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)

   295         {

   296             ASSERT(subexpressionDivot <= divot());

   297             if ((divot() - subexpressionDivot) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot

   298                 return;

   299             m_subexpressionDivotOffset = divot() - subexpressionDivot;

   300             m_subexpressionEndOffset = subexpressionOffset;

   301         }

   302 

   303     protected:

   304         uint16_t m_subexpressionDivotOffset;

   305         uint16_t m_subexpressionEndOffset;

   306     };

   307     

   308     class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {

   309     public:

   310         ThrowablePrefixedSubExpressionData()

   311             : m_subexpressionDivotOffset(0)

   312             , m_subexpressionStartOffset(0)

   313         {

   314         }

   315 

   316         ThrowablePrefixedSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

   317             : ThrowableExpressionData(divot, startOffset, endOffset)

   318             , m_subexpressionDivotOffset(0)

   319             , m_subexpressionStartOffset(0)

   320         {

   321         }

   322 

   323         void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)

   324         {

   325             ASSERT(subexpressionDivot >= divot());

   326             if ((subexpressionDivot - divot()) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot

   327                 return;

   328             m_subexpressionDivotOffset = subexpressionDivot - divot();

   329             m_subexpressionStartOffset = subexpressionOffset;

   330         }

   331 

   332     protected:

   333         uint16_t m_subexpressionDivotOffset;

   334         uint16_t m_subexpressionStartOffset;

   335     };

   336 

   337     class RegExpNode : public ExpressionNode, public ThrowableExpressionData {

   338     public:

   339         RegExpNode(JSGlobalData*, const Identifier& pattern, const Identifier& flags);

   340 

   341     private:

   342         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   343 

   344         const Identifier& m_pattern;

   345         const Identifier& m_flags;

   346     };

   347 

   348     class ThisNode : public ExpressionNode {

   349     public:

   350         ThisNode(JSGlobalData*);

   351 

   352     private:

   353         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   354     };

   355 

   356     class ResolveNode : public ExpressionNode {

   357     public:

   358         ResolveNode(JSGlobalData*, const Identifier&, int startOffset);

   359 

   360         const Identifier& identifier() const { return m_ident; }

   361 

   362     private:

   363         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   364 

   365         virtual bool isPure(BytecodeGenerator&) const ;

   366         virtual bool isLocation() const { return true; }

   367         virtual bool isResolveNode() const { return true; }

   368 

   369         const Identifier& m_ident;

   370         int32_t m_startOffset;

   371     };

   372 

   373     class ElementNode : public ParserArenaFreeable {

   374     public:

   375         ElementNode(JSGlobalData*, int elision, ExpressionNode*);

   376         ElementNode(JSGlobalData*, ElementNode*, int elision, ExpressionNode*);

   377 

   378         int elision() const { return m_elision; }

   379         ExpressionNode* value() { return m_node; }

   380         ElementNode* next() { return m_next; }

   381 

   382     private:

   383         ElementNode* m_next;

   384         int m_elision;

   385         ExpressionNode* m_node;

   386     };

   387 

   388     class ArrayNode : public ExpressionNode {

   389     public:

   390         ArrayNode(JSGlobalData*, int elision);

   391         ArrayNode(JSGlobalData*, ElementNode*);

   392         ArrayNode(JSGlobalData*, int elision, ElementNode*);

   393 

   394         ArgumentListNode* toArgumentList(JSGlobalData*) const;

   395 

   396     private:

   397         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   398 

   399         virtual bool isSimpleArray() const ;

   400 

   401         ElementNode* m_element;

   402         int m_elision;

   403         bool m_optional;

   404     };

   405 

   406     class PropertyNode : public ParserArenaFreeable {

   407     public:

   408         enum Type { Constant = 1, Getter = 2, Setter = 4 };

   409 

   410         PropertyNode(JSGlobalData*, const Identifier& name, ExpressionNode* value, Type);

   411         PropertyNode(JSGlobalData*, double name, ExpressionNode* value, Type);

   412 

   413         const Identifier& name() const { return m_name; }

   414         Type type() const { return m_type; }

   415 

   416     private:

   417         friend class PropertyListNode;

   418         const Identifier& m_name;

   419         ExpressionNode* m_assign;

   420         Type m_type;

   421     };

   422 

   423     class PropertyListNode : public Node {

   424     public:

   425         PropertyListNode(JSGlobalData*, PropertyNode*);

   426         PropertyListNode(JSGlobalData*, PropertyNode*, PropertyListNode*);

   427 

   428         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   429 

   430     private:

   431         PropertyNode* m_node;

   432         PropertyListNode* m_next;

   433     };

   434 

   435     class ObjectLiteralNode : public ExpressionNode {

   436     public:

   437         ObjectLiteralNode(JSGlobalData*);

   438         ObjectLiteralNode(JSGlobalData*, PropertyListNode*);

   439 

   440     private:

   441         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   442 

   443         PropertyListNode* m_list;

   444     };

   445     

   446     class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {

   447     public:

   448         BracketAccessorNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);

   449 

   450         ExpressionNode* base() const { return m_base; }

   451         ExpressionNode* subscript() const { return m_subscript; }

   452 

   453     private:

   454         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   455 

   456         virtual bool isLocation() const { return true; }

   457         virtual bool isBracketAccessorNode() const { return true; }

   458 

   459         ExpressionNode* m_base;

   460         ExpressionNode* m_subscript;

   461         bool m_subscriptHasAssignments;

   462     };

   463 

   464     class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {

   465     public:

   466         DotAccessorNode(JSGlobalData*, ExpressionNode* base, const Identifier&);

   467 

   468         ExpressionNode* base() const { return m_base; }

   469         const Identifier& identifier() const { return m_ident; }

   470 

   471     private:

   472         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   473 

   474         virtual bool isLocation() const { return true; }

   475         virtual bool isDotAccessorNode() const { return true; }

   476 

   477         ExpressionNode* m_base;

   478         const Identifier& m_ident;

   479     };

   480 

   481     class ArgumentListNode : public Node {

   482     public:

   483         ArgumentListNode(JSGlobalData*, ExpressionNode*);

   484         ArgumentListNode(JSGlobalData*, ArgumentListNode*, ExpressionNode*);

   485 

   486         ArgumentListNode* m_next;

   487         ExpressionNode* m_expr;

   488 

   489     private:

   490         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   491     };

   492 

   493     class ArgumentsNode : public ParserArenaFreeable {

   494     public:

   495         ArgumentsNode(JSGlobalData*);

   496         ArgumentsNode(JSGlobalData*, ArgumentListNode*);

   497 

   498         ArgumentListNode* m_listNode;

   499     };

   500 

   501     class NewExprNode : public ExpressionNode, public ThrowableExpressionData {

   502     public:

   503         NewExprNode(JSGlobalData*, ExpressionNode*);

   504         NewExprNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*);

   505 

   506     private:

   507         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   508 

   509         ExpressionNode* m_expr;

   510         ArgumentsNode* m_args;

   511     };

   512 

   513     class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {

   514     public:

   515         EvalFunctionCallNode(JSGlobalData*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

   516 

   517     private:

   518         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   519 

   520         ArgumentsNode* m_args;

   521     };

   522 

   523     class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {

   524     public:

   525         FunctionCallValueNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

   526 

   527     private:

   528         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   529 

   530         ExpressionNode* m_expr;

   531         ArgumentsNode* m_args;

   532     };

   533 

   534     class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {

   535     public:

   536         FunctionCallResolveNode(JSGlobalData*, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

   537 

   538     private:

   539         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   540 

   541         const Identifier& m_ident;

   542         ArgumentsNode* m_args;

   543         size_t m_index; // Used by LocalVarFunctionCallNode.

   544         size_t m_scopeDepth; // Used by ScopedVarFunctionCallNode and NonLocalVarFunctionCallNode

   545     };

   546     

   547     class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {

   548     public:

   549         FunctionCallBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

   550 

   551     private:

   552         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   553 

   554         ExpressionNode* m_base;

   555         ExpressionNode* m_subscript;

   556         ArgumentsNode* m_args;

   557     };

   558 

   559     class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {

   560     public:

   561         FunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

   562 

   563     private:

   564         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   565 

   566     protected:

   567         ExpressionNode* m_base;

   568         const Identifier& m_ident;

   569         ArgumentsNode* m_args;

   570     };

   571 

   572     class CallFunctionCallDotNode : public FunctionCallDotNode {

   573     public:

   574         CallFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

   575 

   576     private:

   577         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   578     };

   579     

   580     class ApplyFunctionCallDotNode : public FunctionCallDotNode {

   581     public:

   582         ApplyFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

   583 

   584     private:

   585         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   586     };

   587 

   588     class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {

   589     public:

   590         PrePostResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);

   591 

   592     protected:

   593         const Identifier& m_ident;

   594     };

   595 

   596     class PostfixResolveNode : public PrePostResolveNode {

   597     public:

   598         PostfixResolveNode(JSGlobalData*, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

   599 

   600     private:

   601         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   602 

   603         Operator m_operator;

   604     };

   605 

   606     class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {

   607     public:

   608         PostfixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

   609 

   610     private:

   611         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   612 

   613         ExpressionNode* m_base;

   614         ExpressionNode* m_subscript;

   615         Operator m_operator;

   616     };

   617 

   618     class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {

   619     public:

   620         PostfixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

   621 

   622     private:

   623         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   624 

   625         ExpressionNode* m_base;

   626         const Identifier& m_ident;

   627         Operator m_operator;

   628     };

   629 

   630     class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {

   631     public:

   632         PostfixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

   633 

   634     private:

   635         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   636 

   637         ExpressionNode* m_expr;

   638         Operator m_operator;

   639     };

   640 

   641     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {

   642     public:

   643         DeleteResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);

   644 

   645     private:

   646         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   647 

   648         const Identifier& m_ident;

   649     };

   650 

   651     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {

   652     public:

   653         DeleteBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);

   654 

   655     private:

   656         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   657 

   658         ExpressionNode* m_base;

   659         ExpressionNode* m_subscript;

   660     };

   661 

   662     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {

   663     public:

   664         DeleteDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);

   665 

   666     private:

   667         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   668 

   669         ExpressionNode* m_base;

   670         const Identifier& m_ident;

   671     };

   672 

   673     class DeleteValueNode : public ExpressionNode {

   674     public:

   675         DeleteValueNode(JSGlobalData*, ExpressionNode*);

   676 

   677     private:

   678         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   679 

   680         ExpressionNode* m_expr;

   681     };

   682 

   683     class VoidNode : public ExpressionNode {

   684     public:

   685         VoidNode(JSGlobalData*, ExpressionNode*);

   686 

   687     private:

   688         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   689 

   690         ExpressionNode* m_expr;

   691     };

   692 

   693     class TypeOfResolveNode : public ExpressionNode {

   694     public:

   695         TypeOfResolveNode(JSGlobalData*, const Identifier&);

   696 

   697         const Identifier& identifier() const { return m_ident; }

   698 

   699     private:

   700         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   701 

   702         const Identifier& m_ident;

   703     };

   704 

   705     class TypeOfValueNode : public ExpressionNode {

   706     public:

   707         TypeOfValueNode(JSGlobalData*, ExpressionNode*);

   708 

   709     private:

   710         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   711 

   712         ExpressionNode* m_expr;

   713     };

   714 

   715     class PrefixResolveNode : public PrePostResolveNode {

   716     public:

   717         PrefixResolveNode(JSGlobalData*, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

   718 

   719     private:

   720         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   721 

   722         Operator m_operator;

   723     };

   724 

   725     class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {

   726     public:

   727         PrefixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

   728 

   729     private:

   730         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   731 

   732         ExpressionNode* m_base;

   733         ExpressionNode* m_subscript;

   734         Operator m_operator;

   735     };

   736 

   737     class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {

   738     public:

   739         PrefixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

   740 

   741     private:

   742         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   743 

   744         ExpressionNode* m_base;

   745         const Identifier& m_ident;

   746         Operator m_operator;

   747     };

   748 

   749     class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {

   750     public:

   751         PrefixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

   752 

   753     private:

   754         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   755 

   756         ExpressionNode* m_expr;

   757         Operator m_operator;

   758     };

   759 

   760     class UnaryOpNode : public ExpressionNode {

   761     public:

   762         UnaryOpNode(JSGlobalData*, ResultType, ExpressionNode*, OpcodeID);

   763 

   764     protected:

   765         ExpressionNode* expr() { return m_expr; }

   766         const ExpressionNode* expr() const { return m_expr; }

   767 

   768     private:

   769         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   770 

   771         OpcodeID opcodeID() const { return m_opcodeID; }

   772 

   773         ExpressionNode* m_expr;

   774         OpcodeID m_opcodeID;

   775     };

   776 

   777     class UnaryPlusNode : public UnaryOpNode {

   778     public:

   779         UnaryPlusNode(JSGlobalData*, ExpressionNode*);

   780 

   781     private:

   782         virtual ExpressionNode* stripUnaryPlus() { return expr(); }

   783     };

   784 

   785     class NegateNode : public UnaryOpNode {

   786     public:

   787         NegateNode(JSGlobalData*, ExpressionNode*);

   788     };

   789 

   790     class BitwiseNotNode : public UnaryOpNode {

   791     public:

   792         BitwiseNotNode(JSGlobalData*, ExpressionNode*);

   793     };

   794 

   795     class LogicalNotNode : public UnaryOpNode {

   796     public:

   797         LogicalNotNode(JSGlobalData*, ExpressionNode*);

   798     private:

   799         void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);

   800         virtual bool hasConditionContextCodegen() const { return expr()->hasConditionContextCodegen(); }

   801     };

   802 

   803     class BinaryOpNode : public ExpressionNode {

   804     public:

   805         BinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

   806         BinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

   807 

   808         RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);

   809 

   810         ExpressionNode* lhs() { return m_expr1; };

   811         ExpressionNode* rhs() { return m_expr2; };

   812 

   813     private:

   814         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   815 

   816     protected:

   817         OpcodeID opcodeID() const { return m_opcodeID; }

   818 

   819     protected:

   820         ExpressionNode* m_expr1;

   821         ExpressionNode* m_expr2;

   822     private:

   823         OpcodeID m_opcodeID;

   824     protected:

   825         bool m_rightHasAssignments;

   826     };

   827 

   828     class ReverseBinaryOpNode : public BinaryOpNode {

   829     public:

   830         ReverseBinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

   831         ReverseBinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

   832 

   833         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   834     };

   835 

   836     class MultNode : public BinaryOpNode {

   837     public:

   838         MultNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   839     };

   840 

   841     class DivNode : public BinaryOpNode {

   842     public:

   843         DivNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   844     };

   845 

   846     class ModNode : public BinaryOpNode {

   847     public:

   848         ModNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   849     };

   850 

   851     class AddNode : public BinaryOpNode {

   852     public:

   853         AddNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   854 

   855         virtual bool isAdd() const { return true; }

   856     };

   857 

   858     class SubNode : public BinaryOpNode {

   859     public:

   860         SubNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   861 

   862         virtual bool isSubtract() const { return true; }

   863     };

   864 

   865     class LeftShiftNode : public BinaryOpNode {

   866     public:

   867         LeftShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   868     };

   869 

   870     class RightShiftNode : public BinaryOpNode {

   871     public:

   872         RightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   873     };

   874 

   875     class UnsignedRightShiftNode : public BinaryOpNode {

   876     public:

   877         UnsignedRightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   878     };

   879 

   880     class LessNode : public BinaryOpNode {

   881     public:

   882         LessNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   883     };

   884 

   885     class GreaterNode : public ReverseBinaryOpNode {

   886     public:

   887         GreaterNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   888     };

   889 

   890     class LessEqNode : public BinaryOpNode {

   891     public:

   892         LessEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   893     };

   894 

   895     class GreaterEqNode : public ReverseBinaryOpNode {

   896     public:

   897         GreaterEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   898     };

   899 

   900     class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {

   901     public:

   902         ThrowableBinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

   903         ThrowableBinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

   904 

   905     private:

   906         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   907     };

   908     

   909     class InstanceOfNode : public ThrowableBinaryOpNode {

   910     public:

   911         InstanceOfNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   912 

   913     private:

   914         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   915     };

   916 

   917     class InNode : public ThrowableBinaryOpNode {

   918     public:

   919         InNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   920     };

   921 

   922     class EqualNode : public BinaryOpNode {

   923     public:

   924         EqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   925 

   926     private:

   927         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   928     };

   929 

   930     class NotEqualNode : public BinaryOpNode {

   931     public:

   932         NotEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   933     };

   934 

   935     class StrictEqualNode : public BinaryOpNode {

   936     public:

   937         StrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   938 

   939     private:

   940         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   941     };

   942 

   943     class NotStrictEqualNode : public BinaryOpNode {

   944     public:

   945         NotStrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   946     };

   947 

   948     class BitAndNode : public BinaryOpNode {

   949     public:

   950         BitAndNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   951     };

   952 

   953     class BitOrNode : public BinaryOpNode {

   954     public:

   955         BitOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   956     };

   957 

   958     class BitXOrNode : public BinaryOpNode {

   959     public:

   960         BitXOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

   961     };

   962 

   963     // m_expr1 && m_expr2, m_expr1 || m_expr2

   964     class LogicalOpNode : public ExpressionNode {

   965     public:

   966         LogicalOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);

   967 

   968     private:

   969         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   970         void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);

   971         virtual bool hasConditionContextCodegen() const { return true; }

   972 

   973         ExpressionNode* m_expr1;

   974         ExpressionNode* m_expr2;

   975         LogicalOperator m_operator;

   976     };

   977 

   978     // The ternary operator, "m_logical ? m_expr1 : m_expr2"

   979     class ConditionalNode : public ExpressionNode {

   980     public:

   981         ConditionalNode(JSGlobalData*, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);

   982 

   983     private:

   984         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   985 

   986         ExpressionNode* m_logical;

   987         ExpressionNode* m_expr1;

   988         ExpressionNode* m_expr2;

   989     };

   990 

   991     class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {

   992     public:

   993         ReadModifyResolveNode(JSGlobalData*, const Identifier&, Operator, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);

   994 

   995     private:

   996         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

   997 

   998         const Identifier& m_ident;

   999         ExpressionNode* m_right;

  1000         size_t m_index; // Used by ReadModifyLocalVarNode.

  1001         Operator m_operator;

  1002         bool m_rightHasAssignments;

  1003     };

  1004 

  1005     class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {

  1006     public:

  1007         AssignResolveNode(JSGlobalData*, const Identifier&, ExpressionNode* right, bool rightHasAssignments);

  1008 

  1009     private:

  1010         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1011 

  1012         const Identifier& m_ident;

  1013         ExpressionNode* m_right;

  1014         size_t m_index; // Used by ReadModifyLocalVarNode.

  1015         bool m_rightHasAssignments;

  1016     };

  1017 

  1018     class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {

  1019     public:

  1020         ReadModifyBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);

  1021 

  1022     private:

  1023         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1024 

  1025         ExpressionNode* m_base;

  1026         ExpressionNode* m_subscript;

  1027         ExpressionNode* m_right;

  1028         Operator m_operator : 30;

  1029         bool m_subscriptHasAssignments : 1;

  1030         bool m_rightHasAssignments : 1;

  1031     };

  1032 

  1033     class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {

  1034     public:

  1035         AssignBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);

  1036 

  1037     private:

  1038         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1039 

  1040         ExpressionNode* m_base;

  1041         ExpressionNode* m_subscript;

  1042         ExpressionNode* m_right;

  1043         bool m_subscriptHasAssignments : 1;

  1044         bool m_rightHasAssignments : 1;

  1045     };

  1046 

  1047     class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {

  1048     public:

  1049         AssignDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);

  1050 

  1051     private:

  1052         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1053 

  1054         ExpressionNode* m_base;

  1055         const Identifier& m_ident;

  1056         ExpressionNode* m_right;

  1057         bool m_rightHasAssignments;

  1058     };

  1059 

  1060     class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {

  1061     public:

  1062         ReadModifyDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);

  1063 

  1064     private:

  1065         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1066 

  1067         ExpressionNode* m_base;

  1068         const Identifier& m_ident;

  1069         ExpressionNode* m_right;

  1070         Operator m_operator : 31;

  1071         bool m_rightHasAssignments : 1;

  1072     };

  1073 

  1074     class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {

  1075     public:

  1076         AssignErrorNode(JSGlobalData*, ExpressionNode* left, Operator, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset);

  1077 

  1078     private:

  1079         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1080 

  1081         ExpressionNode* m_left;

  1082         Operator m_operator;

  1083         ExpressionNode* m_right;

  1084     };

  1085     

  1086     typedef Vector<ExpressionNode*, 8> ExpressionVector;

  1087 

  1088     class CommaNode : public ExpressionNode, public ParserArenaDeletable {

  1089     public:

  1090         CommaNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2);

  1091 

  1092         using ParserArenaDeletable::operator new;

  1093 

  1094         void append(ExpressionNode* expr) { m_expressions.append(expr); }

  1095 

  1096     private:

  1097         virtual bool isCommaNode() const { return true; }

  1098         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1099 

  1100         ExpressionVector m_expressions;

  1101     };

  1102     

  1103     class ConstDeclNode : public ExpressionNode {

  1104     public:

  1105         ConstDeclNode(JSGlobalData*, const Identifier&, ExpressionNode*);

  1106 

  1107         bool hasInitializer() const { return m_init; }

  1108         const Identifier& ident() { return m_ident; }

  1109 

  1110     private:

  1111         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1112         virtual RegisterID* emitCodeSingle(BytecodeGenerator&);

  1113 

  1114         const Identifier& m_ident;

  1115 

  1116     public:

  1117         ConstDeclNode* m_next;

  1118 

  1119     private:

  1120         ExpressionNode* m_init;

  1121     };

  1122 

  1123     class ConstStatementNode : public StatementNode {

  1124     public:

  1125         ConstStatementNode(JSGlobalData*, ConstDeclNode* next);

  1126 

  1127     private:

  1128         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

  1129 

  1130         ConstDeclNode* m_next;

  1131     };

  1132 

  1133     class SourceElements : public ParserArenaDeletable {

  1134     public:

  1135         SourceElements(JSGlobalData*);