src/parser.cc - Issue 7374002: Refactor allocation policies.

Unified Diff: src/parser.cc

Issue 7374002: Refactor allocation policies. Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Created 9 years, 5 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 3085ef86be2a13c4ea0fd9c48e80b1a1f52ddc47..2e21a84aea6bccf95736a9402ca99c94d6fdf483 100644

--- a/src/parser.cc

+++ b/src/parser.cc

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

} else if (num_text == 1) {

terms_.Add(text_.last());

} else {

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

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

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

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

terms_.Add(text);

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

void RegExpBuilder::AddCharacter(uc16 c) {

pending_empty_ = false;

if (characters_ == NULL) {

- characters_ = new(zone()) ZoneList<uc16>(4);

+ characters_ = ZoneList<uc16>::New(zone(), 4);

}

characters_->Add(c);

LAST(ADD_CHAR);

@@ -572,7 +572,7 @@ Parser::Parser(Handle<Script> script,

v8::Extension* extension,

ScriptDataImpl* pre_data)

: isolate_(script->GetIsolate()),

- symbol_cache_(pre_data ? pre_data->symbol_count() : 0),

+ symbol_cache_(isolate_->zone(), pre_data ? pre_data->symbol_count() : 0),

script_(script),

scanner_(isolate_->unicode_cache()),

top_scope_(NULL),

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

if (strict_mode == kStrictMode) {

top_scope_->EnableStrictMode();

}

- ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16);

+ ZoneList<Statement*>* body = ZoneList<Statement*>::New(zone(), 16);

bool ok = true;

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

ParseSourceElements(body, Token::EOS, &ok);

@@ -1070,9 +1070,9 @@ class ThisNamedPropertyAssigmentFinder : public ParserFinder {

ASSERT(assigned_arguments_ == NULL);

ASSERT(assigned_constants_ == NULL);

Zone* zone = isolate_->zone();

- names_ = new(zone) ZoneStringList(4);

- assigned_arguments_ = new(zone) ZoneList<int>(4);

- assigned_constants_ = new(zone) ZoneObjectList(4);

+ names_ = ZoneStringList::New(zone, 4);

+ assigned_arguments_ = ZoneList<int>::New(zone, 4);

+ assigned_constants_ = ZoneObjectList::New(zone, 4);

}

@@ -1262,7 +1262,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(zone()) Block(labels, 1, false);

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

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

TryStatement* statement = ParseTryStatement(CHECK_OK);

if (statement) {

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

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

// Construct block expecting 16 statements.

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

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

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

Expect(Token::LBRACE, CHECK_OK);

InitializationBlockFinder block_finder(top_scope_, target_stack_);

@@ -1564,7 +1564,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(zone()) Block(NULL, 1, true);

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

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

Handle<String> name;

do {

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

if (initialization_scope->is_global_scope()) {

// Compute the arguments for the runtime call.

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

+ ZoneList<Expression*>* arguments = ZoneList<Expression*>::New(zone(), 3);

// We have at least 1 parameter.

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

CallRuntime* initialize;

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

*ok = false;

return NULL;

}

- if (labels == NULL) labels = new(zone()) ZoneStringList(4);

+ if (labels == NULL) labels = ZoneStringList::New(zone(), 4);

labels->Add(label);

// Remove the "ghost" variable that turned out to be a label

// from the top scope. This way, we don't try to resolve it

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

Block* Parser::WithHelper(Expression* obj, ZoneStringList* labels, bool* ok) {

// Parse the statement and collect escaping labels.

- TargetCollector collector;

+ TargetCollector collector(zone());

Statement* stat;

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

with_nesting_level_++;

@@ -1961,17 +1961,17 @@ Block* Parser::WithHelper(Expression* obj, ZoneStringList* labels, bool* ok) {

// Create resulting block with two statements.

// 1: Evaluate the with expression.

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

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

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

if (result != NULL) {

result->AddStatement(new(zone()) EnterWithContextStatement(obj));

// Create body block.

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

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

body->AddStatement(stat);

// Create exit block.

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

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

exit->AddStatement(new(zone()) ExitContextStatement());

// Return a try-finally statement.

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

}

Expect(Token::COLON, CHECK_OK);

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

- ZoneList<Statement*>* statements = new(zone()) ZoneList<Statement*>(5);

+ ZoneList<Statement*>* statements = ZoneList<Statement*>::New(zone(), 5);

while (peek() != Token::CASE &&

peek() != Token::DEFAULT &&

peek() != Token::RBRACE) {

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

Expect(Token::RPAREN, CHECK_OK);

bool default_seen = false;

- ZoneList<CaseClause*>* cases = new(zone()) ZoneList<CaseClause*>(4);

+ ZoneList<CaseClause*>* cases = ZoneList<CaseClause*>::New(zone(), 4);

Expect(Token::LBRACE, CHECK_OK);

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

CaseClause* clause = ParseCaseClause(&default_seen, CHECK_OK);

@@ -2095,7 +2095,7 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

Expect(Token::TRY, CHECK_OK);

- TargetCollector try_collector;

+ TargetCollector try_collector(zone());

Block* try_block;

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

@@ -2113,7 +2113,7 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

// then we will need to collect escaping targets from the catch

// block. Since we don't know yet if there will be a finally block, we

// always collect the targets.

- TargetCollector catch_collector;

+ TargetCollector catch_collector(zone());

Scope* catch_scope = NULL;

Variable* catch_variable = NULL;

Block* catch_block = NULL;

@@ -2139,7 +2139,7 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

// We need to collect escapes from the body for both the inner

// try/finally used to pop the catch context and any possible outer

// try/finally.

- TargetCollector inner_collector;

+ TargetCollector inner_collector(zone());

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

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

catch_scope = NewScope(top_scope_, Scope::CATCH_SCOPE, inside_with());

@@ -2156,7 +2156,7 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

}

// Create exit block.

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

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

inner_finally->AddStatement(new(zone()) ExitContextStatement());

// Create a try/finally statement.

@@ -2164,7 +2164,7 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

new(zone()) TryFinallyStatement(inner_body, inner_finally);

inner_try_finally->set_escaping_targets(inner_collector.targets());

- catch_block = new(zone()) Block(NULL, 1, false);

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

catch_block->AddStatement(inner_try_finally);

} else {

Expect(Token::LBRACE, CHECK_OK);

@@ -2193,7 +2193,7 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

catch_variable,

catch_block);

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

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

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

try_block->AddStatement(statement);

catch_block = NULL; // Clear to indicate it's been handled.

}

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

Statement* body = ParseStatement(NULL, CHECK_OK);

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

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

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

result->AddStatement(variable_statement);

result->AddStatement(loop);

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

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

if (!stack->is_empty()) {

int last = stack->pop();

result = new(zone()) CallNew(result,

- new(zone()) ZoneList<Expression*>(0),

+ ZoneList<Expression*>::New(zone(), 0),

last);

}

return result;

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

// ArrayLiteral ::

// '[' Expression? (',' Expression?)* ']'

- ZoneList<Expression*>* values = new(zone()) ZoneList<Expression*>(4);

+ ZoneList<Expression*>* values = ZoneList<Expression*>::New(zone(), 4);

Expect(Token::LBRACK, CHECK_OK);

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

Expression* elem;

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

// )*[','] '}'

ZoneList<ObjectLiteral::Property*>* properties =

- new(zone()) ZoneList<ObjectLiteral::Property*>(4);

+ ZoneList<ObjectLiteral::Property*>::New(zone(), 4);

int number_of_boilerplate_properties = 0;

bool has_function = false;

@@ -3581,7 +3581,7 @@ ZoneList<Expression*>* Parser::ParseArguments(bool* ok) {

// Arguments ::

// '(' (AssignmentExpression)*[','] ')'

- ZoneList<Expression*>* result = new(zone()) ZoneList<Expression*>(4);

+ ZoneList<Expression*>* result = ZoneList<Expression*>::New(zone(), 4);

Expect(Token::LPAREN, CHECK_OK);

bool done = (peek() == Token::RPAREN);

while (!done) {

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

int num_parameters = 0;

Scope* scope = NewScope(top_scope_, Scope::FUNCTION_SCOPE, inside_with());

- ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(8);

+ ZoneList<Statement*>* body = ZoneList<Statement*>::New(zone(), 8);

int materialized_literal_count;

int expected_property_count;

int start_pos;

@@ -4106,7 +4106,7 @@ Expression* Parser::NewThrowError(Handle<String> constructor,

Handle<JSArray> array = isolate()->factory()->NewJSArrayWithElements(elements,

TENURED);

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

+ ZoneList<Expression*>* args = ZoneList<Expression*>::New(zone(), 2);

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

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

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

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

Advance();

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

ZoneList<CharacterRange>* ranges =

- new(zone()) ZoneList<CharacterRange>(2);

+ ZoneList<CharacterRange>::New(zone(), 2);

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

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

builder->AddAtom(atom);

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

Advance(2);

} else {

if (captures_ == NULL) {

- captures_ = new(zone()) ZoneList<RegExpCapture*>(2);

+ captures_ = ZoneList<RegExpCapture*>::New(zone(), 2);

}

if (captures_started() >= kMaxCaptures) {

ReportError(CStrVector("Too many captures") CHECK_FAILED);

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

uc32 c = Next();

Advance(2);

ZoneList<CharacterRange>* ranges =

- new(zone()) ZoneList<CharacterRange>(2);

+ ZoneList<CharacterRange>::New(zone(), 2);

CharacterRange::AddClassEscape(c, ranges);

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

builder->AddAtom(atom);

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

is_negated = true;

Advance();

}

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

+ ZoneList<CharacterRange>* ranges = ZoneList<CharacterRange>::New(zone(), 2);

while (has_more() && current() != ']') {

uc16 char_class = kNoCharClass;

CharacterRange first = ParseClassAtom(&char_class CHECK_FAILED);

« no previous file with comments | « src/parser.h ('k') | src/profile-generator.cc » ('j') | no next file with comments »