Source/JavaScriptCore/parser/Nodes.h

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