src/parser.cc - Issue 6771058: Support placement new syntax for zone objects and start using it in the parser.

Unified Diff: src/parser.cc

Issue 6771058: Support placement new syntax for zone objects and start using it in the parser. (Closed)

Patch Set: Update RegExpBuilder Created 9 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: src/parser.cc

diff --git a/src/parser.cc b/src/parser.cc

index e85206eeeb5129fa364ea26a03505f72e254937a..22d4d3f1fe0ed9b101e2d666b1928f219f1c650d 100644

--- a/src/parser.cc

+++ b/src/parser.cc

@@ -88,12 +88,13 @@ class PositionStack {

RegExpBuilder::RegExpBuilder()

- : pending_empty_(false),

- characters_(NULL),

- terms_(),

- alternatives_()

+ : zone_(Isolate::Current()->zone()),

+ pending_empty_(false),

+ characters_(NULL),

+ terms_(),

+ alternatives_()

#ifdef DEBUG

- , last_added_(ADD_NONE)

+ , last_added_(ADD_NONE)

#endif

{}

@@ -101,7 +102,7 @@ RegExpBuilder::RegExpBuilder()

void RegExpBuilder::FlushCharacters() {

pending_empty_ = false;

if (characters_ != NULL) {

- RegExpTree* atom = new RegExpAtom(characters_->ToConstVector());

+ RegExpTree* atom = new(zone()) RegExpAtom(characters_->ToConstVector());

Mads Ager (chromium) 2011/04/01 17:08:38 We have to decide whether we want a space between

characters_ = NULL;

text_.Add(atom);

LAST(ADD_ATOM);

@@ -117,7 +118,7 @@ void RegExpBuilder::FlushText() {

} else if (num_text == 1) {

terms_.Add(text_.last());

} else {

- RegExpText* text = new RegExpText();

+ RegExpText* text = new(zone()) RegExpText();

for (int i = 0; i < num_text; i++)

text_.Get(i)->AppendToText(text);

terms_.Add(text);

@@ -178,7 +179,7 @@ void RegExpBuilder::FlushTerms() {

} else if (num_terms == 1) {

alternative = terms_.last();

} else {

- alternative = new RegExpAlternative(terms_.GetList());

+ alternative = new(zone()) RegExpAlternative(terms_.GetList());

}

alternatives_.Add(alternative);

terms_.Clear();

@@ -195,7 +196,7 @@ RegExpTree* RegExpBuilder::ToRegExp() {

if (num_alternatives == 1) {

return alternatives_.last();

}

- return new RegExpDisjunction(alternatives_.GetList());

+ return new(zone()) RegExpDisjunction(alternatives_.GetList());

}

@@ -214,11 +215,11 @@ void RegExpBuilder::AddQuantifierToAtom(int min,

int num_chars = char_vector.length();

if (num_chars > 1) {

Vector<const uc16> prefix = char_vector.SubVector(0, num_chars - 1);

- text_.Add(new RegExpAtom(prefix));

+ text_.Add(new(zone()) RegExpAtom(prefix));

char_vector = char_vector.SubVector(num_chars - 1, num_chars);

}

characters_ = NULL;

- atom = new RegExpAtom(char_vector);

+ atom = new(zone()) RegExpAtom(char_vector);

FlushText();

} else if (text_.length() > 0) {

ASSERT(last_added_ == ADD_ATOM);

@@ -241,7 +242,7 @@ void RegExpBuilder::AddQuantifierToAtom(int min,

UNREACHABLE();

return;

}

- terms_.Add(new RegExpQuantifier(min, max, type, atom));

+ terms_.Add(new(zone()) RegExpQuantifier(min, max, type, atom));

LAST(ADD_TERM);

}

@@ -408,7 +409,7 @@ unsigned* ScriptDataImpl::ReadAddress(int position) {

Scope* Parser::NewScope(Scope* parent, Scope::Type type, bool inside_with) {

- Scope* result = new Scope(parent, type);

+ Scope* result = new(zone()) Scope(parent, type);

result->Initialize(inside_with);

return result;

}

@@ -601,7 +602,7 @@ FunctionLiteral* Parser::ParseProgram(Handle<String> source,

HistogramTimerScope timer(isolate()->counters()->parse());

isolate()->counters()->total_parse_size()->Increment(source->length());

- fni_ = new FuncNameInferrer();

+ fni_ = new(zone()) FuncNameInferrer();

// Initialize parser state.

source->TryFlatten();

@@ -652,7 +653,7 @@ FunctionLiteral* Parser::DoParseProgram(Handle<String> source,

CheckOctalLiteral(beg_loc, scanner().location().end_pos, &ok);

}

if (ok) {

- result = new FunctionLiteral(

+ result = new(zone()) FunctionLiteral(

no_name,

top_scope_,

body,

@@ -713,7 +714,7 @@ FunctionLiteral* Parser::ParseLazy(CompilationInfo* info,

ASSERT(target_stack_ == NULL);

Handle<String> name(String::cast(shared_info->name()));

- fni_ = new FuncNameInferrer();

+ fni_ = new(zone()) FuncNameInferrer();

fni_->PushEnclosingName(name);

mode_ = PARSE_EAGERLY;

@@ -1252,7 +1253,7 @@ Statement* Parser::ParseStatement(ZoneStringList* labels, bool* ok) {

// one must take great care not to treat it as a

// fall-through. It is much easier just to wrap the entire

// try-statement in a statement block and put the labels there

- Block* result = new Block(labels, 1, false);

+ Block* result = new(zone()) Block(labels, 1, false);

Target target(&this->target_stack_, result);

TryStatement* statement = ParseTryStatement(CHECK_OK);

if (statement) {

@@ -1350,13 +1351,13 @@ VariableProxy* Parser::Declare(Handle<String> name,

// a performance issue since it may lead to repeated

// Runtime::DeclareContextSlot() calls.

VariableProxy* proxy = top_scope_->NewUnresolved(name, inside_with());

- top_scope_->AddDeclaration(new Declaration(proxy, mode, fun));

+ top_scope_->AddDeclaration(new(zone()) Declaration(proxy, mode, fun));

// For global const variables we bind the proxy to a variable.

if (mode == Variable::CONST && top_scope_->is_global_scope()) {

ASSERT(resolve); // should be set by all callers

Variable::Kind kind = Variable::NORMAL;

- var = new Variable(top_scope_, name, Variable::CONST, true, kind);

+ var = new(zone()) Variable(top_scope_, name, Variable::CONST, true, kind);

}

// If requested and we have a local variable, bind the proxy to the variable

@@ -1444,10 +1445,11 @@ Statement* Parser::ParseNativeDeclaration(bool* ok) {

// TODO(1240846): It's weird that native function declarations are

// introduced dynamically when we meet their declarations, whereas

// other functions are setup when entering the surrounding scope.

- SharedFunctionInfoLiteral* lit = new SharedFunctionInfoLiteral(shared);

+ SharedFunctionInfoLiteral* lit =

+ new(zone()) SharedFunctionInfoLiteral(shared);

VariableProxy* var = Declare(name, Variable::VAR, NULL, true, CHECK_OK);

- return new ExpressionStatement(

- new Assignment(Token::INIT_VAR, var, lit, RelocInfo::kNoPosition));

+ return new(zone()) ExpressionStatement(new(zone()) Assignment(

+ Token::INIT_VAR, var, lit, RelocInfo::kNoPosition));

}

@@ -1479,7 +1481,7 @@ Block* Parser::ParseBlock(ZoneStringList* labels, bool* ok) {

// (ECMA-262, 3rd, 12.2)

// Construct block expecting 16 statements.

- Block* result = new Block(labels, 16, false);

+ Block* result = new(zone()) Block(labels, 16, false);

Target target(&this->target_stack_, result);

Expect(Token::LBRACE, CHECK_OK);

while (peek() != Token::RBRACE) {

@@ -1549,7 +1551,7 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN,

// is inside an initializer block, it is ignored.

// Create new block with one expected declaration.

- Block* block = new Block(NULL, 1, true);

+ Block* block = new(zone()) Block(NULL, 1, true);

VariableProxy* last_var = NULL; // the last variable declared

int nvars = 0; // the number of variables declared

do {

@@ -1650,7 +1652,8 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN,

if (top_scope_->is_global_scope()) {

// Compute the arguments for the runtime call.

ZoneList<Expression*>* arguments = new ZoneList<Expression*>(3);

- arguments->Add(new Literal(name)); // we have at least 1 parameter

+ // We have at least 1 parameter.

+ arguments->Add(new(zone()) Literal(name));

CallRuntime* initialize;

if (is_const) {

@@ -1662,7 +1665,7 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN,

// Note that the function does different things depending on

// the number of arguments (1 or 2).

initialize =

- new CallRuntime(

+ new(zone()) CallRuntime(

isolate()->factory()->InitializeConstGlobal_symbol(),

Runtime::FunctionForId(Runtime::kInitializeConstGlobal),

arguments);

@@ -1686,13 +1689,13 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN,

// Note that the function does different things depending on

// the number of arguments (2 or 3).

initialize =

- new CallRuntime(

+ new(zone()) CallRuntime(

isolate()->factory()->InitializeVarGlobal_symbol(),

Runtime::FunctionForId(Runtime::kInitializeVarGlobal),

arguments);

}

- block->AddStatement(new ExpressionStatement(initialize));

+ block->AddStatement(new(zone()) ExpressionStatement(initialize));

}

// Add an assignment node to the initialization statement block if

@@ -1707,8 +1710,11 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN,

// the top context for variables). Sigh...

if (value != NULL) {

Token::Value op = (is_const ? Token::INIT_CONST : Token::INIT_VAR);

- Assignment* assignment = new Assignment(op, last_var, value, position);

- if (block) block->AddStatement(new ExpressionStatement(assignment));

+ Assignment* assignment =

+ new(zone()) Assignment(op, last_var, value, position);

+ if (block) {

+ block->AddStatement(new(zone()) ExpressionStatement(assignment));

+ }

}

if (fni_ != NULL) fni_->Leave();

@@ -1774,7 +1780,7 @@ Statement* Parser::ParseExpressionOrLabelledStatement(ZoneStringList* labels,

// Parsed expression statement.

ExpectSemicolon(CHECK_OK);

- return new ExpressionStatement(expr);

+ return new(zone()) ExpressionStatement(expr);

}

@@ -1794,7 +1800,7 @@ IfStatement* Parser::ParseIfStatement(ZoneStringList* labels, bool* ok) {

} else {

else_statement = EmptyStatement();

}

- return new IfStatement(condition, then_statement, else_statement);

+ return new(zone()) IfStatement(condition, then_statement, else_statement);

}

@@ -1824,7 +1830,7 @@ Statement* Parser::ParseContinueStatement(bool* ok) {

return NULL;

}

ExpectSemicolon(CHECK_OK);

- return new ContinueStatement(target);

+ return new(zone()) ContinueStatement(target);

}

@@ -1859,7 +1865,7 @@ Statement* Parser::ParseBreakStatement(ZoneStringList* labels, bool* ok) {

return NULL;

}

ExpectSemicolon(CHECK_OK);

- return new BreakStatement(target);

+ return new(zone()) BreakStatement(target);

}

@@ -1880,7 +1886,7 @@ Statement* Parser::ParseReturnStatement(bool* ok) {

if (!top_scope_->is_function_scope()) {

Handle<String> type = isolate()->factory()->illegal_return_symbol();

Expression* throw_error = NewThrowSyntaxError(type, Handle<Object>::null());

- return new ExpressionStatement(throw_error);

+ return new(zone()) ExpressionStatement(throw_error);

}

Token::Value tok = peek();

@@ -1889,12 +1895,12 @@ Statement* Parser::ParseReturnStatement(bool* ok) {

tok == Token::RBRACE ||

tok == Token::EOS) {

ExpectSemicolon(CHECK_OK);

- return new ReturnStatement(GetLiteralUndefined());

+ return new(zone()) ReturnStatement(GetLiteralUndefined());

}

Expression* expr = ParseExpression(true, CHECK_OK);

ExpectSemicolon(CHECK_OK);

- return new ReturnStatement(expr);

+ return new(zone()) ReturnStatement(expr);

}

@@ -1915,21 +1921,21 @@ Block* Parser::WithHelper(Expression* obj,

// Create resulting block with two statements.

// 1: Evaluate the with expression.

// 2: The try-finally block evaluating the body.

- Block* result = new Block(NULL, 2, false);

+ Block* result = new(zone()) Block(NULL, 2, false);

if (result != NULL) {

- result->AddStatement(new WithEnterStatement(obj, is_catch_block));

+ result->AddStatement(new(zone()) WithEnterStatement(obj, is_catch_block));

// Create body block.

- Block* body = new Block(NULL, 1, false);

+ Block* body = new(zone()) Block(NULL, 1, false);

body->AddStatement(stat);

// Create exit block.

- Block* exit = new Block(NULL, 1, false);

- exit->AddStatement(new WithExitStatement());

+ Block* exit = new(zone()) Block(NULL, 1, false);

+ exit->AddStatement(new(zone()) WithExitStatement());

// Return a try-finally statement.

- TryFinallyStatement* wrapper = new TryFinallyStatement(body, exit);

+ TryFinallyStatement* wrapper = new(zone()) TryFinallyStatement(body, exit);

wrapper->set_escaping_targets(collector.targets());

result->AddStatement(wrapper);

}

@@ -1986,7 +1992,7 @@ CaseClause* Parser::ParseCaseClause(bool* default_seen_ptr, bool* ok) {

statements->Add(stat);

}

- return new CaseClause(label, statements, pos);

+ return new(zone()) CaseClause(label, statements, pos);

}

@@ -1995,7 +2001,7 @@ SwitchStatement* Parser::ParseSwitchStatement(ZoneStringList* labels,

// SwitchStatement ::

// 'switch' '(' Expression ')' '{' CaseClause* '}'

- SwitchStatement* statement = new SwitchStatement(labels);

+ SwitchStatement* statement = new(zone()) SwitchStatement(labels);

Target target(&this->target_stack_, statement);

Expect(Token::SWITCH, CHECK_OK);

@@ -2031,7 +2037,7 @@ Statement* Parser::ParseThrowStatement(bool* ok) {

Expression* exception = ParseExpression(true, CHECK_OK);

ExpectSemicolon(CHECK_OK);

- return new ExpressionStatement(new Throw(exception, pos));

+ return new(zone()) ExpressionStatement(new(zone()) Throw(exception, pos));

}

@@ -2095,9 +2101,10 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

// executing the finally block.

catch_var =

top_scope_->NewTemporary(isolate()->factory()->catch_var_symbol());

- Literal* name_literal = new Literal(name);

- VariableProxy* catch_var_use = new VariableProxy(catch_var);

- Expression* obj = new CatchExtensionObject(name_literal, catch_var_use);

+ Literal* name_literal = new(zone()) Literal(name);

+ VariableProxy* catch_var_use = new(zone()) VariableProxy(catch_var);

+ Expression* obj =

+ new(zone()) CatchExtensionObject(name_literal, catch_var_use);

{ Target target(&this->target_stack_, &catch_collector);

catch_block = WithHelper(obj, NULL, true, CHECK_OK);

}

@@ -2121,11 +2128,11 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

// 'try { try { } catch { } } finally { }'

if (catch_block != NULL && finally_block != NULL) {

- VariableProxy* catch_var_defn = new VariableProxy(catch_var);

+ VariableProxy* catch_var_defn = new(zone()) VariableProxy(catch_var);

TryCatchStatement* statement =

- new TryCatchStatement(try_block, catch_var_defn, catch_block);

+ new(zone()) TryCatchStatement(try_block, catch_var_defn, catch_block);

statement->set_escaping_targets(collector.targets());

- try_block = new Block(NULL, 1, false);

+ try_block = new(zone()) Block(NULL, 1, false);

try_block->AddStatement(statement);

catch_block = NULL;

}

@@ -2133,12 +2140,13 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

TryStatement* result = NULL;

if (catch_block != NULL) {

ASSERT(finally_block == NULL);

- VariableProxy* catch_var_defn = new VariableProxy(catch_var);

- result = new TryCatchStatement(try_block, catch_var_defn, catch_block);

+ VariableProxy* catch_var_defn = new(zone()) VariableProxy(catch_var);

+ result =

+ new(zone()) TryCatchStatement(try_block, catch_var_defn, catch_block);

result->set_escaping_targets(collector.targets());

} else {

ASSERT(finally_block != NULL);

- result = new TryFinallyStatement(try_block, finally_block);

+ result = new(zone()) TryFinallyStatement(try_block, finally_block);

// Add the jump targets of the try block and the catch block.

for (int i = 0; i < collector.targets()->length(); i++) {

catch_collector.AddTarget(collector.targets()->at(i));

@@ -2156,7 +2164,7 @@ DoWhileStatement* Parser::ParseDoWhileStatement(ZoneStringList* labels,

// 'do' Statement 'while' '(' Expression ')' ';'

lexical_scope_->AddLoop();

- DoWhileStatement* loop = new DoWhileStatement(labels);

+ DoWhileStatement* loop = new(zone()) DoWhileStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::DO, CHECK_OK);

@@ -2189,7 +2197,7 @@ WhileStatement* Parser::ParseWhileStatement(ZoneStringList* labels, bool* ok) {

// 'while' '(' Expression ')' Statement

lexical_scope_->AddLoop();

- WhileStatement* loop = new WhileStatement(labels);

+ WhileStatement* loop = new(zone()) WhileStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::WHILE, CHECK_OK);

@@ -2219,7 +2227,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

Block* variable_statement =

ParseVariableDeclarations(false, &each, CHECK_OK);

if (peek() == Token::IN && each != NULL) {

- ForInStatement* loop = new ForInStatement(labels);

+ ForInStatement* loop = new(zone()) ForInStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::IN, CHECK_OK);

@@ -2228,7 +2236,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

Statement* body = ParseStatement(NULL, CHECK_OK);

loop->Initialize(each, enumerable, body);

- Block* result = new Block(NULL, 2, false);

+ Block* result = new(zone()) Block(NULL, 2, false);

result->AddStatement(variable_statement);

result->AddStatement(loop);

// Parsed for-in loop w/ variable/const declaration.

@@ -2249,7 +2257,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

isolate()->factory()->invalid_lhs_in_for_in_symbol();

expression = NewThrowReferenceError(type);

}

- ForInStatement* loop = new ForInStatement(labels);

+ ForInStatement* loop = new(zone()) ForInStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::IN, CHECK_OK);

@@ -2262,13 +2270,13 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

return loop;

} else {

- init = new ExpressionStatement(expression);

+ init = new(zone()) ExpressionStatement(expression);

}

// Standard 'for' loop

- ForStatement* loop = new ForStatement(labels);

+ ForStatement* loop = new(zone()) ForStatement(labels);

Target target(&this->target_stack_, loop);

// Parsed initializer at this point.

@@ -2284,7 +2292,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

Statement* next = NULL;

if (peek() != Token::RPAREN) {

Expression* exp = ParseExpression(true, CHECK_OK);

- next = new ExpressionStatement(exp);

+ next = new(zone()) ExpressionStatement(exp);

}

Expect(Token::RPAREN, CHECK_OK);

@@ -2305,7 +2313,7 @@ Expression* Parser::ParseExpression(bool accept_IN, bool* ok) {

Expect(Token::COMMA, CHECK_OK);

int position = scanner().location().beg_pos;

Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);

- result = new BinaryOperation(Token::COMMA, result, right, position);

+ result = new(zone()) BinaryOperation(Token::COMMA, result, right, position);

}

return result;

}

@@ -2377,7 +2385,7 @@ Expression* Parser::ParseAssignmentExpression(bool accept_IN, bool* ok) {

fni_->Leave();

}

- return new Assignment(op, expression, right, pos);

+ return new(zone()) Assignment(op, expression, right, pos);

}

@@ -2399,7 +2407,7 @@ Expression* Parser::ParseConditionalExpression(bool accept_IN, bool* ok) {

Expect(Token::COLON, CHECK_OK);

int right_position = scanner().peek_location().beg_pos;

Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);

- return new Conditional(expression, left, right,

+ return new(zone()) Conditional(expression, left, right,

left_position, right_position);

}

@@ -2487,12 +2495,12 @@ Expression* Parser::ParseBinaryExpression(int prec, bool accept_IN, bool* ok) {

x = NewCompareNode(cmp, x, y, position);

if (cmp != op) {

// The comparison was negated - add a NOT.

- x = new UnaryOperation(Token::NOT, x);

+ x = new(zone()) UnaryOperation(Token::NOT, x);

}

} else {

// We have a "normal" binary operation.

- x = new BinaryOperation(op, x, y, position);

+ x = new(zone()) BinaryOperation(op, x, y, position);

}

@@ -2509,15 +2517,15 @@ Expression* Parser::NewCompareNode(Token::Value op,

bool is_strict = (op == Token::EQ_STRICT);

Literal* x_literal = x->AsLiteral();

if (x_literal != NULL && x_literal->IsNull()) {

- return new CompareToNull(is_strict, y);

+ return new(zone()) CompareToNull(is_strict, y);

}

Literal* y_literal = y->AsLiteral();

if (y_literal != NULL && y_literal->IsNull()) {

- return new CompareToNull(is_strict, x);

+ return new(zone()) CompareToNull(is_strict, x);

}

- return new CompareOperation(op, x, y, position);

+ return new(zone()) CompareOperation(op, x, y, position);

}

@@ -2564,7 +2572,7 @@ Expression* Parser::ParseUnaryExpression(bool* ok) {

}

- return new UnaryOperation(op, expression);

+ return new(zone()) UnaryOperation(op, expression);

} else if (Token::IsCountOp(op)) {

op = Next();

@@ -2585,8 +2593,9 @@ Expression* Parser::ParseUnaryExpression(bool* ok) {

}

int position = scanner().location().beg_pos;

- IncrementOperation* increment = new IncrementOperation(op, expression);

- return new CountOperation(true /* prefix */, increment, position);

+ IncrementOperation* increment =

+ new(zone()) IncrementOperation(op, expression);

+ return new(zone()) CountOperation(true /* prefix */, increment, position);

} else {

return ParsePostfixExpression(ok);

@@ -2618,8 +2627,10 @@ Expression* Parser::ParsePostfixExpression(bool* ok) {

Token::Value next = Next();

int position = scanner().location().beg_pos;

- IncrementOperation* increment = new IncrementOperation(next, expression);

- expression = new CountOperation(false /* postfix */, increment, position);

+ IncrementOperation* increment =

+ new(zone()) IncrementOperation(next, expression);

+ expression =

+ new(zone()) CountOperation(false /* postfix */, increment, position);

}

return expression;

}

@@ -2642,7 +2653,7 @@ Expression* Parser::ParseLeftHandSideExpression(bool* ok) {

Consume(Token::LBRACK);

int pos = scanner().location().beg_pos;

Expression* index = ParseExpression(true, CHECK_OK);

- result = new Property(result, index, pos);

+ result = new(zone()) Property(result, index, pos);

Expect(Token::RBRACK, CHECK_OK);

break;

}

@@ -2680,7 +2691,7 @@ Expression* Parser::ParseLeftHandSideExpression(bool* ok) {

Consume(Token::PERIOD);

int pos = scanner().location().beg_pos;

Handle<String> name = ParseIdentifierName(CHECK_OK);

- result = new Property(result, new Literal(name), pos);

+ result = new(zone()) Property(result, new(zone()) Literal(name), pos);

if (fni_ != NULL) fni_->PushLiteralName(name);

break;

}

@@ -2716,7 +2727,7 @@ Expression* Parser::ParseNewPrefix(PositionStack* stack, bool* ok) {

if (!stack->is_empty()) {

int last = stack->pop();

- result = new CallNew(result, new ZoneList<Expression*>(0), last);

+ result = new(zone()) CallNew(result, new ZoneList<Expression*>(0), last);

}

return result;

}

@@ -2761,7 +2772,7 @@ Expression* Parser::ParseMemberWithNewPrefixesExpression(PositionStack* stack,

Consume(Token::LBRACK);

int pos = scanner().location().beg_pos;

Expression* index = ParseExpression(true, CHECK_OK);

- result = new Property(result, index, pos);

+ result = new(zone()) Property(result, index, pos);

Expect(Token::RBRACK, CHECK_OK);

break;

}

@@ -2769,7 +2780,7 @@ Expression* Parser::ParseMemberWithNewPrefixesExpression(PositionStack* stack,

Consume(Token::PERIOD);

int pos = scanner().location().beg_pos;

Handle<String> name = ParseIdentifierName(CHECK_OK);

- result = new Property(result, new Literal(name), pos);

+ result = new(zone()) Property(result, new(zone()) Literal(name), pos);

if (fni_ != NULL) fni_->PushLiteralName(name);

break;

}

@@ -2797,7 +2808,7 @@ DebuggerStatement* Parser::ParseDebuggerStatement(bool* ok) {

Expect(Token::DEBUGGER, CHECK_OK);

ExpectSemicolon(CHECK_OK);

- return new DebuggerStatement();

+ return new(zone()) DebuggerStatement();

}

@@ -2866,17 +2877,17 @@ Expression* Parser::ParsePrimaryExpression(bool* ok) {

case Token::NULL_LITERAL:

Consume(Token::NULL_LITERAL);

- result = new Literal(isolate()->factory()->null_value());

+ result = new(zone()) Literal(isolate()->factory()->null_value());

break;

case Token::TRUE_LITERAL:

Consume(Token::TRUE_LITERAL);

- result = new Literal(isolate()->factory()->true_value());

+ result = new(zone()) Literal(isolate()->factory()->true_value());

break;

case Token::FALSE_LITERAL:

Consume(Token::FALSE_LITERAL);

- result = new Literal(isolate()->factory()->false_value());

+ result = new(zone()) Literal(isolate()->factory()->false_value());

break;

case Token::IDENTIFIER:

@@ -2901,7 +2912,7 @@ Expression* Parser::ParsePrimaryExpression(bool* ok) {

case Token::STRING: {

Consume(Token::STRING);

Handle<String> symbol = GetSymbol(CHECK_OK);

- result = new Literal(symbol);

+ result = new(zone()) Literal(symbol);

if (fni_ != NULL) fni_->PushLiteralName(symbol);

break;

}

@@ -3028,7 +3039,7 @@ Expression* Parser::ParseArrayLiteral(bool* ok) {

literals->set_map(isolate()->heap()->fixed_cow_array_map());

}

- return new ArrayLiteral(literals, values,

+ return new(zone()) ArrayLiteral(literals, values,

literal_index, is_simple, depth);

}

@@ -3306,7 +3317,7 @@ ObjectLiteral::Property* Parser::ParseObjectLiteralGetSet(bool is_getter,

// Allow any number of parameters for compatiabilty with JSC.

// Specification only allows zero parameters for get and one for set.

ObjectLiteral::Property* property =

- new ObjectLiteral::Property(is_getter, value);

+ new(zone()) ObjectLiteral::Property(is_getter, value);

return property;

} else {

ReportUnexpectedToken(next);

@@ -3372,7 +3383,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

}

// Failed to parse as get/set property, so it's just a property

// called "get" or "set".

- key = new Literal(id);

+ key = new(zone()) Literal(id);

break;

}

case Token::STRING: {

@@ -3384,7 +3395,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

key = NewNumberLiteral(index);

break;

}

- key = new Literal(string);

+ key = new(zone()) Literal(string);

break;

}

case Token::NUMBER: {

@@ -3399,7 +3410,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

if (Token::IsKeyword(next)) {

Consume(next);

Handle<String> string = GetSymbol(CHECK_OK);

- key = new Literal(string);

+ key = new(zone()) Literal(string);

} else {

// Unexpected token.

Token::Value next = Next();

@@ -3413,7 +3424,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

Expression* value = ParseAssignmentExpression(true, CHECK_OK);

ObjectLiteral::Property* property =

- new ObjectLiteral::Property(key, value);

+ new(zone()) ObjectLiteral::Property(key, value);

// Mark object literals that contain function literals and pretenure the

// literal so it can be added as a constant function property.

@@ -3452,7 +3463,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

&is_simple,

&fast_elements,

&depth);

- return new ObjectLiteral(constant_properties,

+ return new(zone()) ObjectLiteral(constant_properties,

properties,

literal_index,

is_simple,

@@ -3477,7 +3488,7 @@ Expression* Parser::ParseRegExpLiteral(bool seen_equal, bool* ok) {

Handle<String> js_flags = NextLiteralString(TENURED);

Next();

- return new RegExpLiteral(js_pattern, js_flags, literal_index);

+ return new(zone()) RegExpLiteral(js_pattern, js_flags, literal_index);

}

@@ -3580,9 +3591,9 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> var_name,

VariableProxy* fproxy =

top_scope_->NewUnresolved(function_name, inside_with());

fproxy->BindTo(fvar);

- body->Add(new ExpressionStatement(

- new Assignment(Token::INIT_CONST, fproxy,

- new ThisFunction(),

+ body->Add(new(zone()) ExpressionStatement(

+ new(zone()) Assignment(Token::INIT_CONST, fproxy,

+ new(zone()) ThisFunction(),

RelocInfo::kNoPosition)));

}

@@ -3676,7 +3687,7 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> var_name,

}

FunctionLiteral* function_literal =

- new FunctionLiteral(name,

+ new(zone()) FunctionLiteral(name,

top_scope_,

body,

materialized_literal_count,

@@ -3738,7 +3749,7 @@ Expression* Parser::ParseV8Intrinsic(bool* ok) {

}

// We have a valid intrinsics call or a call to a builtin.

- return new CallRuntime(name, function, args);

+ return new(zone()) CallRuntime(name, function, args);

}

@@ -3793,12 +3804,12 @@ void Parser::ExpectSemicolon(bool* ok) {

Literal* Parser::GetLiteralUndefined() {

- return new Literal(isolate()->factory()->undefined_value());

+ return new(zone()) Literal(isolate()->factory()->undefined_value());

}

Literal* Parser::GetLiteralTheHole() {

- return new Literal(isolate()->factory()->the_hole_value());

+ return new(zone()) Literal(isolate()->factory()->the_hole_value());

}

@@ -3946,7 +3957,7 @@ void Parser::RegisterTargetUse(BreakTarget* target, Target* stop) {

Literal* Parser::NewNumberLiteral(double number) {

- return new Literal(isolate()->factory()->NewNumber(number, TENURED));

+ return new(zone()) Literal(isolate()->factory()->NewNumber(number, TENURED));

}

@@ -3993,9 +4004,9 @@ Expression* Parser::NewThrowError(Handle<String> constructor,

TENURED);

ZoneList<Expression*>* args = new ZoneList<Expression*>(2);

- args->Add(new Literal(type));

- args->Add(new Literal(array));

- return new Throw(new CallRuntime(constructor, NULL, args),

+ args->Add(new(zone()) Literal(type));

+ args->Add(new(zone()) Literal(array));

+ return new(zone()) Throw(new(zone()) CallRuntime(constructor, NULL, args),

scanner().location().beg_pos);

}

@@ -4318,13 +4329,13 @@ RegExpTree* RegExpParser::ParseDisjunction() {

// Build result of subexpression.

if (type == CAPTURE) {

- RegExpCapture* capture = new RegExpCapture(body, capture_index);

+ RegExpCapture* capture = new(zone()) RegExpCapture(body, capture_index);

captures_->at(capture_index - 1) = capture;

body = capture;

} else if (type != GROUPING) {

ASSERT(type == POSITIVE_LOOKAHEAD || type == NEGATIVE_LOOKAHEAD);

bool is_positive = (type == POSITIVE_LOOKAHEAD);

- body = new RegExpLookahead(body,

+ body = new(zone()) RegExpLookahead(body,

is_positive,

end_capture_index - capture_index,

capture_index);

@@ -4347,10 +4358,10 @@ RegExpTree* RegExpParser::ParseDisjunction() {

Advance();

if (multiline_) {

builder->AddAssertion(

- new RegExpAssertion(RegExpAssertion::START_OF_LINE));

+ new(zone()) RegExpAssertion(RegExpAssertion::START_OF_LINE));

} else {

builder->AddAssertion(

- new RegExpAssertion(RegExpAssertion::START_OF_INPUT));

+ new(zone()) RegExpAssertion(RegExpAssertion::START_OF_INPUT));

set_contains_anchor();

}

continue;

@@ -4360,7 +4371,7 @@ RegExpTree* RegExpParser::ParseDisjunction() {

RegExpAssertion::Type type =

multiline_ ? RegExpAssertion::END_OF_LINE :

RegExpAssertion::END_OF_INPUT;

- builder->AddAssertion(new RegExpAssertion(type));

+ builder->AddAssertion(new(zone()) RegExpAssertion(type));

continue;

}

case '.': {

@@ -4368,7 +4379,7 @@ RegExpTree* RegExpParser::ParseDisjunction() {

// everything except \x0a, \x0d, \u2028 and \u2029

ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2);

CharacterRange::AddClassEscape('.', ranges);

- RegExpTree* atom = new RegExpCharacterClass(ranges, false);

+ RegExpTree* atom = new(zone()) RegExpCharacterClass(ranges, false);

builder->AddAtom(atom);

break;

}

@@ -4401,7 +4412,7 @@ RegExpTree* RegExpParser::ParseDisjunction() {

captures_->Add(NULL);

}

// Store current state and begin new disjunction parsing.

- stored_state = new RegExpParserState(stored_state,

+ stored_state = new(zone()) RegExpParserState(stored_state,

type,

captures_started());

builder = stored_state->builder();

@@ -4421,12 +4432,12 @@ RegExpTree* RegExpParser::ParseDisjunction() {

case 'b':

Advance(2);

builder->AddAssertion(

- new RegExpAssertion(RegExpAssertion::BOUNDARY));

+ new(zone()) RegExpAssertion(RegExpAssertion::BOUNDARY));

continue;

case 'B':

Advance(2);

builder->AddAssertion(

- new RegExpAssertion(RegExpAssertion::NON_BOUNDARY));

+ new(zone()) RegExpAssertion(RegExpAssertion::NON_BOUNDARY));

continue;

// AtomEscape ::

// CharacterClassEscape

@@ -4438,7 +4449,7 @@ RegExpTree* RegExpParser::ParseDisjunction() {

Advance(2);

ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2);

CharacterRange::AddClassEscape(c, ranges);

- RegExpTree* atom = new RegExpCharacterClass(ranges, false);

+ RegExpTree* atom = new(zone()) RegExpCharacterClass(ranges, false);

builder->AddAtom(atom);

break;

}

@@ -4454,7 +4465,7 @@ RegExpTree* RegExpParser::ParseDisjunction() {

builder->AddEmpty();

break;

}

- RegExpTree* atom = new RegExpBackReference(capture);

+ RegExpTree* atom = new(zone()) RegExpBackReference(capture);

builder->AddAtom(atom);

break;

}

@@ -4972,7 +4983,7 @@ RegExpTree* RegExpParser::ParseCharacterClass() {

ranges->Add(CharacterRange::Everything());

is_negated = !is_negated;

}

- return new RegExpCharacterClass(ranges, is_negated);

+ return new(zone()) RegExpCharacterClass(ranges, is_negated);

}

« no previous file with comments | « src/parser.h ('k') | src/zone.h » ('j') | no next file with comments »