Skip to content

V
V8
Commit 6c5c8238 authored by vitalyr@chromium.org's avatar vitalyr@chromium.org
Browse files
Options

Support placement new syntax for zone objects and start using it in the parser. 

Review URL: http://codereview.chromium.org/6771058

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@7489 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent d37b5750
Hide whitespace changes
Inline Side-by-side
Showing with 138 additions and 117 deletions
src/parser.cc
View file @ 6c5c8238
......@@ -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());
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);
}
......
src/parser.h
View file @ 6c5c8238
......@@ -280,6 +280,9 @@ class RegExpBuilder: public ZoneObject {
void FlushCharacters();
void FlushText();
void FlushTerms();
Zone* zone() { return zone_; }
Zone* zone_;
bool pending_empty_;
ZoneList<uc16>* characters_;
BufferedZoneList<RegExpTree, 2> terms_;
......@@ -389,6 +392,7 @@ class RegExpParser {
};
Isolate* isolate() { return isolate_; }
Zone* zone() { return isolate_->zone(); }
uc32 current() { return current_; }
bool has_more() { return has_more_; }
......@@ -453,6 +457,7 @@ class Parser {
};
Isolate* isolate() { return isolate_; }
Zone* zone() { return isolate_->zone(); }
// Called by ParseProgram after setting up the scanner.
FunctionLiteral* DoParseProgram(Handle<String> source,
......
src/zone-inl.h
View file @ 6c5c8238
......@@ -97,6 +97,10 @@ void* ZoneObject::operator new(size_t size) {
return ZONE->New(static_cast<int>(size));
}
void* ZoneObject::operator new(size_t size, Zone* zone) {
return zone->New(static_cast<int>(size));
}
inline void* ZoneListAllocationPolicy::New(int size) {
return ZONE->New(size);
......
src/zone.h
View file @ 6c5c8238
......@@ -133,6 +133,7 @@ class ZoneObject {
public:
// Allocate a new ZoneObject of 'size' bytes in the Zone.
inline void* operator new(size_t size);
inline void* operator new(size_t size, Zone* zone);
// Ideally, the delete operator should be private instead of
// public, but unfortunately the compiler sometimes synthesizes
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment