parser/Nodes.h

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