/*

* Copyright (C) 1999-2000 Harri Porten ([email protected])

* Copyright (C) 2001 Peter Kelly ([email protected])

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

* Copyright (C) 2007 Cameron Zwarich ([email protected])

* Copyright (C) 2007 Maks Orlovich

* Copyright (C) 2007 Eric Seidel <[email protected]>

*

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

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

* License as published by the Free Software Foundation; either

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

*

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

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

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

* Library General Public License for more details.

*

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

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

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

* Boston, MA 02110-1301, USA.

*

*/

#ifndef Nodes_h

#define Nodes_h

#include "Error.h"

#include "JITCode.h"

#include "Opcode.h"

#include "ParserArena.h"

#include "ParserTokens.h"

#include "ResultType.h"

#include "SourceCode.h"

#include "SymbolTable.h"

#include <wtf/MathExtras.h>

namespace JSC {

class ArgumentListNode;

class BytecodeGenerator;

class FunctionBodyNode;

class Label;

class PropertyListNode;

class ReadModifyResolveNode;

class RegisterID;

class JSScope;

class ScopeNode;

enum Operator {

OpEqual,

OpPlusEq,

OpMinusEq,

OpMultEq,

OpDivEq,

OpPlusPlus,

OpMinusMinus,

OpAndEq,

OpXOrEq,

OpOrEq,

OpModEq,

OpLShift,

OpRShift,

OpURShift

};

enum LogicalOperator {

OpLogicalAnd,

OpLogicalOr

};

enum FallThroughMode {

FallThroughMeansTrue = 0,

FallThroughMeansFalse = 1

};

inline FallThroughMode invert(FallThroughMode fallThroughMode) { return static_cast<FallThroughMode>(!fallThroughMode); }

typedef HashSet<RefPtr<StringImpl>, IdentifierRepHash> IdentifierSet;

namespace DeclarationStacks {

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

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

typedef Vector<FunctionBodyNode*> FunctionStack;

}

struct SwitchInfo {

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

uint32_t bytecodeOffset;

SwitchType switchType;

};

class ParserArenaFreeable {

public:

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

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

void* operator new(size_t, VM*);

};

class ParserArenaDeletable {

public:

virtual ~ParserArenaDeletable() { }

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

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

void* operator new(size_t, VM*);

};

template <typename T>

struct ParserArenaData : ParserArenaDeletable {

T data;

};

class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {

protected:

ParserArenaRefCounted(VM*);

public:

virtual ~ParserArenaRefCounted()

{

ASSERT(deletionHasBegun());

}

};

class Node : public ParserArenaFreeable {

protected:

Node(const JSTokenLocation&);

public:

virtual ~Node() { }

int lineNo() const { return m_position.line; }

int startOffset() const { return m_position.offset; }

int lineStartOffset() const { return m_position.lineStartOffset; }

const JSTextPosition& position() const { return m_position; }

protected:

JSTextPosition m_position;

};

class ExpressionNode : public Node {

protected:

ExpressionNode(const JSTokenLocation&, ResultType = ResultType::unknownType());

public:

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

virtual bool isNumber() const { return false; }

virtual bool isString() const { return false; }

virtual bool isNull() const { return false; }

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

virtual bool isConstant() const { return false; }

virtual bool isLocation() const { return false; }

virtual bool isResolveNode() const { return false; }

virtual bool isBracketAccessorNode() const { return false; }

virtual bool isDotAccessorNode() const { return false; }

virtual bool isDeconstructionNode() const { return false; }

virtual bool isFuncExprNode() const { return false; }

virtual bool isCommaNode() const { return false; }

virtual bool isSimpleArray() const { return false; }

virtual bool isAdd() const { return false; }

virtual bool isSubtract() const { return false; }

virtual bool isBoolean() const { return false; }

virtual bool isSpreadExpression() const { return false; }

virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, FallThroughMode);

virtual ExpressionNode* stripUnaryPlus() { return this; }

ResultType resultDescriptor() const { return m_resultType; }

private:

ResultType m_resultType;

};

class StatementNode : public Node {

protected:

StatementNode(const JSTokenLocation&);

public:

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

void setLoc(unsigned firstLine, unsigned lastLine, int startOffset, int lineStartOffset);

unsigned firstLine() const { return lineNo(); }

unsigned lastLine() const { return m_lastLine; }

virtual bool isEmptyStatement() const { return false; }

virtual bool isReturnNode() const { return false; }

virtual bool isExprStatement() const { return false; }

virtual bool isBreak() const { return false; }

virtual bool isContinue() const { return false; }

virtual bool isBlock() const { return false; }

private:

int m_lastLine;

};

