X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/9dae56ea45a0f5f8136a5c93d6f3a7f99399ca73..14957cd040308e3eeec43d26bae5d76da13fcd85:/parser/Nodes.h diff --git a/parser/Nodes.h b/parser/Nodes.h index 2496a4f..6e73c00 100644 --- a/parser/Nodes.h +++ b/parser/Nodes.h @@ -23,36 +23,29 @@ * */ -#ifndef NODES_H_ -#define NODES_H_ +#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 -#include -#include - -#if PLATFORM(X86) && COMPILER(GCC) -#define JSC_FAST_CALL __attribute__((regparm(3))) -#else -#define JSC_FAST_CALL -#endif namespace JSC { - class CodeBlock; + class ArgumentListNode; class BytecodeGenerator; - class FuncDeclNode; - class EvalCodeBlock; - class JSFunction; - class NodeReleaser; - class ProgramCodeBlock; + class FunctionBodyNode; + class Label; class PropertyListNode; + class ReadModifyResolveNode; class RegisterID; class ScopeChainNode; + class ScopeNode; typedef unsigned CodeFeatures; @@ -64,7 +57,11 @@ namespace JSC { const CodeFeatures WithFeature = 1 << 4; const CodeFeatures CatchFeature = 1 << 5; const CodeFeatures ThisFeature = 1 << 6; - const CodeFeatures AllFeatures = EvalFeature | ClosureFeature | AssignFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature; + const CodeFeatures StrictModeFeature = 1 << 7; + const CodeFeatures ShadowsArgumentsFeature = 1 << 8; + + + const CodeFeatures AllFeatures = EvalFeature | ClosureFeature | AssignFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature | StrictModeFeature | ShadowsArgumentsFeature; enum Operator { OpEqual, @@ -88,10 +85,12 @@ namespace JSC { OpLogicalOr }; + typedef HashSet, IdentifierRepHash> IdentifierSet; + namespace DeclarationStacks { enum VarAttrs { IsConstant = 1, HasInitializer = 2 }; - typedef Vector > VarStack; - typedef Vector > FunctionStack; + typedef Vector > VarStack; + typedef Vector FunctionStack; } struct SwitchInfo { @@ -100,53 +99,41 @@ namespace JSC { SwitchType switchType; }; - class ParserRefCounted : Noncopyable { - protected: - ParserRefCounted(JSGlobalData*) JSC_FAST_CALL; - + class ParserArenaFreeable { public: - virtual ~ParserRefCounted(); - - // Nonrecursive destruction. - virtual void releaseNodes(NodeReleaser&); - - void ref() JSC_FAST_CALL; - void deref() JSC_FAST_CALL; - bool hasOneRef() JSC_FAST_CALL; - - static void deleteNewObjects(JSGlobalData*) JSC_FAST_CALL; - - private: - JSGlobalData* m_globalData; + // 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 Node : public ParserRefCounted { + class ParserArenaDeletable { public: - Node(JSGlobalData*) JSC_FAST_CALL; + 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*); + }; - /* - Return value: The register holding the production's value. - dst: An optional parameter specifying the most efficient - destination at which to store the production's value. - The callee must honor dst. + class ParserArenaRefCounted : public RefCounted { + protected: + ParserArenaRefCounted(JSGlobalData*); - dst provides for a crude form of copy propagation. For example, + public: + virtual ~ParserArenaRefCounted() + { + ASSERT(deletionHasBegun()); + } + }; - x = 1 + class Node : public ParserArenaFreeable { + protected: + Node(JSGlobalData*); - becomes - - load r[x], 1 - - instead of + public: + virtual ~Node() { } - load r0, 1 - mov r[x], r0 - - because the assignment node, "x =", passes r[x] as dst to the number - node, "1". - */ - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* dst = 0) JSC_FAST_CALL = 0; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0; int lineNo() const { return m_line; } @@ -155,47 +142,49 @@ namespace JSC { }; class ExpressionNode : public Node { - public: - ExpressionNode(JSGlobalData* globalData, ResultType resultDesc = ResultType::unknownType()) JSC_FAST_CALL - : Node(globalData) - , m_resultDesc(resultDesc) - { - } - - virtual bool isNumber() const JSC_FAST_CALL { return false; } - virtual bool isString() const JSC_FAST_CALL { return false; } - virtual bool isNull() const JSC_FAST_CALL { return false; } - virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return false; } - virtual bool isLocation() const JSC_FAST_CALL { return false; } - virtual bool isResolveNode() const JSC_FAST_CALL { return false; } - virtual bool isBracketAccessorNode() const JSC_FAST_CALL { return false; } - virtual bool isDotAccessorNode() const JSC_FAST_CALL { return false; } - virtual bool isFuncExprNode() const JSC_FAST_CALL { return false; } + 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 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 JSC_FAST_CALL { return m_resultDesc; } - - // This needs to be in public in order to compile using GCC 3.x - typedef enum { EvalOperator, FunctionCall } CallerType; + ResultType resultDescriptor() const { return m_resultType; } private: - ResultType m_resultDesc; + ResultType m_resultType; }; class StatementNode : public Node { + protected: + StatementNode(JSGlobalData*); + public: - StatementNode(JSGlobalData*) JSC_FAST_CALL; - void setLoc(int line0, int line1) JSC_FAST_CALL; - int firstLine() const JSC_FAST_CALL { return lineNo(); } - int lastLine() const JSC_FAST_CALL { return m_lastLine; } + void setLoc(int firstLine, int lastLine); + int firstLine() const { return lineNo(); } + int lastLine() const { return m_lastLine; } - virtual bool isEmptyStatement() const JSC_FAST_CALL { return false; } - virtual bool isReturnNode() const JSC_FAST_CALL { return false; } - virtual bool isExprStatement() const JSC_FAST_CALL { return false; } + virtual bool isEmptyStatement() const { return false; } + virtual bool isReturnNode() const { return false; } + virtual bool isExprStatement() const { return false; } - virtual bool isBlock() const JSC_FAST_CALL { return false; } - virtual bool isLoop() const JSC_FAST_CALL { return false; } + virtual bool isBlock() const { return false; } private: int m_lastLine; @@ -203,67 +192,56 @@ namespace JSC { class NullNode : public ExpressionNode { public: - NullNode(JSGlobalData* globalData) JSC_FAST_CALL - : ExpressionNode(globalData, ResultType::nullType()) - { - } + NullNode(JSGlobalData*); - virtual bool isNull() const JSC_FAST_CALL { return true; } + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + virtual bool isNull() const { return true; } }; class BooleanNode : public ExpressionNode { public: - BooleanNode(JSGlobalData* globalData, bool value) JSC_FAST_CALL - : ExpressionNode(globalData, ResultType::booleanType()) - , m_value(value) - { - } + BooleanNode(JSGlobalData*, bool value); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; } + virtual bool isPure(BytecodeGenerator&) const { return true; } - private: bool m_value; }; class NumberNode : public ExpressionNode { public: - NumberNode(JSGlobalData* globalData, double v) JSC_FAST_CALL - : ExpressionNode(globalData, ResultType::numberType()) - , m_double(v) - { - } - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + NumberNode(JSGlobalData*, double value); - virtual bool isNumber() const JSC_FAST_CALL { return true; } - virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; } - double value() const JSC_FAST_CALL { return m_double; } - void setValue(double d) JSC_FAST_CALL { m_double = d; } + double value() const { return m_value; } + void setValue(double value) { m_value = value; } private: - double m_double; + 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(JSGlobalData* globalData, const Identifier& v) JSC_FAST_CALL - : ExpressionNode(globalData, ResultType::stringType()) - , m_value(v) - { - } + StringNode(JSGlobalData*, const Identifier&); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - virtual bool isString() const JSC_FAST_CALL { return true; } const Identifier& value() { return m_value; } - virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL { return true; } private: - Identifier m_value; + 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 { @@ -294,8 +272,7 @@ namespace JSC { uint16_t endOffset() const { return m_endOffset; } protected: - RegisterID* emitThrowError(BytecodeGenerator&, ErrorType, const char* msg); - RegisterID* emitThrowError(BytecodeGenerator&, ErrorType, const char* msg, const Identifier&); + RegisterID* emitThrowReferenceError(BytecodeGenerator&, const UString& message); private: uint32_t m_divot; @@ -306,8 +283,7 @@ namespace JSC { class ThrowableSubExpressionData : public ThrowableExpressionData { public: ThrowableSubExpressionData() - : ThrowableExpressionData() - , m_subexpressionDivotOffset(0) + : m_subexpressionDivotOffset(0) , m_subexpressionEndOffset(0) { } @@ -336,8 +312,7 @@ namespace JSC { class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData { public: ThrowablePrefixedSubExpressionData() - : ThrowableExpressionData() - , m_subexpressionDivotOffset(0) + : m_subexpressionDivotOffset(0) , m_subexpressionStartOffset(0) { } @@ -365,1158 +340,695 @@ namespace JSC { class RegExpNode : public ExpressionNode, public ThrowableExpressionData { public: - RegExpNode(JSGlobalData* globalData, const UString& pattern, const UString& flags) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_pattern(pattern) - , m_flags(flags) - { - } - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + RegExpNode(JSGlobalData*, const Identifier& pattern, const Identifier& flags); private: - UString m_pattern; - UString m_flags; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_pattern; + const Identifier& m_flags; }; class ThisNode : public ExpressionNode { public: - ThisNode(JSGlobalData* globalData) JSC_FAST_CALL - : ExpressionNode(globalData) - { - } + ThisNode(JSGlobalData*); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; class ResolveNode : public ExpressionNode { public: - ResolveNode(JSGlobalData* globalData, const Identifier& ident, int startOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_ident(ident) - , m_startOffset(startOffset) - { - } + ResolveNode(JSGlobalData*, const Identifier&, int startOffset); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - virtual bool isPure(BytecodeGenerator&) const JSC_FAST_CALL; - virtual bool isLocation() const JSC_FAST_CALL { return true; } - virtual bool isResolveNode() const JSC_FAST_CALL { return true; } - const Identifier& identifier() const JSC_FAST_CALL { return m_ident; } + const Identifier& identifier() const { return m_ident; } private: - Identifier m_ident; + 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 ParserRefCounted { + class ElementNode : public ParserArenaFreeable { public: - ElementNode(JSGlobalData* globalData, int elision, ExpressionNode* node) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_elision(elision) - , m_node(node) - { - } - - ElementNode(JSGlobalData* globalData, ElementNode* l, int elision, ExpressionNode* node) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_elision(elision) - , m_node(node) - { - l->m_next = this; - } - - virtual ~ElementNode(); - virtual void releaseNodes(NodeReleaser&); + ElementNode(JSGlobalData*, int elision, ExpressionNode*); + ElementNode(JSGlobalData*, ElementNode*, int elision, ExpressionNode*); int elision() const { return m_elision; } - ExpressionNode* value() { return m_node.get(); } - - ElementNode* next() { return m_next.get(); } + ExpressionNode* value() { return m_node; } + ElementNode* next() { return m_next; } private: - RefPtr m_next; + ElementNode* m_next; int m_elision; - RefPtr m_node; + ExpressionNode* m_node; }; class ArrayNode : public ExpressionNode { public: - ArrayNode(JSGlobalData* globalData, int elision) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_elision(elision) - , m_optional(true) - { - } - - ArrayNode(JSGlobalData* globalData, ElementNode* element) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_element(element) - , m_elision(0) - , m_optional(false) - { - } + ArrayNode(JSGlobalData*, int elision); + ArrayNode(JSGlobalData*, ElementNode*); + ArrayNode(JSGlobalData*, int elision, ElementNode*); - ArrayNode(JSGlobalData* globalData, int elision, ElementNode* element) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_element(element) - , m_elision(elision) - , m_optional(true) - { - } + ArgumentListNode* toArgumentList(JSGlobalData*) const; - virtual ~ArrayNode(); - virtual void releaseNodes(NodeReleaser&); + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + virtual bool isSimpleArray() const ; - private: - RefPtr m_element; + ElementNode* m_element; int m_elision; bool m_optional; }; - class PropertyNode : public ParserRefCounted { + class PropertyNode : public ParserArenaFreeable { public: - enum Type { Constant, Getter, Setter }; - - PropertyNode(JSGlobalData* globalData, const Identifier& name, ExpressionNode* assign, Type type) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_name(name) - , m_assign(assign) - , m_type(type) - { - } + enum Type { Constant = 1, Getter = 2, Setter = 4 }; - virtual ~PropertyNode(); - virtual void releaseNodes(NodeReleaser&); + PropertyNode(JSGlobalData*, const Identifier& name, ExpressionNode* value, Type); + PropertyNode(JSGlobalData*, double name, ExpressionNode* value, Type); const Identifier& name() const { return m_name; } + Type type() const { return m_type; } private: friend class PropertyListNode; - Identifier m_name; - RefPtr m_assign; + const Identifier& m_name; + ExpressionNode* m_assign; Type m_type; }; class PropertyListNode : public Node { public: - PropertyListNode(JSGlobalData* globalData, PropertyNode* node) JSC_FAST_CALL - : Node(globalData) - , m_node(node) - { - } - - PropertyListNode(JSGlobalData* globalData, PropertyNode* node, PropertyListNode* list) JSC_FAST_CALL - : Node(globalData) - , m_node(node) - { - list->m_next = this; - } + PropertyListNode(JSGlobalData*, PropertyNode*); + PropertyListNode(JSGlobalData*, PropertyNode*, PropertyListNode*); - virtual ~PropertyListNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); private: - RefPtr m_node; - RefPtr m_next; + PropertyNode* m_node; + PropertyListNode* m_next; }; class ObjectLiteralNode : public ExpressionNode { public: - ObjectLiteralNode(JSGlobalData* globalData) JSC_FAST_CALL - : ExpressionNode(globalData) - { - } - - ObjectLiteralNode(JSGlobalData* globalData, PropertyListNode* list) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_list(list) - { - } - - virtual ~ObjectLiteralNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + ObjectLiteralNode(JSGlobalData*); + ObjectLiteralNode(JSGlobalData*, PropertyListNode*); private: - RefPtr m_list; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + PropertyListNode* m_list; }; class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData { public: - BracketAccessorNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_base(base) - , m_subscript(subscript) - , m_subscriptHasAssignments(subscriptHasAssignments) - { - } + BracketAccessorNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments); - virtual ~BracketAccessorNode(); - virtual void releaseNodes(NodeReleaser&); + ExpressionNode* base() const { return m_base; } + ExpressionNode* subscript() const { return m_subscript; } - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - virtual bool isLocation() const JSC_FAST_CALL { return true; } - virtual bool isBracketAccessorNode() const JSC_FAST_CALL { return true; } - ExpressionNode* base() JSC_FAST_CALL { return m_base.get(); } - ExpressionNode* subscript() JSC_FAST_CALL { return m_subscript.get(); } + virtual bool isLocation() const { return true; } + virtual bool isBracketAccessorNode() const { return true; } - private: - RefPtr m_base; - RefPtr m_subscript; + ExpressionNode* m_base; + ExpressionNode* m_subscript; bool m_subscriptHasAssignments; }; class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData { public: - DotAccessorNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_base(base) - , m_ident(ident) - { - } + DotAccessorNode(JSGlobalData*, ExpressionNode* base, const Identifier&); - virtual ~DotAccessorNode(); - virtual void releaseNodes(NodeReleaser&); + ExpressionNode* base() const { return m_base; } + const Identifier& identifier() const { return m_ident; } - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - virtual bool isLocation() const JSC_FAST_CALL { return true; } - virtual bool isDotAccessorNode() const JSC_FAST_CALL { return true; } - ExpressionNode* base() const JSC_FAST_CALL { return m_base.get(); } - const Identifier& identifier() const JSC_FAST_CALL { return m_ident; } + virtual bool isLocation() const { return true; } + virtual bool isDotAccessorNode() const { return true; } - private: - RefPtr m_base; - Identifier m_ident; + ExpressionNode* m_base; + const Identifier& m_ident; }; class ArgumentListNode : public Node { public: - ArgumentListNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : Node(globalData) - , m_expr(expr) - { - } - - ArgumentListNode(JSGlobalData* globalData, ArgumentListNode* listNode, ExpressionNode* expr) JSC_FAST_CALL - : Node(globalData) - , m_expr(expr) - { - listNode->m_next = this; - } - - virtual ~ArgumentListNode(); - virtual void releaseNodes(NodeReleaser&); + ArgumentListNode(JSGlobalData*, ExpressionNode*); + ArgumentListNode(JSGlobalData*, ArgumentListNode*, ExpressionNode*); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + ArgumentListNode* m_next; + ExpressionNode* m_expr; - RefPtr m_next; - RefPtr m_expr; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; - class ArgumentsNode : public ParserRefCounted { + class ArgumentsNode : public ParserArenaFreeable { public: - ArgumentsNode(JSGlobalData* globalData) JSC_FAST_CALL - : ParserRefCounted(globalData) - { - } - - ArgumentsNode(JSGlobalData* globalData, ArgumentListNode* listNode) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_listNode(listNode) - { - } + ArgumentsNode(JSGlobalData*); + ArgumentsNode(JSGlobalData*, ArgumentListNode*); - virtual ~ArgumentsNode(); - virtual void releaseNodes(NodeReleaser&); - - RefPtr m_listNode; + ArgumentListNode* m_listNode; }; class NewExprNode : public ExpressionNode, public ThrowableExpressionData { public: - NewExprNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_expr(expr) - { - } - - NewExprNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_expr(expr) - , m_args(args) - { - } - - virtual ~NewExprNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + NewExprNode(JSGlobalData*, ExpressionNode*); + NewExprNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*); private: - RefPtr m_expr; - RefPtr m_args; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; + ArgumentsNode* m_args; }; class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData { public: - EvalFunctionCallNode(JSGlobalData* globalData, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_args(args) - { - } - - virtual ~EvalFunctionCallNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + EvalFunctionCallNode(JSGlobalData*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_args; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ArgumentsNode* m_args; }; class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData { public: - FunctionCallValueNode(JSGlobalData* globalData, ExpressionNode* expr, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_expr(expr) - , m_args(args) - { - } - - virtual ~FunctionCallValueNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + FunctionCallValueNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_expr; - RefPtr m_args; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; + ArgumentsNode* m_args; }; class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData { public: - FunctionCallResolveNode(JSGlobalData* globalData, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_ident(ident) - , m_args(args) - { - } - - virtual ~FunctionCallResolveNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + FunctionCallResolveNode(JSGlobalData*, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset); private: - Identifier m_ident; - RefPtr m_args; + 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(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableSubExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_subscript(subscript) - , m_args(args) - { - } - - virtual ~FunctionCallBracketNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + FunctionCallBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - RefPtr m_subscript; - RefPtr m_args; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + ExpressionNode* m_subscript; + ArgumentsNode* m_args; }; class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData { public: - FunctionCallDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ArgumentsNode* args, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableSubExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_ident(ident) - , m_args(args) - { - } + 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; + }; - virtual ~FunctionCallDotNode(); - virtual void releaseNodes(NodeReleaser&); + class CallFunctionCallDotNode : public FunctionCallDotNode { + public: + CallFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + }; + + class ApplyFunctionCallDotNode : public FunctionCallDotNode { + public: + ApplyFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - Identifier m_ident; - RefPtr m_args; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData { public: - PrePostResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData, ResultType::numberType()) // could be reusable for pre? - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_ident(ident) - { - } + PrePostResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset); protected: - Identifier m_ident; + const Identifier& m_ident; }; class PostfixResolveNode : public PrePostResolveNode { public: - PostfixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset) - , m_operator(oper) - { - } - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + PostfixResolveNode(JSGlobalData*, 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(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableSubExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_subscript(subscript) - , m_operator(oper) - { - } - - virtual ~PostfixBracketNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + PostfixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - RefPtr m_subscript; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + ExpressionNode* m_subscript; Operator m_operator; }; class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData { public: - PostfixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableSubExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_ident(ident) - , m_operator(oper) - { - } - - virtual ~PostfixDotNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + PostfixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - Identifier m_ident; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + const Identifier& m_ident; Operator m_operator; }; class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData { public: - PostfixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableSubExpressionData(divot, startOffset, endOffset) - , m_expr(expr) - , m_operator(oper) - { - } - - virtual ~PostfixErrorNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + PostfixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_expr; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; Operator m_operator; }; class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData { public: - DeleteResolveNode(JSGlobalData* globalData, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_ident(ident) - { - } - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + DeleteResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset); private: - Identifier m_ident; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_ident; }; class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData { public: - DeleteBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_subscript(subscript) - { - } - - virtual ~DeleteBracketNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + DeleteBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - RefPtr m_subscript; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + ExpressionNode* m_subscript; }; class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData { public: - DeleteDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_ident(ident) - { - } - - virtual ~DeleteDotNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + DeleteDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - Identifier m_ident; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + const Identifier& m_ident; }; class DeleteValueNode : public ExpressionNode { public: - DeleteValueNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_expr(expr) - { - } - - virtual ~DeleteValueNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + DeleteValueNode(JSGlobalData*, ExpressionNode*); private: - RefPtr m_expr; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; }; class VoidNode : public ExpressionNode { public: - VoidNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_expr(expr) - { - } - - virtual ~VoidNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + VoidNode(JSGlobalData*, ExpressionNode*); private: - RefPtr m_expr; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; }; class TypeOfResolveNode : public ExpressionNode { public: - TypeOfResolveNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL - : ExpressionNode(globalData, ResultType::stringType()) - , m_ident(ident) - { - } + TypeOfResolveNode(JSGlobalData*, const Identifier&); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - const Identifier& identifier() const JSC_FAST_CALL { return m_ident; } + const Identifier& identifier() const { return m_ident; } private: - Identifier m_ident; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_ident; }; class TypeOfValueNode : public ExpressionNode { public: - TypeOfValueNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : ExpressionNode(globalData, ResultType::stringType()) - , m_expr(expr) - { - } - - virtual ~TypeOfValueNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + TypeOfValueNode(JSGlobalData*, ExpressionNode*); private: - RefPtr m_expr; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; }; class PrefixResolveNode : public PrePostResolveNode { public: - PrefixResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : PrePostResolveNode(globalData, ident, divot, startOffset, endOffset) - , m_operator(oper) - { - } - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + PrefixResolveNode(JSGlobalData*, 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(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_subscript(subscript) - , m_operator(oper) - { - } - - virtual ~PrefixBracketNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + PrefixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - RefPtr m_subscript; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + ExpressionNode* m_subscript; Operator m_operator; }; class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData { public: - PrefixDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowablePrefixedSubExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_ident(ident) - , m_operator(oper) - { - } - - virtual ~PrefixDotNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + PrefixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - Identifier m_ident; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + const Identifier& m_ident; Operator m_operator; }; class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData { public: - PrefixErrorNode(JSGlobalData* globalData, ExpressionNode* expr, Operator oper, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_expr(expr) - , m_operator(oper) - { - } - - virtual ~PrefixErrorNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + PrefixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_expr; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; Operator m_operator; }; class UnaryOpNode : public ExpressionNode { public: - UnaryOpNode(JSGlobalData* globalData, ExpressionNode* expr) - : ExpressionNode(globalData) - , m_expr(expr) - { - } + UnaryOpNode(JSGlobalData*, ResultType, ExpressionNode*, OpcodeID); - UnaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr) - : ExpressionNode(globalData, type) - , m_expr(expr) - { - } + protected: + ExpressionNode* expr() { return m_expr; } + const ExpressionNode* expr() const { return m_expr; } - virtual ~UnaryOpNode(); - virtual void releaseNodes(NodeReleaser&); + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - virtual OpcodeID opcodeID() const JSC_FAST_CALL = 0; + OpcodeID opcodeID() const { return m_opcodeID; } - protected: - RefPtr m_expr; + ExpressionNode* m_expr; + OpcodeID m_opcodeID; }; class UnaryPlusNode : public UnaryOpNode { public: - UnaryPlusNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : UnaryOpNode(globalData, ResultType::numberType(), expr) - { - } - - virtual ExpressionNode* stripUnaryPlus() { return m_expr.get(); } + UnaryPlusNode(JSGlobalData*, ExpressionNode*); - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_to_jsnumber; } + private: + virtual ExpressionNode* stripUnaryPlus() { return expr(); } }; class NegateNode : public UnaryOpNode { public: - NegateNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : UnaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_negate; } + NegateNode(JSGlobalData*, ExpressionNode*); }; class BitwiseNotNode : public UnaryOpNode { public: - BitwiseNotNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : UnaryOpNode(globalData, ResultType::forBitOp(), expr) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitnot; } + BitwiseNotNode(JSGlobalData*, ExpressionNode*); }; class LogicalNotNode : public UnaryOpNode { public: - LogicalNotNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : UnaryOpNode(globalData, ResultType::booleanType(), expr) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_not; } + LogicalNotNode(JSGlobalData*, ExpressionNode*); + private: + void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue); + virtual bool hasConditionContextCodegen() const { return expr()->hasConditionContextCodegen(); } }; class BinaryOpNode : public ExpressionNode { public: - BinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) - : ExpressionNode(globalData) - , m_expr1(expr1) - , m_expr2(expr2) - , m_rightHasAssignments(rightHasAssignments) - { - } + BinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments); + BinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments); - BinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) - : ExpressionNode(globalData, type) - , m_expr1(expr1) - , m_expr2(expr2) - , m_rightHasAssignments(rightHasAssignments) - { - } + RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0); - virtual ~BinaryOpNode(); - virtual void releaseNodes(NodeReleaser&); + ExpressionNode* lhs() { return m_expr1; }; + ExpressionNode* rhs() { return m_expr2; }; - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - virtual OpcodeID opcodeID() const JSC_FAST_CALL = 0; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); protected: - RefPtr m_expr1; - RefPtr m_expr2; + OpcodeID opcodeID() const { return m_opcodeID; } + + protected: + ExpressionNode* m_expr1; + ExpressionNode* m_expr2; + private: + OpcodeID m_opcodeID; + protected: bool m_rightHasAssignments; }; class ReverseBinaryOpNode : public BinaryOpNode { public: - ReverseBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) - : BinaryOpNode(globalData, expr1, expr2, rightHasAssignments) - { - } - - ReverseBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) - : BinaryOpNode(globalData, type, expr1, expr2, rightHasAssignments) - { - } + 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) JSC_FAST_CALL; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; class MultNode : public BinaryOpNode { public: - MultNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_mul; } + MultNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class DivNode : public BinaryOpNode { public: - DivNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_div; } + DivNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class ModNode : public BinaryOpNode { public: - ModNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_mod; } + ModNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class AddNode : public BinaryOpNode { public: - AddNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::forAdd(expr1->resultDescriptor(), expr2->resultDescriptor()), expr1, expr2, rightHasAssignments) - { - } + AddNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_add; } + virtual bool isAdd() const { return true; } }; class SubNode : public BinaryOpNode { public: - SubNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments) - { - } + SubNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_sub; } + virtual bool isSubtract() const { return true; } }; class LeftShiftNode : public BinaryOpNode { public: - LeftShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lshift; } + LeftShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class RightShiftNode : public BinaryOpNode { public: - RightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_rshift; } + RightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class UnsignedRightShiftNode : public BinaryOpNode { public: - UnsignedRightShiftNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::numberTypeCanReuse(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_urshift; } + UnsignedRightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class LessNode : public BinaryOpNode { public: - LessNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_less; } + LessNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class GreaterNode : public ReverseBinaryOpNode { public: - GreaterNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : ReverseBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_less; } + GreaterNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class LessEqNode : public BinaryOpNode { public: - LessEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lesseq; } + LessEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class GreaterEqNode : public ReverseBinaryOpNode { public: - GreaterEqNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : ReverseBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lesseq; } + GreaterEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData { public: - ThrowableBinaryOpNode(JSGlobalData* globalData, ResultType type, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, type, expr1, expr2, rightHasAssignments) - { - } - ThrowableBinaryOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, expr1, expr2, rightHasAssignments) - { - } - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + 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); }; class InstanceOfNode : public ThrowableBinaryOpNode { public: - InstanceOfNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : ThrowableBinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_instanceof; } + InstanceOfNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; class InNode : public ThrowableBinaryOpNode { public: - InNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : ThrowableBinaryOpNode(globalData, expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_in; } + InNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class EqualNode : public BinaryOpNode { public: - EqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } + EqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_eq; } + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; class NotEqualNode : public BinaryOpNode { public: - NotEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_neq; } + NotEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class StrictEqualNode : public BinaryOpNode { public: - StrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } + StrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_stricteq; } + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; class NotStrictEqualNode : public BinaryOpNode { public: - NotStrictEqualNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::booleanType(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_nstricteq; } + NotStrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class BitAndNode : public BinaryOpNode { public: - BitAndNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitand; } + BitAndNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class BitOrNode : public BinaryOpNode { public: - BitOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitor; } + BitOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; class BitXOrNode : public BinaryOpNode { public: - BitXOrNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments) JSC_FAST_CALL - : BinaryOpNode(globalData, ResultType::forBitOp(), expr1, expr2, rightHasAssignments) - { - } - - virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitxor; } + BitXOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments); }; - /** - * m_expr1 && m_expr2, m_expr1 || m_expr2 - */ + // m_expr1 && m_expr2, m_expr1 || m_expr2 class LogicalOpNode : public ExpressionNode { public: - LogicalOpNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator oper) JSC_FAST_CALL - : ExpressionNode(globalData, ResultType::booleanType()) - , m_expr1(expr1) - , m_expr2(expr2) - , m_operator(oper) - { - } - - virtual ~LogicalOpNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + LogicalOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator); private: - RefPtr m_expr1; - RefPtr m_expr2; + 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" - */ + // The ternary operator, "m_logical ? m_expr1 : m_expr2" class ConditionalNode : public ExpressionNode { public: - ConditionalNode(JSGlobalData* globalData, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_logical(logical) - , m_expr1(expr1) - , m_expr2(expr2) - { - } - - virtual ~ConditionalNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + ConditionalNode(JSGlobalData*, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2); private: - RefPtr m_logical; - RefPtr m_expr1; - RefPtr m_expr2; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_logical; + ExpressionNode* m_expr1; + ExpressionNode* m_expr2; }; class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData { public: - ReadModifyResolveNode(JSGlobalData* globalData, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_ident(ident) - , m_right(right) - , m_operator(oper) - , m_rightHasAssignments(rightHasAssignments) - { - } - - virtual ~ReadModifyResolveNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + ReadModifyResolveNode(JSGlobalData*, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset); private: - Identifier m_ident; - RefPtr m_right; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_ident; + ExpressionNode* m_right; size_t m_index; // Used by ReadModifyLocalVarNode. - Operator m_operator : 31; - bool m_rightHasAssignments : 1; + Operator m_operator; + bool m_rightHasAssignments; }; class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData { public: - AssignResolveNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_ident(ident) - , m_right(right) - , m_rightHasAssignments(rightHasAssignments) - { - } - - virtual ~AssignResolveNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + AssignResolveNode(JSGlobalData*, const Identifier&, ExpressionNode* right, bool rightHasAssignments); private: - Identifier m_ident; - RefPtr m_right; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_ident; + ExpressionNode* m_right; size_t m_index; // Used by ReadModifyLocalVarNode. bool m_rightHasAssignments; }; class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData { public: - ReadModifyBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableSubExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_subscript(subscript) - , m_right(right) - , m_operator(oper) - , m_subscriptHasAssignments(subscriptHasAssignments) - , m_rightHasAssignments(rightHasAssignments) - { - } - - virtual ~ReadModifyBracketNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + ReadModifyBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - RefPtr m_subscript; - RefPtr m_right; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + ExpressionNode* m_subscript; + ExpressionNode* m_right; Operator m_operator : 30; bool m_subscriptHasAssignments : 1; bool m_rightHasAssignments : 1; @@ -1524,592 +1036,396 @@ namespace JSC { class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData { public: - AssignBracketNode(JSGlobalData* globalData, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_subscript(subscript) - , m_right(right) - , m_subscriptHasAssignments(subscriptHasAssignments) - , m_rightHasAssignments(rightHasAssignments) - { - } - - virtual ~AssignBracketNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + AssignBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - RefPtr m_subscript; - RefPtr m_right; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + ExpressionNode* m_subscript; + ExpressionNode* m_right; bool m_subscriptHasAssignments : 1; bool m_rightHasAssignments : 1; }; class AssignDotNode : public ExpressionNode, public ThrowableExpressionData { public: - AssignDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_ident(ident) - , m_right(right) - , m_rightHasAssignments(rightHasAssignments) - { - } - - virtual ~AssignDotNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + AssignDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - Identifier m_ident; - RefPtr m_right; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + const Identifier& m_ident; + ExpressionNode* m_right; bool m_rightHasAssignments; }; class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData { public: - ReadModifyDotNode(JSGlobalData* globalData, ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableSubExpressionData(divot, startOffset, endOffset) - , m_base(base) - , m_ident(ident) - , m_right(right) - , m_operator(oper) - , m_rightHasAssignments(rightHasAssignments) - { - } - - virtual ~ReadModifyDotNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + ReadModifyDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_base; - Identifier m_ident; - RefPtr m_right; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_base; + const Identifier& m_ident; + ExpressionNode* m_right; Operator m_operator : 31; bool m_rightHasAssignments : 1; }; class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData { public: - AssignErrorNode(JSGlobalData* globalData, ExpressionNode* left, Operator oper, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset) JSC_FAST_CALL - : ExpressionNode(globalData) - , ThrowableExpressionData(divot, startOffset, endOffset) - , m_left(left) - , m_operator(oper) - , m_right(right) - { - } - - virtual ~AssignErrorNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + AssignErrorNode(JSGlobalData*, ExpressionNode* left, Operator, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset); private: - RefPtr m_left; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_left; Operator m_operator; - RefPtr m_right; + ExpressionNode* m_right; }; + + typedef Vector ExpressionVector; - class CommaNode : public ExpressionNode { + class CommaNode : public ExpressionNode, public ParserArenaDeletable { public: - CommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_expr1(expr1) - , m_expr2(expr2) - { - } + CommaNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2); - virtual ~CommaNode(); - virtual void releaseNodes(NodeReleaser&); + using ParserArenaDeletable::operator new; - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + void append(ExpressionNode* expr) { m_expressions.append(expr); } private: - RefPtr m_expr1; - RefPtr m_expr2; + virtual bool isCommaNode() const { return true; } + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionVector m_expressions; }; - class VarDeclCommaNode : public CommaNode { - public: - VarDeclCommaNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2) JSC_FAST_CALL - : CommaNode(globalData, expr1, expr2) - { - } - }; - class ConstDeclNode : public ExpressionNode { public: - ConstDeclNode(JSGlobalData* globalData, const Identifier& ident, ExpressionNode* in) JSC_FAST_CALL; + ConstDeclNode(JSGlobalData*, const Identifier&, ExpressionNode*); - virtual ~ConstDeclNode(); - virtual void releaseNodes(NodeReleaser&); + bool hasInitializer() const { return m_init; } + const Identifier& ident() { return m_ident; } - Identifier m_ident; - RefPtr m_next; - RefPtr m_init; - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - virtual RegisterID* emitCodeSingle(BytecodeGenerator&) JSC_FAST_CALL; - }; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + virtual RegisterID* emitCodeSingle(BytecodeGenerator&); + + const Identifier& m_ident; - class ConstStatementNode : public StatementNode { public: - ConstStatementNode(JSGlobalData* globalData, ConstDeclNode* next) JSC_FAST_CALL - : StatementNode(globalData) - , m_next(next) - { - } + ConstDeclNode* m_next; - virtual ~ConstStatementNode(); - virtual void releaseNodes(NodeReleaser&); + private: + ExpressionNode* m_init; + }; - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + class ConstStatementNode : public StatementNode { + public: + ConstStatementNode(JSGlobalData*, ConstDeclNode* next); private: - RefPtr m_next; - }; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - typedef Vector > StatementVector; + ConstDeclNode* m_next; + }; - class SourceElements : public ParserRefCounted { + class SourceElements : public ParserArenaDeletable { public: - SourceElements(JSGlobalData* globalData) : ParserRefCounted(globalData) {} + SourceElements(JSGlobalData*); - void append(PassRefPtr); - void releaseContentsIntoVector(StatementVector& destination) - { - ASSERT(destination.isEmpty()); - m_statements.swap(destination); - destination.shrinkToFit(); - } + void append(StatementNode*); + + StatementNode* singleStatement() const; + StatementNode* lastStatement() const; + + void emitBytecode(BytecodeGenerator&, RegisterID* destination); private: - StatementVector m_statements; + Vector m_statements; }; class BlockNode : public StatementNode { public: - BlockNode(JSGlobalData*, SourceElements* children) JSC_FAST_CALL; + BlockNode(JSGlobalData*, SourceElements* = 0); - virtual ~BlockNode(); - virtual void releaseNodes(NodeReleaser&); + StatementNode* singleStatement() const; + StatementNode* lastStatement() const; - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - StatementVector& children() { return m_children; } + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - virtual bool isBlock() const JSC_FAST_CALL { return true; } + virtual bool isBlock() const { return true; } - private: - StatementVector m_children; + SourceElements* m_statements; }; class EmptyStatementNode : public StatementNode { public: - EmptyStatementNode(JSGlobalData* globalData) JSC_FAST_CALL // debug - : StatementNode(globalData) - { - } + EmptyStatementNode(JSGlobalData*); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - virtual bool isEmptyStatement() const JSC_FAST_CALL { return true; } + virtual bool isEmptyStatement() const { return true; } }; class DebuggerStatementNode : public StatementNode { public: - DebuggerStatementNode(JSGlobalData* globalData) JSC_FAST_CALL - : StatementNode(globalData) - { - } + DebuggerStatementNode(JSGlobalData*); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; class ExprStatementNode : public StatementNode { public: - ExprStatementNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : StatementNode(globalData) - , m_expr(expr) - { - } + ExprStatementNode(JSGlobalData*, ExpressionNode*); - virtual bool isExprStatement() const JSC_FAST_CALL { return true; } + ExpressionNode* expr() const { return m_expr; } - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + private: + virtual bool isExprStatement() const { return true; } - ExpressionNode* expr() const { return m_expr.get(); } + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - private: - RefPtr m_expr; + ExpressionNode* m_expr; }; class VarStatementNode : public StatementNode { public: - VarStatementNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : StatementNode(globalData) - , m_expr(expr) - { - } - - virtual ~VarStatementNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + VarStatementNode(JSGlobalData*, ExpressionNode*); private: - RefPtr m_expr; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; }; class IfNode : public StatementNode { public: - IfNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock) JSC_FAST_CALL - : StatementNode(globalData) - , m_condition(condition) - , m_ifBlock(ifBlock) - { - } - - virtual ~IfNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + IfNode(JSGlobalData*, ExpressionNode* condition, StatementNode* ifBlock); protected: - RefPtr m_condition; - RefPtr m_ifBlock; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_condition; + StatementNode* m_ifBlock; }; class IfElseNode : public IfNode { public: - IfElseNode(JSGlobalData* globalData, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock) JSC_FAST_CALL - : IfNode(globalData, condition, ifBlock) - , m_elseBlock(elseBlock) - { - } - - virtual ~IfElseNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + IfElseNode(JSGlobalData*, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock); private: - RefPtr m_elseBlock; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + StatementNode* m_elseBlock; }; class DoWhileNode : public StatementNode { public: - DoWhileNode(JSGlobalData* globalData, StatementNode* statement, ExpressionNode* expr) JSC_FAST_CALL - : StatementNode(globalData) - , m_statement(statement) - , m_expr(expr) - { - } - - virtual ~DoWhileNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - virtual bool isLoop() const JSC_FAST_CALL { return true; } + DoWhileNode(JSGlobalData*, StatementNode* statement, ExpressionNode*); private: - RefPtr m_statement; - RefPtr m_expr; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + StatementNode* m_statement; + ExpressionNode* m_expr; }; class WhileNode : public StatementNode { public: - WhileNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement) JSC_FAST_CALL - : StatementNode(globalData) - , m_expr(expr) - , m_statement(statement) - { - } - - virtual ~WhileNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - virtual bool isLoop() const JSC_FAST_CALL { return true; } + WhileNode(JSGlobalData*, ExpressionNode*, StatementNode* statement); private: - RefPtr m_expr; - RefPtr m_statement; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; + StatementNode* m_statement; }; class ForNode : public StatementNode { public: - ForNode(JSGlobalData* globalData, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) JSC_FAST_CALL - : StatementNode(globalData) - , m_expr1(expr1) - , m_expr2(expr2) - , m_expr3(expr3) - , m_statement(statement) - , m_expr1WasVarDecl(expr1 && expr1WasVarDecl) - { - ASSERT(statement); - } - - virtual ~ForNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - virtual bool isLoop() const JSC_FAST_CALL { return true; } + ForNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl); private: - RefPtr m_expr1; - RefPtr m_expr2; - RefPtr m_expr3; - RefPtr m_statement; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr1; + ExpressionNode* m_expr2; + ExpressionNode* m_expr3; + StatementNode* m_statement; bool m_expr1WasVarDecl; }; class ForInNode : public StatementNode, public ThrowableExpressionData { public: - ForInNode(JSGlobalData*, ExpressionNode*, ExpressionNode*, StatementNode*) JSC_FAST_CALL; - ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset) JSC_FAST_CALL; - - virtual ~ForInNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - virtual bool isLoop() const JSC_FAST_CALL { return true; } + ForInNode(JSGlobalData*, ExpressionNode*, ExpressionNode*, StatementNode*); + ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset); private: - Identifier m_ident; - RefPtr m_init; - RefPtr m_lexpr; - RefPtr m_expr; - RefPtr m_statement; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_ident; + ExpressionNode* m_init; + ExpressionNode* m_lexpr; + ExpressionNode* m_expr; + StatementNode* m_statement; bool m_identIsVarDecl; }; class ContinueNode : public StatementNode, public ThrowableExpressionData { public: - ContinueNode(JSGlobalData* globalData) JSC_FAST_CALL - : StatementNode(globalData) - { - } - - ContinueNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL - : StatementNode(globalData) - , m_ident(ident) - { - } + ContinueNode(JSGlobalData*); + ContinueNode(JSGlobalData*, const Identifier&); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - private: - Identifier m_ident; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_ident; }; class BreakNode : public StatementNode, public ThrowableExpressionData { public: - BreakNode(JSGlobalData* globalData) JSC_FAST_CALL - : StatementNode(globalData) - { - } - - BreakNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL - : StatementNode(globalData) - , m_ident(ident) - { - } + BreakNode(JSGlobalData*); + BreakNode(JSGlobalData*, const Identifier&); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - private: - Identifier m_ident; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_ident; }; class ReturnNode : public StatementNode, public ThrowableExpressionData { public: - ReturnNode(JSGlobalData* globalData, ExpressionNode* value) JSC_FAST_CALL - : StatementNode(globalData) - , m_value(value) - { - } - - virtual ~ReturnNode(); - virtual void releaseNodes(NodeReleaser&); + ReturnNode(JSGlobalData*, ExpressionNode* value); - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - virtual bool isReturnNode() const JSC_FAST_CALL { return true; } + ExpressionNode* value() { return m_value; } private: - RefPtr m_value; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + virtual bool isReturnNode() const { return true; } + + ExpressionNode* m_value; }; class WithNode : public StatementNode { public: - WithNode(JSGlobalData* globalData, ExpressionNode* expr, StatementNode* statement, uint32_t divot, uint32_t expressionLength) JSC_FAST_CALL - : StatementNode(globalData) - , m_expr(expr) - , m_statement(statement) - , m_divot(divot) - , m_expressionLength(expressionLength) - { - } - - virtual ~WithNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + WithNode(JSGlobalData*, ExpressionNode*, StatementNode*, uint32_t divot, uint32_t expressionLength); private: - RefPtr m_expr; - RefPtr m_statement; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; + StatementNode* m_statement; uint32_t m_divot; uint32_t m_expressionLength; }; class LabelNode : public StatementNode, public ThrowableExpressionData { public: - LabelNode(JSGlobalData* globalData, const Identifier& name, StatementNode* statement) JSC_FAST_CALL - : StatementNode(globalData) - , m_name(name) - , m_statement(statement) - { - } - - virtual ~LabelNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + LabelNode(JSGlobalData*, const Identifier& name, StatementNode*); private: - Identifier m_name; - RefPtr m_statement; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + const Identifier& m_name; + StatementNode* m_statement; }; class ThrowNode : public StatementNode, public ThrowableExpressionData { public: - ThrowNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : StatementNode(globalData) - , m_expr(expr) - { - } - - virtual ~ThrowNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + ThrowNode(JSGlobalData*, ExpressionNode*); private: - RefPtr m_expr; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; }; class TryNode : public StatementNode { public: - TryNode(JSGlobalData* globalData, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock) JSC_FAST_CALL - : StatementNode(globalData) - , m_tryBlock(tryBlock) - , m_exceptionIdent(exceptionIdent) - , m_catchBlock(catchBlock) - , m_finallyBlock(finallyBlock) - , m_catchHasEval(catchHasEval) - { - } - - virtual ~TryNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* dst = 0) JSC_FAST_CALL; + TryNode(JSGlobalData*, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock); private: - RefPtr m_tryBlock; - Identifier m_exceptionIdent; - RefPtr m_catchBlock; - RefPtr m_finallyBlock; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + StatementNode* m_tryBlock; + const Identifier& m_exceptionIdent; + StatementNode* m_catchBlock; + StatementNode* m_finallyBlock; bool m_catchHasEval; }; - class ParameterNode : public ParserRefCounted { + class ParameterNode : public ParserArenaFreeable { public: - ParameterNode(JSGlobalData* globalData, const Identifier& ident) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_ident(ident) - { - } + ParameterNode(JSGlobalData*, const Identifier&); + ParameterNode(JSGlobalData*, ParameterNode*, const Identifier&); - ParameterNode(JSGlobalData* globalData, ParameterNode* l, const Identifier& ident) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_ident(ident) - { - l->m_next = this; - } - - virtual ~ParameterNode(); - virtual void releaseNodes(NodeReleaser&); - - const Identifier& ident() const JSC_FAST_CALL { return m_ident; } - ParameterNode* nextParam() const JSC_FAST_CALL { return m_next.get(); } + const Identifier& ident() const { return m_ident; } + ParameterNode* nextParam() const { return m_next; } private: - Identifier m_ident; - RefPtr m_next; + const Identifier& m_ident; + ParameterNode* m_next; }; struct ScopeNodeData { + WTF_MAKE_FAST_ALLOCATED; + public: typedef DeclarationStacks::VarStack VarStack; typedef DeclarationStacks::FunctionStack FunctionStack; - ScopeNodeData(SourceElements*, VarStack*, FunctionStack*, int numConstants); + ScopeNodeData(ParserArena&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, int numConstants); + ParserArena m_arena; VarStack m_varStack; FunctionStack m_functionStack; int m_numConstants; - StatementVector m_children; - - void mark(); + SourceElements* m_statements; + IdentifierSet m_capturedVariables; }; - class ScopeNode : public StatementNode { + class ScopeNode : public StatementNode, public ParserArenaRefCounted { public: typedef DeclarationStacks::VarStack VarStack; typedef DeclarationStacks::FunctionStack FunctionStack; - ScopeNode(JSGlobalData*) JSC_FAST_CALL; - ScopeNode(JSGlobalData*, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, CodeFeatures, int numConstants) JSC_FAST_CALL; - virtual ~ScopeNode(); - virtual void releaseNodes(NodeReleaser&); + ScopeNode(JSGlobalData*, bool inStrictContext); + ScopeNode(JSGlobalData*, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, CodeFeatures, int numConstants); + + using ParserArenaRefCounted::operator new; - void adoptData(std::auto_ptr data) { m_data.adopt(data); } ScopeNodeData* data() const { return m_data.get(); } void destroyData() { m_data.clear(); } const SourceCode& source() const { return m_source; } - const UString& sourceURL() const JSC_FAST_CALL { return m_source.provider()->url(); } + const UString& sourceURL() const { return m_source.provider()->url(); } intptr_t sourceID() const { return m_source.provider()->asID(); } void setFeatures(CodeFeatures features) { m_features = features; } CodeFeatures features() { return m_features; } bool usesEval() const { return m_features & EvalFeature; } - bool usesArguments() const { return m_features & ArgumentsFeature; } + bool usesArguments() const { return (m_features & ArgumentsFeature) && !(m_features & ShadowsArgumentsFeature); } + bool isStrictMode() const { return m_features & StrictModeFeature; } void setUsesArguments() { m_features |= ArgumentsFeature; } bool usesThis() const { return m_features & ThisFeature; } - bool needsActivation() const { return m_features & (EvalFeature | ClosureFeature | WithFeature | CatchFeature); } + bool needsActivationForMoreThanVariables() const { ASSERT(m_data); return m_features & (EvalFeature | WithFeature | CatchFeature); } + bool needsActivation() const { ASSERT(m_data); return (hasCapturedVariables()) || (m_features & (EvalFeature | WithFeature | CatchFeature)); } + bool hasCapturedVariables() const { return !!m_data->m_capturedVariables.size(); } + size_t capturedVariableCount() const { return m_data->m_capturedVariables.size(); } + bool captures(const Identifier& ident) { return m_data->m_capturedVariables.contains(ident.impl()); } VarStack& varStack() { ASSERT(m_data); return m_data->m_varStack; } FunctionStack& functionStack() { ASSERT(m_data); return m_data->m_functionStack; } - StatementVector& children() { ASSERT(m_data); return m_data->m_children; } - int neededConstants() { ASSERT(m_data); @@ -2118,7 +1434,9 @@ namespace JSC { return m_data->m_numConstants + 2; } - virtual void mark() { } + StatementNode* singleStatement() const; + + void emitStatementsBytecode(BytecodeGenerator&, RegisterID* destination); protected: void setSource(const SourceCode& source) { m_source = source; } @@ -2131,262 +1449,139 @@ namespace JSC { class ProgramNode : public ScopeNode { public: - static ProgramNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL; + static const bool isFunctionNode = false; + static PassRefPtr create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants); - ProgramCodeBlock& bytecode(ScopeChainNode* scopeChain) JSC_FAST_CALL - { - if (!m_code) - generateBytecode(scopeChain); - return *m_code; - } + static const bool scopeIsFunction = false; private: - ProgramNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL; - - void generateBytecode(ScopeChainNode*) JSC_FAST_CALL; - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + ProgramNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants); - OwnPtr m_code; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; class EvalNode : public ScopeNode { public: - static EvalNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL; - - EvalCodeBlock& bytecode(ScopeChainNode* scopeChain) JSC_FAST_CALL - { - if (!m_code) - generateBytecode(scopeChain); - return *m_code; - } - - EvalCodeBlock& bytecodeForExceptionInfoReparse(ScopeChainNode*, CodeBlock*) JSC_FAST_CALL; + static const bool isFunctionNode = false; + static PassRefPtr create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants); - virtual void mark(); + static const bool scopeIsFunction = false; private: - EvalNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL; + EvalNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants); - void generateBytecode(ScopeChainNode*) JSC_FAST_CALL; - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - OwnPtr m_code; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); }; - class FunctionBodyNode : public ScopeNode { - friend class JIT; + class FunctionParameters : public Vector, public RefCounted { + WTF_MAKE_FAST_ALLOCATED; public: - static FunctionBodyNode* create(JSGlobalData*) JSC_FAST_CALL; - static FunctionBodyNode* create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL; - virtual ~FunctionBodyNode(); - - const Identifier* parameters() const JSC_FAST_CALL { return m_parameters; } - size_t parameterCount() const { return m_parameterCount; } - UString paramString() const JSC_FAST_CALL; - Identifier* copyParameters(); + static PassRefPtr create(ParameterNode* firstParameter) { return adoptRef(new FunctionParameters(firstParameter)); } - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - CodeBlock& bytecode(ScopeChainNode* scopeChain) JSC_FAST_CALL - { - ASSERT(scopeChain); - if (!m_code) - generateBytecode(scopeChain); - return *m_code; - } + private: + FunctionParameters(ParameterNode*); + }; - CodeBlock& generatedBytecode() JSC_FAST_CALL - { - ASSERT(m_code); - return *m_code; - } + class FunctionBodyNode : public ScopeNode { + public: + static const bool isFunctionNode = true; + static FunctionBodyNode* create(JSGlobalData*, bool isStrictMode); + static PassRefPtr create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants); - bool isGenerated() JSC_FAST_CALL - { - return m_code; - } + FunctionParameters* parameters() const { return m_parameters.get(); } + size_t parameterCount() const { return m_parameters->size(); } - virtual void mark(); + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - void finishParsing(const SourceCode&, ParameterNode*); - void finishParsing(Identifier* parameters, size_t parameterCount); + void finishParsing(const SourceCode&, ParameterNode*, const Identifier&); + void finishParsing(PassRefPtr, const Identifier&); - UString toSourceString() const JSC_FAST_CALL { return source().toString(); } - - // These objects are ref/deref'd a lot in the scope chain, so this is a faster ref/deref. - // If the virtual machine changes so this doesn't happen as much we can change back. - void ref() - { - if (++m_refCount == 1) - ScopeNode::ref(); - } - void deref() - { - ASSERT(m_refCount); - if (!--m_refCount) - ScopeNode::deref(); - } + const Identifier& ident() { return m_ident; } - CodeBlock& bytecodeForExceptionInfoReparse(ScopeChainNode*, CodeBlock*) JSC_FAST_CALL; + static const bool scopeIsFunction = true; private: - FunctionBodyNode(JSGlobalData*) JSC_FAST_CALL; - FunctionBodyNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, const SourceCode&, CodeFeatures, int numConstants) JSC_FAST_CALL; + FunctionBodyNode(JSGlobalData*, bool inStrictContext); + FunctionBodyNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants); - void generateBytecode(ScopeChainNode*) JSC_FAST_CALL; - - Identifier* m_parameters; - size_t m_parameterCount; - OwnPtr m_code; - unsigned m_refCount; + Identifier m_ident; + RefPtr m_parameters; }; class FuncExprNode : public ExpressionNode { public: - FuncExprNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0) JSC_FAST_CALL - : ExpressionNode(globalData) - , m_ident(ident) - , m_parameter(parameter) - , m_body(body) - { - m_body->finishParsing(source, m_parameter.get()); - } - - virtual ~FuncExprNode(); - virtual void releaseNodes(NodeReleaser&); + FuncExprNode(JSGlobalData*, const Identifier&, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0); - virtual bool isFuncExprNode() const JSC_FAST_CALL { return true; } + FunctionBodyNode* body() { return m_body; } - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - JSFunction* makeFunction(ExecState*, ScopeChainNode*) JSC_FAST_CALL; + private: + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); - FunctionBodyNode* body() { return m_body.get(); } + virtual bool isFuncExprNode() const { return true; } - private: - Identifier m_ident; - RefPtr m_parameter; - RefPtr m_body; + FunctionBodyNode* m_body; }; class FuncDeclNode : public StatementNode { public: - FuncDeclNode(JSGlobalData* globalData, const Identifier& ident, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0) JSC_FAST_CALL - : StatementNode(globalData) - , m_ident(ident) - , m_parameter(parameter) - , m_body(body) - { - m_body->finishParsing(source, m_parameter.get()); - } - - virtual ~FuncDeclNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; - - JSFunction* makeFunction(ExecState*, ScopeChainNode*) JSC_FAST_CALL; - - Identifier m_ident; + FuncDeclNode(JSGlobalData*, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0); - FunctionBodyNode* body() { return m_body.get(); } + FunctionBodyNode* body() { return m_body; } private: - RefPtr m_parameter; - RefPtr m_body; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + FunctionBodyNode* m_body; }; - class CaseClauseNode : public ParserRefCounted { + class CaseClauseNode : public ParserArenaFreeable { public: - CaseClauseNode(JSGlobalData* globalData, ExpressionNode* expr) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_expr(expr) - { - } - - CaseClauseNode(JSGlobalData* globalData, ExpressionNode* expr, SourceElements* children) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_expr(expr) - { - if (children) - children->releaseContentsIntoVector(m_children); - } + CaseClauseNode(JSGlobalData*, ExpressionNode*, SourceElements* = 0); - virtual ~CaseClauseNode(); - virtual void releaseNodes(NodeReleaser&); + ExpressionNode* expr() const { return m_expr; } - ExpressionNode* expr() const { return m_expr.get(); } - StatementVector& children() { return m_children; } + void emitBytecode(BytecodeGenerator&, RegisterID* destination); private: - RefPtr m_expr; - StatementVector m_children; + ExpressionNode* m_expr; + SourceElements* m_statements; }; - class ClauseListNode : public ParserRefCounted { + class ClauseListNode : public ParserArenaFreeable { public: - ClauseListNode(JSGlobalData* globalData, CaseClauseNode* clause) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_clause(clause) - { - } - - ClauseListNode(JSGlobalData* globalData, ClauseListNode* clauseList, CaseClauseNode* clause) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_clause(clause) - { - clauseList->m_next = this; - } - - virtual ~ClauseListNode(); - virtual void releaseNodes(NodeReleaser&); + ClauseListNode(JSGlobalData*, CaseClauseNode*); + ClauseListNode(JSGlobalData*, ClauseListNode*, CaseClauseNode*); - CaseClauseNode* getClause() const JSC_FAST_CALL { return m_clause.get(); } - ClauseListNode* getNext() const JSC_FAST_CALL { return m_next.get(); } + CaseClauseNode* getClause() const { return m_clause; } + ClauseListNode* getNext() const { return m_next; } private: - RefPtr m_clause; - RefPtr m_next; + CaseClauseNode* m_clause; + ClauseListNode* m_next; }; - class CaseBlockNode : public ParserRefCounted { + class CaseBlockNode : public ParserArenaFreeable { public: - CaseBlockNode(JSGlobalData* globalData, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) JSC_FAST_CALL - : ParserRefCounted(globalData) - , m_list1(list1) - , m_defaultClause(defaultClause) - , m_list2(list2) - { - } - - virtual ~CaseBlockNode(); - virtual void releaseNodes(NodeReleaser&); + CaseBlockNode(JSGlobalData*, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2); - RegisterID* emitBytecodeForBlock(BytecodeGenerator&, RegisterID* input, RegisterID* dst = 0) JSC_FAST_CALL; + RegisterID* emitBytecodeForBlock(BytecodeGenerator&, RegisterID* input, RegisterID* destination); private: SwitchInfo::SwitchType tryOptimizedSwitch(Vector& literalVector, int32_t& min_num, int32_t& max_num); - RefPtr m_list1; - RefPtr m_defaultClause; - RefPtr m_list2; + ClauseListNode* m_list1; + CaseClauseNode* m_defaultClause; + ClauseListNode* m_list2; }; class SwitchNode : public StatementNode { public: - SwitchNode(JSGlobalData* globalData, ExpressionNode* expr, CaseBlockNode* block) JSC_FAST_CALL - : StatementNode(globalData) - , m_expr(expr) - , m_block(block) - { - } - - virtual ~SwitchNode(); - virtual void releaseNodes(NodeReleaser&); - - virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) JSC_FAST_CALL; + SwitchNode(JSGlobalData*, ExpressionNode*, CaseBlockNode*); private: - RefPtr m_expr; - RefPtr m_block; + virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0); + + ExpressionNode* m_expr; + CaseBlockNode* m_block; }; struct ElementList { @@ -2421,4 +1616,4 @@ namespace JSC { } // namespace JSC -#endif // NODES_H_ +#endif // Nodes_h