OpEqual,

OpPlusEq,

OpMinusEq,

OpMultEq,

OpDivEq,

OpPlusPlus,

OpMinusMinus,

OpAndEq,

OpXOrEq,

OpOrEq,

OpModEq,

OpLShift,

OpRShift,

OpURShift

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

uint32_t bytecodeOffset;

SwitchType switchType;

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

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

protected:

ParserArenaRefCounted(JSGlobalData*);

public:

virtual ~ParserArenaRefCounted()

{

ASSERT(deletionHasBegun());

}

protected:

Node(JSGlobalData*);

public:

virtual ~Node() { }

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

int lineNo() const { return m_line; }

protected:

int m_line;

protected:

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

protected:

StatementNode(JSGlobalData*);

public:

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;

public:

NullNode(JSGlobalData*);

private:

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

virtual bool isNull() const { return true; }

public:

BooleanNode(JSGlobalData*, bool value);

private:

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

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

bool m_value;

public:

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

public:

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

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* emitThrowError(BytecodeGenerator&, ErrorType, const char* message);

RegisterID* emitThrowError(BytecodeGenerator&, ErrorType, const char* message, const UString&);

RegisterID* emitThrowError(BytecodeGenerator&, ErrorType, const char* message, const Identifier&);

private:

uint32_t m_divot;

uint16_t m_startOffset;

uint16_t m_endOffset;

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;

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;

public:

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

private:

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

const Identifier& m_pattern;

const Identifier& m_flags;

public:

ThisNode(JSGlobalData*);

private:

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

public:

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

public:

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

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

public:

ArrayNode(JSGlobalData*, int elision);

ArrayNode(JSGlobalData*, ElementNode*);

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

ArgumentListNode* toArgumentList(JSGlobalData*) const;

private:

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

virtual bool isSimpleArray() const ;

ElementNode* m_element;

int m_elision;

bool m_optional;

public:

enum Type { Constant, Getter, Setter };

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

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

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

private:

friend class PropertyListNode;

const Identifier& m_name;

ExpressionNode* m_assign;

Type m_type;

public:

PropertyListNode(JSGlobalData*, PropertyNode*);

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

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

private:

PropertyNode* m_node;

PropertyListNode* m_next;

public:

ObjectLiteralNode(JSGlobalData*);

ObjectLiteralNode(JSGlobalData*, PropertyListNode*);

private:

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

PropertyListNode* m_list;

public:

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

public:

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

public:

ArgumentListNode(JSGlobalData*, ExpressionNode*);

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

ArgumentListNode* m_next;

ExpressionNode* m_expr;

private:

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

public:

ArgumentsNode(JSGlobalData*);

ArgumentsNode(JSGlobalData*, ArgumentListNode*);

ArgumentListNode* m_listNode;

public:

NewExprNode(JSGlobalData*, ExpressionNode*);

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

private:

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

ExpressionNode* m_expr;

ArgumentsNode* m_args;

public:

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

private:

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

ArgumentsNode* m_args;

public:

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

private:

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

ExpressionNode* m_expr;

ArgumentsNode* m_args;

public:

FunctionCallResolveNode(JSGlobalData*, 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

public:

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

public:

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

public:

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

private:

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

public:

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

private:

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

public:

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

protected:

const Identifier& m_ident;

public:

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

private:

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

Operator m_operator;

public:

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

public:

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

public:

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

private:

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

ExpressionNode* m_expr;

Operator m_operator;

public:

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

private:

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

const Identifier& m_ident;

public:

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

private:

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

ExpressionNode* m_base;

ExpressionNode* m_subscript;

public:

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

private:

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

ExpressionNode* m_base;

const Identifier& m_ident;

public:

DeleteValueNode(JSGlobalData*, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

public:

VoidNode(JSGlobalData*, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

public:

TypeOfResolveNode(JSGlobalData*, const Identifier&);

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

private:

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

const Identifier& m_ident;

public:

TypeOfValueNode(JSGlobalData*, ExpressionNode*);

private:

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

ExpressionNode* m_expr;

public:

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

private:

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

Operator m_operator;

public:

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

public:

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

public:

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

private:

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

ExpressionNode* m_expr;

Operator m_operator;

public:

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

public:

UnaryPlusNode(JSGlobalData*, ExpressionNode*);

private:

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

public:

LogicalNotNode(JSGlobalData*, ExpressionNode*);

private:

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

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

public:

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

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

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

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;

public:

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

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

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

public:

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

virtual bool isAdd() const { return true; }

public:

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

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

private:

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

public:

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

private:

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

public:

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

private:

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

public:

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

private:

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

public:

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

public:

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

private:

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

ExpressionNode* m_logical;

ExpressionNode* m_expr1;

ExpressionNode* m_expr2;

public:

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

private:

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

const Identifier& m_ident;

ExpressionNode* m_right;

size_t m_index; // Used by ReadModifyLocalVarNode.

Operator m_operator;

bool m_rightHasAssignments;

public:

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