/*

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

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

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

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

* Copyright (C) 2007 Maks Orlovich

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

*

* 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 "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 ScopeChainNode;

class ScopeNode;

typedef unsigned CodeFeatures;

const CodeFeatures NoFeatures = 0;

const CodeFeatures EvalFeature = 1 << 0;

const CodeFeatures ArgumentsFeature = 1 << 1;

const CodeFeatures WithFeature = 1 << 2;

const CodeFeatures CatchFeature = 1 << 3;

const CodeFeatures ThisFeature = 1 << 4;

const CodeFeatures StrictModeFeature = 1 << 5;

const CodeFeatures ShadowsArgumentsFeature = 1 << 6;

const CodeFeatures AllFeatures = EvalFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature | StrictModeFeature | ShadowsArgumentsFeature;

enum Operator {

OpEqual,

OpPlusEq,

OpMinusEq,

OpMultEq,

OpDivEq,

OpPlusPlus,

OpMinusMinus,

OpAndEq,

OpXOrEq,

OpOrEq,

OpModEq,

OpLShift,

OpRShift,

OpURShift

};

enum LogicalOperator {

OpLogicalAnd,

OpLogicalOr

};

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

namespace DeclarationStacks {

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

typedef Vector<std::pair<const 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, JSGlobalData*);

};

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, JSGlobalData*);

};

template <typename T>

struct ParserArenaData : ParserArenaDeletable {

T data;

};

class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {

protected:

ParserArenaRefCounted(JSGlobalData*);

public:

virtual ~ParserArenaRefCounted()

{

ASSERT(deletionHasBegun());

}

};

class Node : public ParserArenaFreeable {

protected:

Node(int);

public:

virtual ~Node() { }

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

int lineNo() const { return m_lineNumber; }

protected:

int m_lineNumber;

};

class ExpressionNode : public Node {

protected:

ExpressionNode(int, ResultType = ResultType::unknownType());

public:

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 isLocation() const { return false; }

virtual bool isResolveNode() const { return false; }

virtual bool isBracketAccessorNode() const { return false; }

virtual bool isDotAccessorNode() 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 hasConditionContextCodegen() const { return false; }

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

virtual ExpressionNode* stripUnaryPlus() { return this; }

ResultType resultDescriptor() const { return m_resultType; }

private:

ResultType m_resultType;

};

class StatementNode : public Node {

protected:

StatementNode(int);

public:

JS_EXPORT_PRIVATE void setLoc(int firstLine, int lastLine);

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

int 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 isBlock() const { return false; }

private:

int m_lastLine;

};

class NullNode : public ExpressionNode {

public:

NullNode(int);

private:

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

virtual bool isNull() const { return true; }

};

class BooleanNode : public ExpressionNode {

public:

BooleanNode(int, bool value);

private:

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

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

bool m_value;

};

class NumberNode : public ExpressionNode {

public:

NumberNode(int, double value);

double value() const { return m_value; }

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

private:

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

virtual bool isNumber() const { return true; }

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

double m_value;

};

class StringNode : public ExpressionNode {

public:

StringNode(int, const Identifier&);

const Identifier& value() { return m_value; }

private:

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

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

virtual bool isString() const { return true; }

const Identifier& m_value;

};

class ThrowableExpressionData {

public:

ThrowableExpressionData()

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

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

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

{

}

ThrowableExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

: m_divot(divot)

, m_startOffset(startOffset)

, m_endOffset(endOffset)

{

}

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

{

m_divot = divot;

m_startOffset = startOffset;

m_endOffset = endOffset;

}

uint32_t divot() const { return m_divot; }

uint16_t startOffset() const { return m_startOffset; }

uint16_t endOffset() const { return m_endOffset; }

protected:

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

private:

uint32_t m_divot;

uint16_t m_startOffset;

uint16_t m_endOffset;

};

class ThrowableSubExpressionData : public ThrowableExpressionData {

public:

ThrowableSubExpressionData()

: m_subexpressionDivotOffset(0)

, m_subexpressionEndOffset(0)

{

}

ThrowableSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

: ThrowableExpressionData(divot, startOffset, endOffset)

, m_subexpressionDivotOffset(0)

, m_subexpressionEndOffset(0)

{

}

void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)

{

ASSERT(subexpressionDivot <= divot());

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

return;

m_subexpressionDivotOffset = divot() - subexpressionDivot;

m_subexpressionEndOffset = subexpressionOffset;

}

protected:

uint16_t m_subexpressionDivotOffset;

uint16_t m_subexpressionEndOffset;

};

class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {

public:

ThrowablePrefixedSubExpressionData()

: m_subexpressionDivotOffset(0)

, m_subexpressionStartOffset(0)

{

}

ThrowablePrefixedSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

: ThrowableExpressionData(divot, startOffset, endOffset)

, m_subexpressionDivotOffset(0)

, m_subexpressionStartOffset(0)

{

}

void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)

{

ASSERT(subexpressionDivot >= divot());

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

return;

m_subexpressionDivotOffset = subexpressionDivot - divot();

m_subexpressionStartOffset = subexpressionOffset;

}

protected:

uint16_t m_subexpressionDivotOffset;

uint16_t m_subexpressionStartOffset;

};

class RegExpNode : public ExpressionNode, public ThrowableExpressionData {

public:

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

private:

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

const Identifier& m_pattern;

const Identifier& m_flags;

};

class ThisNode : public ExpressionNode {

public:

ThisNode(int);

private:

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

};

class ResolveNode : public ExpressionNode {

public:

ResolveNode(int, const Identifier&, int startOffset);

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

private:

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

virtual bool isPure(BytecodeGenerator&) const ;

virtual bool isLocation() const { return true; }

virtual bool isResolveNode() const { return true; }

const Identifier& m_ident;

int32_t m_startOffset;

};

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(int, int elision);

ArrayNode(int, ElementNode*);

ArrayNode(int, int elision, ElementNode*);

ArgumentListNode* toArgumentList(JSGlobalData*, int) const;

private:

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

virtual bool isSimpleArray() const ;

ElementNode* m_element;

int m_elision;

bool m_optional;

};

class PropertyNode : public ParserArenaFreeable {

public:

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

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

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

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

Type type() const { return m_type; }

private:

friend class PropertyListNode;

const Identifier& m_name;

ExpressionNode* m_assign;

Type m_type;

};

class PropertyListNode : public Node {

public:

PropertyListNode(int, PropertyNode*);

PropertyListNode(int, PropertyNode*, PropertyListNode*);

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

private:

PropertyNode* m_node;

PropertyListNode* m_next;

};

class ObjectLiteralNode : public ExpressionNode {

public:

ObjectLiteralNode(int);

ObjectLiteralNode(int, PropertyListNode*);

private:

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

PropertyListNode* m_list;

};

class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {

public:

BracketAccessorNode(int, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);

ExpressionNode* base() const { return m_base; }

ExpressionNode* subscript() const { return m_subscript; }

private:

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

virtual bool isLocation() const { return true; }

virtual bool isBracketAccessorNode() const { return true; }

ExpressionNode* m_base;

ExpressionNode* m_subscript;

bool m_subscriptHasAssignments;

};

class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {

public:

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

ExpressionNode* base() const { return m_base; }

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

private:

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

virtual bool isLocation() const { return true; }

virtual bool isDotAccessorNode() const { return true; }

ExpressionNode* m_base;

const Identifier& m_ident;

};

class ArgumentListNode : public Node {

public:

ArgumentListNode(int, ExpressionNode*);

ArgumentListNode(int, ArgumentListNode*, ExpressionNode*);

ArgumentListNode* m_next;

ExpressionNode* m_expr;

private:

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

};

class ArgumentsNode : public ParserArenaFreeable {

public:

ArgumentsNode();

ArgumentsNode(ArgumentListNode*);

ArgumentListNode* m_listNode;

};

class NewExprNode : public ExpressionNode, public ThrowableExpressionData {

public:

NewExprNode(int, ExpressionNode*);

NewExprNode(int, ExpressionNode*, ArgumentsNode*);

private:

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

ExpressionNode* m_expr;

ArgumentsNode* m_args;

};

class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {

public:

EvalFunctionCallNode(int, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

private:

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

ArgumentsNode* m_args;

};

class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {

public:

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

private:

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

ExpressionNode* m_expr;

ArgumentsNode* m_args;

};

class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {

public:

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

private:

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

const Identifier& m_ident;

ArgumentsNode* m_args;

size_t m_index; // Used by LocalVarFunctionCallNode.

size_t m_scopeDepth; // Used by ScopedVarFunctionCallNode and NonLocalVarFunctionCallNode

};

class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {

public:

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

private:

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

ExpressionNode* m_base;

ExpressionNode* m_subscript;

ArgumentsNode* m_args;

};

class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {

public:

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

private:

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

protected:

ExpressionNode* m_base;

const Identifier& m_ident;

ArgumentsNode* m_args;

};

class CallFunctionCallDotNode : public FunctionCallDotNode {

public:

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

private:

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

};

class ApplyFunctionCallDotNode : public FunctionCallDotNode {

public:

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

private:

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

};

class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {

public:

PrePostResolveNode(int, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);

protected:

const Identifier& m_ident;

};

class PostfixResolveNode : public PrePostResolveNode {

public:

PostfixResolveNode(int, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

private:

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

Operator m_operator;

};

class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {

public:

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

private:

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

ExpressionNode* m_base;

ExpressionNode* m_subscript;

Operator m_operator;

};

class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {

public:

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

private:

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

ExpressionNode* m_base;

const Identifier& m_ident;

Operator m_operator;

};

class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {

public:

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

private:

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

ExpressionNode* m_expr;

Operator m_operator;

};

class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {

public:

DeleteResolveNode(int, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);

private:

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

const Identifier& m_ident;

};

class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {

public:

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

private:

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

ExpressionNode* m_base;

ExpressionNode* m_subscript;

};

class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {

public:

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

private:

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

ExpressionNode* m_base;

const Identifier& m_ident;

};

class DeleteValueNode : public ExpressionNode {

public:

DeleteValueNode(int, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

};

class VoidNode : public ExpressionNode {

public:

VoidNode(int, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

};

class TypeOfResolveNode : public ExpressionNode {

public:

TypeOfResolveNode(int, const Identifier&);

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

private:

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

const Identifier& m_ident;

};

class TypeOfValueNode : public ExpressionNode {

public:

TypeOfValueNode(int, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

};

class PrefixResolveNode : public PrePostResolveNode {

public:

PrefixResolveNode(int, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);

private:

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

Operator m_operator;

};

class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {

public:

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

private:

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

ExpressionNode* m_base;

ExpressionNode* m_subscript;

Operator m_operator;

};

class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {

public:

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

private:

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

ExpressionNode* m_base;

const Identifier& m_ident;

Operator m_operator;

};

class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {

public:

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

private:

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

ExpressionNode* m_expr;

Operator m_operator;

};

class UnaryOpNode : public ExpressionNode {

public:

UnaryOpNode(int, ResultType, ExpressionNode*, OpcodeID);

protected:

ExpressionNode* expr() { return m_expr; }

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

private:

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

OpcodeID opcodeID() const { return m_opcodeID; }

ExpressionNode* m_expr;

OpcodeID m_opcodeID;

};

class UnaryPlusNode : public UnaryOpNode {

public:

UnaryPlusNode(int, ExpressionNode*);

private:

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

};

class NegateNode : public UnaryOpNode {

public:

NegateNode(int, ExpressionNode*);

};

class BitwiseNotNode : public ExpressionNode {

public:

BitwiseNotNode(int, ExpressionNode*);

protected:

ExpressionNode* expr() { return m_expr; }

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

private:

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

ExpressionNode* m_expr;

};

class LogicalNotNode : public UnaryOpNode {

public:

LogicalNotNode(int, ExpressionNode*);

private:

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

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

};

class BinaryOpNode : public ExpressionNode {

public:

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

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

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

ExpressionNode* lhs() { return m_expr1; };

ExpressionNode* rhs() { return m_expr2; };

private:

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

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(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class DivNode : public BinaryOpNode {

public:

DivNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class ModNode : public BinaryOpNode {

public:

ModNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class AddNode : public BinaryOpNode {

public:

AddNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

virtual bool isAdd() const { return true; }

};

class SubNode : public BinaryOpNode {

public:

SubNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

virtual bool isSubtract() const { return true; }

};

class LeftShiftNode : public BinaryOpNode {

public:

LeftShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class RightShiftNode : public BinaryOpNode {

public:

RightShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class UnsignedRightShiftNode : public BinaryOpNode {

public:

UnsignedRightShiftNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class LessNode : public BinaryOpNode {

public:

LessNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class GreaterNode : public BinaryOpNode {

public:

GreaterNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class LessEqNode : public BinaryOpNode {

public:

LessEqNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class GreaterEqNode : public BinaryOpNode {

public:

GreaterEqNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {

public:

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

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

private:

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

};

class InstanceOfNode : public ThrowableBinaryOpNode {

public:

InstanceOfNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

private:

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

};

class InNode : public ThrowableBinaryOpNode {

public:

InNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class EqualNode : public BinaryOpNode {

public:

EqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

private:

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

};

class NotEqualNode : public BinaryOpNode {

public:

NotEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class StrictEqualNode : public BinaryOpNode {

public:

StrictEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

private:

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

};

class NotStrictEqualNode : public BinaryOpNode {

public:

NotStrictEqualNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class BitAndNode : public BinaryOpNode {

public:

BitAndNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class BitOrNode : public BinaryOpNode {

public:

BitOrNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

class BitXOrNode : public BinaryOpNode {

public:

BitXOrNode(int, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

};

// m_expr1 && m_expr2, m_expr1 || m_expr2

class LogicalOpNode : public ExpressionNode {

public:

LogicalOpNode(int, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);

private:

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

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

virtual bool hasConditionContextCodegen() const { return true; }

ExpressionNode* m_expr1;

ExpressionNode* m_expr2;

LogicalOperator m_operator;

};

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

class ConditionalNode : public ExpressionNode {

public:

ConditionalNode(int, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);

private:

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

ExpressionNode* m_logical;

ExpressionNode* m_expr1;

ExpressionNode* m_expr2;

};

class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {

public:

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