class ConstantNode : public ExpressionNode {

public:

ConstantNode(const JSTokenLocation&, ResultType);

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

virtual bool isConstant() const OVERRIDE { return true; }

virtual JSValue jsValue(BytecodeGenerator&) const = 0;

private:

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

virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) OVERRIDE;

};

class NullNode : public ConstantNode {

public:

NullNode(const JSTokenLocation&);

private:

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

virtual JSValue jsValue(BytecodeGenerator&) const OVERRIDE { return jsNull(); }

};

class BooleanNode : public ConstantNode {

public:

BooleanNode(const JSTokenLocation&, bool value);

bool value() { return m_value; }

private:

virtual bool isBoolean() const OVERRIDE { return true; }

virtual JSValue jsValue(BytecodeGenerator&) const OVERRIDE { return jsBoolean(m_value); }

bool m_value;

};

class NumberNode : public ConstantNode {

public:

NumberNode(const JSTokenLocation&, double value);

double value() { return m_value; }

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

private:

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

virtual JSValue jsValue(BytecodeGenerator&) const OVERRIDE { return jsNumber(m_value); }

double m_value;

};

class StringNode : public ConstantNode {

public:

StringNode(const JSTokenLocation&, const Identifier&);

const Identifier& value() { return m_value; }

private:

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

virtual JSValue jsValue(BytecodeGenerator&) const OVERRIDE;

const Identifier& m_value;

};

class ThrowableExpressionData {

public:

ThrowableExpressionData()

: m_divot(-1, -1, -1)

, m_divotStart(-1, -1, -1)

, m_divotEnd(-1, -1, -1)

{

}

ThrowableExpressionData(const JSTextPosition& divot, const JSTextPosition& start, const JSTextPosition& end)

: m_divot(divot)

, m_divotStart(start)

, m_divotEnd(end)

{

ASSERT(m_divot.offset >= m_divot.lineStartOffset);

ASSERT(m_divotStart.offset >= m_divotStart.lineStartOffset);

ASSERT(m_divotEnd.offset >= m_divotEnd.lineStartOffset);

}

void setExceptionSourceCode(const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

{

ASSERT(divot.offset >= divot.lineStartOffset);

ASSERT(divotStart.offset >= divotStart.lineStartOffset);

ASSERT(divotEnd.offset >= divotEnd.lineStartOffset);

m_divot = divot;

m_divotStart = divotStart;

m_divotEnd = divotEnd;

}

const JSTextPosition& divot() const { return m_divot; }

const JSTextPosition& divotStart() const { return m_divotStart; }

const JSTextPosition& divotEnd() const { return m_divotEnd; }

protected:

RegisterID* emitThrowReferenceError(BytecodeGenerator&, const String& message);

private:

JSTextPosition m_divot;

JSTextPosition m_divotStart;

JSTextPosition m_divotEnd;

};

class ThrowableSubExpressionData : public ThrowableExpressionData {

public:

ThrowableSubExpressionData()

: m_subexpressionDivotOffset(0)

, m_subexpressionEndOffset(0)

, m_subexpressionLineOffset(0)

, m_subexpressionLineStartOffset(0)

{

}

ThrowableSubExpressionData(const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

: ThrowableExpressionData(divot, divotStart, divotEnd)

, m_subexpressionDivotOffset(0)

, m_subexpressionEndOffset(0)

, m_subexpressionLineOffset(0)

, m_subexpressionLineStartOffset(0)

{

}

void setSubexpressionInfo(const JSTextPosition& subexpressionDivot, int subexpressionOffset)

{

ASSERT(subexpressionDivot.offset <= divot().offset);

// Overflow means we can't do this safely, so just point at the primary divot,

// divotLine, or divotLineStart.

if ((divot() - subexpressionDivot.offset) & ~0xFFFF)

return;

if ((divot().line - subexpressionDivot.line) & ~0xFFFF)

return;

if ((divot().lineStartOffset - subexpressionDivot.lineStartOffset) & ~0xFFFF)

return;

if ((divotEnd() - subexpressionOffset) & ~0xFFFF)

return;

m_subexpressionDivotOffset = divot() - subexpressionDivot.offset;

m_subexpressionEndOffset = divotEnd() - subexpressionOffset;

m_subexpressionLineOffset = divot().line - subexpressionDivot.line;

m_subexpressionLineStartOffset = divot().lineStartOffset - subexpressionDivot.lineStartOffset;

}

JSTextPosition subexpressionDivot()

{

int newLine = divot().line - m_subexpressionLineOffset;

int newOffset = divot().offset - m_subexpressionDivotOffset;

int newLineStartOffset = divot().lineStartOffset - m_subexpressionLineStartOffset;

return JSTextPosition(newLine, newOffset, newLineStartOffset);

}

JSTextPosition subexpressionStart() { return divotStart(); }

JSTextPosition subexpressionEnd() { return divotEnd() - static_cast<int>(m_subexpressionEndOffset); }

protected:

uint16_t m_subexpressionDivotOffset;

uint16_t m_subexpressionEndOffset;

uint16_t m_subexpressionLineOffset;

uint16_t m_subexpressionLineStartOffset;

};

class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {

public:

ThrowablePrefixedSubExpressionData()

: m_subexpressionDivotOffset(0)

, m_subexpressionStartOffset(0)

, m_subexpressionLineOffset(0)

, m_subexpressionLineStartOffset(0)

{

}

ThrowablePrefixedSubExpressionData(const JSTextPosition& divot, const JSTextPosition& start, const JSTextPosition& end)

: ThrowableExpressionData(divot, start, end)

, m_subexpressionDivotOffset(0)

, m_subexpressionStartOffset(0)

, m_subexpressionLineOffset(0)

, m_subexpressionLineStartOffset(0)

{

}

void setSubexpressionInfo(const JSTextPosition& subexpressionDivot, int subexpressionOffset)

{

ASSERT(subexpressionDivot.offset >= divot().offset);

// Overflow means we can't do this safely, so just point at the primary divot,

// divotLine, or divotLineStart.

if ((subexpressionDivot.offset - divot()) & ~0xFFFF)

return;

if ((subexpressionDivot.line - divot().line) & ~0xFFFF)

return;

if ((subexpressionDivot.lineStartOffset - divot().lineStartOffset) & ~0xFFFF)

return;

if ((subexpressionOffset - divotStart()) & ~0xFFFF)

return;

m_subexpressionDivotOffset = subexpressionDivot.offset - divot();

m_subexpressionStartOffset = subexpressionOffset - divotStart();

m_subexpressionLineOffset = subexpressionDivot.line - divot().line;

m_subexpressionLineStartOffset = subexpressionDivot.lineStartOffset - divot().lineStartOffset;

}

JSTextPosition subexpressionDivot()

{

int newLine = divot().line + m_subexpressionLineOffset;

int newOffset = divot().offset + m_subexpressionDivotOffset;

int newLineStartOffset = divot().lineStartOffset + m_subexpressionLineStartOffset;

return JSTextPosition(newLine, newOffset, newLineStartOffset);

}

JSTextPosition subexpressionStart() { return divotStart() + static_cast<int>(m_subexpressionStartOffset); }

JSTextPosition subexpressionEnd() { return divotEnd(); }

protected:

uint16_t m_subexpressionDivotOffset;

uint16_t m_subexpressionStartOffset;

uint16_t m_subexpressionLineOffset;

uint16_t m_subexpressionLineStartOffset;

};

class RegExpNode : public ExpressionNode, public ThrowableExpressionData {

public:

RegExpNode(const JSTokenLocation&, const Identifier& pattern, const Identifier& flags);

private:

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

const Identifier& m_pattern;

const Identifier& m_flags;

};

class ThisNode : public ExpressionNode {

public:

ThisNode(const JSTokenLocation&);

private:

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

};

class ResolveNode : public ExpressionNode {

public:

ResolveNode(const JSTokenLocation&, const Identifier&, const JSTextPosition& start);

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

private:

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

virtual bool isPure(BytecodeGenerator&) const OVERRIDE;

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

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

const Identifier& m_ident;

JSTextPosition m_start;

};

class ElementNode : public ParserArenaFreeable {

public:

ElementNode(int elision, ExpressionNode*);

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

int elision() const { return m_elision; }

ExpressionNode* value() { return m_node; }

ElementNode* next() { return m_next; }

private:

ElementNode* m_next;

int m_elision;

ExpressionNode* m_node;

};

class ArrayNode : public ExpressionNode {

public:

ArrayNode(const JSTokenLocation&, int elision);

ArrayNode(const JSTokenLocation&, ElementNode*);

ArrayNode(const JSTokenLocation&, int elision, ElementNode*);

ArgumentListNode* toArgumentList(VM*, int, int) const;

ElementNode* elements() const { ASSERT(isSimpleArray()); return m_element; }

private:

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

virtual bool isSimpleArray() const OVERRIDE;

ElementNode* m_element;

int m_elision;

bool m_optional;

};

class PropertyNode : public ParserArenaFreeable {

public:

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

PropertyNode(VM*, const Identifier&, ExpressionNode*, Type);

PropertyNode(VM*, double, ExpressionNode*, Type);

PropertyNode(VM*, ExpressionNode* propertyName, ExpressionNode*, Type);

ExpressionNode* expressionName() const { return m_expression; }

const Identifier* name() const { return m_name; }

Type type() const { return m_type; }

private:

friend class PropertyListNode;

const Identifier* m_name;

ExpressionNode* m_expression;

ExpressionNode* m_assign;

Type m_type;

};

class PropertyListNode : public ExpressionNode {

public:

PropertyListNode(const JSTokenLocation&, PropertyNode*);

PropertyListNode(const JSTokenLocation&, PropertyNode*, PropertyListNode*);

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

private:

PropertyNode* m_node;

PropertyListNode* m_next;

};

class ObjectLiteralNode : public ExpressionNode {

public:

ObjectLiteralNode(const JSTokenLocation&);

ObjectLiteralNode(const JSTokenLocation&, PropertyListNode*);

private:

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

PropertyListNode* m_list;

};

class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {

public:

BracketAccessorNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);

ExpressionNode* base() const { return m_base; }

ExpressionNode* subscript() const { return m_subscript; }

bool subscriptHasAssignments() const { return m_subscriptHasAssignments; }

private:

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

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

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

ExpressionNode* m_base;

ExpressionNode* m_subscript;

bool m_subscriptHasAssignments;

};

class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {

public:

DotAccessorNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&);

ExpressionNode* base() const { return m_base; }

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

private:

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

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

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

ExpressionNode* m_base;

const Identifier& m_ident;

};

class SpreadExpressionNode : public ExpressionNode, public ThrowableExpressionData {

public:

SpreadExpressionNode(const JSTokenLocation&, ExpressionNode*);

ExpressionNode* expression() const { return m_expression; }

private:

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

virtual bool isSpreadExpression() const OVERRIDE { return true; }

ExpressionNode* m_expression;

};

class ArgumentListNode : public ExpressionNode {

public:

ArgumentListNode(const JSTokenLocation&, ExpressionNode*);

ArgumentListNode(const JSTokenLocation&, ArgumentListNode*, ExpressionNode*);

ArgumentListNode* m_next;

ExpressionNode* m_expr;

private:

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

};

class ArgumentsNode : public ParserArenaFreeable {

public:

ArgumentsNode();

ArgumentsNode(ArgumentListNode*);

ArgumentListNode* m_listNode;

};

class NewExprNode : public ExpressionNode, public ThrowableExpressionData {

public:

NewExprNode(const JSTokenLocation&, ExpressionNode*);

NewExprNode(const JSTokenLocation&, ExpressionNode*, ArgumentsNode*);

private:

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

ExpressionNode* m_expr;

ArgumentsNode* m_args;

};

class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {

public:

EvalFunctionCallNode(const JSTokenLocation&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

ArgumentsNode* m_args;

};

class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {

public:

FunctionCallValueNode(const JSTokenLocation&, ExpressionNode*, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

ExpressionNode* m_expr;

ArgumentsNode* m_args;

};

class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {

public:

FunctionCallResolveNode(const JSTokenLocation&, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

const Identifier& m_ident;

ArgumentsNode* m_args;

};

class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {

public:

FunctionCallBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

ExpressionNode* m_base;

ExpressionNode* m_subscript;

ArgumentsNode* m_args;

};

class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {

public:

FunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

protected:

ExpressionNode* m_base;

const Identifier& m_ident;

ArgumentsNode* m_args;

};

class CallFunctionCallDotNode : public FunctionCallDotNode {

public:

CallFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

};

class ApplyFunctionCallDotNode : public FunctionCallDotNode {

public:

ApplyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

};

class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {

public:

DeleteResolveNode(const JSTokenLocation&, const Identifier&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

const Identifier& m_ident;

};

class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {

public:

DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

ExpressionNode* m_base;

ExpressionNode* m_subscript;

};

class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {

public:

DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

ExpressionNode* m_base;

const Identifier& m_ident;

};

class DeleteValueNode : public ExpressionNode {

public:

DeleteValueNode(const JSTokenLocation&, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

};

class VoidNode : public ExpressionNode {

public:

VoidNode(const JSTokenLocation&, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

};

class TypeOfResolveNode : public ExpressionNode {

public:

TypeOfResolveNode(const JSTokenLocation&, const Identifier&);

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

private:

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

const Identifier& m_ident;

};

class TypeOfValueNode : public ExpressionNode {

public:

TypeOfValueNode(const JSTokenLocation&, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

};

class PrefixNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {

public:

PrefixNode(const JSTokenLocation&, ExpressionNode*, Operator, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

protected:

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

virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0);

virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0);

virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0);

ExpressionNode* m_expr;

Operator m_operator;

};

class PostfixNode : public PrefixNode {

public:

PostfixNode(const JSTokenLocation&, ExpressionNode*, Operator, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

private:

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

virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;

virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;

virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;

};

class UnaryOpNode : public ExpressionNode {

public:

UnaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode*, OpcodeID);

protected:

ExpressionNode* expr() { return m_expr; }

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

private:

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

OpcodeID opcodeID() const { return m_opcodeID; }

ExpressionNode* m_expr;

OpcodeID m_opcodeID;

};

class UnaryPlusNode : public UnaryOpNode {

public:

UnaryPlusNode(const JSTokenLocation&, ExpressionNode*);

private:

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

};

class NegateNode : public UnaryOpNode {

public:

NegateNode(const JSTokenLocation&, ExpressionNode*);

};

class BitwiseNotNode : public ExpressionNode {

public:

BitwiseNotNode(const JSTokenLocation&, ExpressionNode*);

protected:

ExpressionNode* expr() { return m_expr; }

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

private:

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

ExpressionNode* m_expr;

};

class LogicalNotNode : public UnaryOpNode {

public:

LogicalNotNode(const JSTokenLocation&, ExpressionNode*);

private:

virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) OVERRIDE;

};

class BinaryOpNode : public ExpressionNode {

public:

BinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

BinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

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

virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) OVERRIDE;

ExpressionNode* lhs() { return m_expr1; };

ExpressionNode* rhs() { return m_expr2; };

private:

void tryFoldToBranch(BytecodeGenerator&, TriState& branchCondition, ExpressionNode*& branchExpression);

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

protected:

OpcodeID opcodeID() const { return m_opcodeID; }

protected:

ExpressionNode* m_expr1;

ExpressionNode* m_expr2;

private:

OpcodeID m_opcodeID;

protected:

bool m_rightHasAssignments;

};

class MultNode : public BinaryOpNode {

public:

MultNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class DivNode : public BinaryOpNode {

public:

DivNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class ModNode : public BinaryOpNode {

public:

ModNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class AddNode : public BinaryOpNode {

public:

AddNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

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

};

class SubNode : public BinaryOpNode {

public:

SubNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

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

};

class LeftShiftNode : public BinaryOpNode {

public:

LeftShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class RightShiftNode : public BinaryOpNode {

public:

RightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class UnsignedRightShiftNode : public BinaryOpNode {

public:

UnsignedRightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class LessNode : public BinaryOpNode {

public:

LessNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class GreaterNode : public BinaryOpNode {

public:

GreaterNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class LessEqNode : public BinaryOpNode {

public:

LessEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class GreaterEqNode : public BinaryOpNode {

public:

GreaterEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {

public:

ThrowableBinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

ThrowableBinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

private:

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

};

class InstanceOfNode : public ThrowableBinaryOpNode {

public:

InstanceOfNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

private:

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

};

class InNode : public ThrowableBinaryOpNode {

public:

InNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class EqualNode : public BinaryOpNode {

public:

EqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

private:

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

};

class NotEqualNode : public BinaryOpNode {

public:

NotEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class StrictEqualNode : public BinaryOpNode {

public:

StrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

private:

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

};

class NotStrictEqualNode : public BinaryOpNode {

public:

NotStrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class BitAndNode : public BinaryOpNode {

public:

BitAndNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class BitOrNode : public BinaryOpNode {

public:

BitOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class BitXOrNode : public BinaryOpNode {

public:

BitXOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

// m_expr1 && m_expr2, m_expr1 || m_expr2

class LogicalOpNode : public ExpressionNode {

public:

LogicalOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);

private:

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

virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) OVERRIDE;

ExpressionNode* m_expr1;

ExpressionNode* m_expr2;

LogicalOperator m_operator;

};

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

class ConditionalNode : public ExpressionNode {

public:

ConditionalNode(const JSTokenLocation&, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);

private:

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