runtime/vm/regexp.cc - Issue 2481873005: clang-format runtime/vm

Unified Diff: runtime/vm/regexp.cc

Issue 2481873005: clang-format runtime/vm (Closed)

Patch Set: Merge Created 4 years, 1 month 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: runtime/vm/regexp.cc

diff --git a/runtime/vm/regexp.cc b/runtime/vm/regexp.cc

index 2b9df9535d20cc03fed86f986866f33126b5428e..19b88c5605940ceb7a33674b3970fa2061a5911d 100644

--- a/runtime/vm/regexp.cc

+++ b/runtime/vm/regexp.cc

@@ -270,9 +270,9 @@ class FrequencyCollator : public ValueObject {

private:

class CharacterFrequency {

public:

- CharacterFrequency() : counter_(0), character_(-1) { }

+ CharacterFrequency() : counter_(0), character_(-1) {}

explicit CharacterFrequency(intptr_t character)

- : counter_(0), character_(character) { }

+ : counter_(0), character_(character) {}

void Increment() { counter_++; }

intptr_t counter() { return counter_; }

@@ -294,19 +294,14 @@ class FrequencyCollator : public ValueObject {

class RegExpCompiler : public ValueObject {

public:

- RegExpCompiler(intptr_t capture_count,

- bool ignore_case,

- bool is_one_byte);

+ RegExpCompiler(intptr_t capture_count, bool ignore_case, bool is_one_byte);

- intptr_t AllocateRegister() {

- return next_register_++;

- }

+ intptr_t AllocateRegister() { return next_register_++; }

- RegExpEngine::CompilationResult Assemble(

- IRRegExpMacroAssembler* assembler,

- RegExpNode* start,

- intptr_t capture_count,

- const String& pattern);

+ RegExpEngine::CompilationResult Assemble(IRRegExpMacroAssembler* assembler,

+ RegExpNode* start,

+ intptr_t capture_count,

+ const String& pattern);

RegExpEngine::CompilationResult Assemble(

BytecodeRegExpMacroAssembler* assembler,

@@ -364,6 +359,7 @@ class RecursionCheck : public ValueObject {

compiler->IncrementRecursionDepth();

}

~RecursionCheck() { compiler_->DecrementRecursionDepth(); }

private:

RegExpCompiler* compiler_;

};

@@ -387,7 +383,7 @@ RegExpCompiler::RegExpCompiler(intptr_t capture_count,

reg_exp_too_big_(false),

current_expansion_factor_(1),

zone_(Thread::Current()->zone()) {

- accept_ = new(Z) EndNode(EndNode::ACCEPT, Z);

+ accept_ = new (Z) EndNode(EndNode::ACCEPT, Z);

}

@@ -415,11 +411,10 @@ RegExpEngine::CompilationResult RegExpCompiler::Assemble(

macro_assembler->GenerateBacktrackBlock();

macro_assembler->FinalizeRegistersArray();

- return RegExpEngine::CompilationResult(macro_assembler->backtrack_goto(),

- macro_assembler->graph_entry(),

- macro_assembler->num_blocks(),

- macro_assembler->num_stack_locals(),

- next_register_);

+ return RegExpEngine::CompilationResult(

+ macro_assembler->backtrack_goto(), macro_assembler->graph_entry(),

+ macro_assembler->num_blocks(), macro_assembler->num_stack_locals(),

+ next_register_);

}

@@ -460,11 +455,9 @@ bool Trace::DeferredAction::Mentions(intptr_t that) {

bool Trace::mentions_reg(intptr_t reg) {

- for (DeferredAction* action = actions_;

- action != NULL;

+ for (DeferredAction* action = actions_; action != NULL;

action = action->next()) {

- if (action->Mentions(reg))

- return true;

+ if (action->Mentions(reg)) return true;

}

return false;

}

@@ -472,8 +465,7 @@ bool Trace::mentions_reg(intptr_t reg) {

bool Trace::GetStoredPosition(intptr_t reg, intptr_t* cp_offset) {

ASSERT(*cp_offset == 0);

- for (DeferredAction* action = actions_;

- action != NULL;

+ for (DeferredAction* action = actions_; action != NULL;

action = action->next()) {

if (action->Mentions(reg)) {

if (action->action_type() == ActionNode::STORE_POSITION) {

@@ -491,11 +483,9 @@ bool Trace::GetStoredPosition(intptr_t reg, intptr_t* cp_offset) {

// This is called as we come into a loop choice node and some other tricky

// nodes. It normalizes the state of the code generator to ensure we can

// generate generic code.

-intptr_t Trace::FindAffectedRegisters(OutSet* affected_registers,

- Zone* zone) {

+intptr_t Trace::FindAffectedRegisters(OutSet* affected_registers, Zone* zone) {

intptr_t max_register = RegExpCompiler::kNoRegister;

- for (DeferredAction* action = actions_;

- action != NULL;

+ for (DeferredAction* action = actions_; action != NULL;

action = action->next()) {

if (action->action_type() == ActionNode::CLEAR_CAPTURES) {

Interval range = static_cast<DeferredClearCaptures*>(action)->range();

@@ -552,8 +542,7 @@ void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,

intptr_t store_position = -1;

// This is a little tricky because we are scanning the actions in reverse

// historical order (newest first).

- for (DeferredAction* action = actions_;

- action != NULL;

+ for (DeferredAction* action = actions_; action != NULL;

action = action->next()) {

if (action->Mentions(reg)) {

switch (action->action_type()) {

@@ -677,12 +666,8 @@ void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {

intptr_t max_register = FindAffectedRegisters(&affected_registers, zone);

OutSet registers_to_pop;

OutSet registers_to_clear;

- PerformDeferredActions(assembler,

- max_register,

- affected_registers,

- &registers_to_pop,

- &registers_to_clear,

- zone);

+ PerformDeferredActions(assembler, max_register, affected_registers,

+ &registers_to_pop, &registers_to_clear, zone);

if (cp_offset_ != 0) {

assembler->AdvanceCurrentPosition(cp_offset_);

}

@@ -695,9 +680,7 @@ void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {

// On backtrack we need to restore state.

assembler->BindBlock(&undo);

- RestoreAffectedRegisters(assembler,

- max_register,

- registers_to_pop,

+ RestoreAffectedRegisters(assembler, max_register, registers_to_pop,

registers_to_clear);

if (backtrack() == NULL) {

assembler->Backtrack();

@@ -760,8 +743,7 @@ void EndNode::Emit(RegExpCompiler* compiler, Trace* trace) {

void GuardedAlternative::AddGuard(Guard* guard, Zone* zone) {

- if (guards_ == NULL)

- guards_ = new(zone) ZoneGrowableArray<Guard*>(1);

+ if (guards_ == NULL) guards_ = new (zone) ZoneGrowableArray<Guard*>(1);

guards_->Add(guard);

}

@@ -770,7 +752,7 @@ ActionNode* ActionNode::SetRegister(intptr_t reg,

intptr_t val,

RegExpNode* on_success) {

ActionNode* result =

- new(on_success->zone()) ActionNode(SET_REGISTER, on_success);

+ new (on_success->zone()) ActionNode(SET_REGISTER, on_success);

result->data_.u_store_register.reg = reg;

result->data_.u_store_register.value = val;

return result;

@@ -780,7 +762,7 @@ ActionNode* ActionNode::SetRegister(intptr_t reg,

ActionNode* ActionNode::IncrementRegister(intptr_t reg,

RegExpNode* on_success) {

ActionNode* result =

- new(on_success->zone()) ActionNode(INCREMENT_REGISTER, on_success);

+ new (on_success->zone()) ActionNode(INCREMENT_REGISTER, on_success);

result->data_.u_increment_register.reg = reg;

return result;

}

@@ -790,17 +772,16 @@ ActionNode* ActionNode::StorePosition(intptr_t reg,

bool is_capture,

RegExpNode* on_success) {

ActionNode* result =

- new(on_success->zone()) ActionNode(STORE_POSITION, on_success);

+ new (on_success->zone()) ActionNode(STORE_POSITION, on_success);

result->data_.u_position_register.reg = reg;

result->data_.u_position_register.is_capture = is_capture;

return result;

}

-ActionNode* ActionNode::ClearCaptures(Interval range,

- RegExpNode* on_success) {

+ActionNode* ActionNode::ClearCaptures(Interval range, RegExpNode* on_success) {

ActionNode* result =

- new(on_success->zone()) ActionNode(CLEAR_CAPTURES, on_success);

+ new (on_success->zone()) ActionNode(CLEAR_CAPTURES, on_success);

result->data_.u_clear_captures.range_from = range.from();

result->data_.u_clear_captures.range_to = range.to();

return result;

@@ -811,7 +792,7 @@ ActionNode* ActionNode::BeginSubmatch(intptr_t stack_reg,

intptr_t position_reg,

RegExpNode* on_success) {

ActionNode* result =

- new(on_success->zone()) ActionNode(BEGIN_SUBMATCH, on_success);

+ new (on_success->zone()) ActionNode(BEGIN_SUBMATCH, on_success);

result->data_.u_submatch.stack_pointer_register = stack_reg;

result->data_.u_submatch.current_position_register = position_reg;

return result;

@@ -823,9 +804,8 @@ ActionNode* ActionNode::PositiveSubmatchSuccess(intptr_t stack_reg,

intptr_t clear_register_count,

intptr_t clear_register_from,

RegExpNode* on_success) {

- ActionNode* result =

- new(on_success->zone()) ActionNode(POSITIVE_SUBMATCH_SUCCESS,

- on_success);

+ ActionNode* result = new (on_success->zone())

+ ActionNode(POSITIVE_SUBMATCH_SUCCESS, on_success);

result->data_.u_submatch.stack_pointer_register = stack_reg;

result->data_.u_submatch.current_position_register = position_reg;

result->data_.u_submatch.clear_register_count = clear_register_count;

@@ -839,7 +819,7 @@ ActionNode* ActionNode::EmptyMatchCheck(intptr_t start_register,

intptr_t repetition_limit,

RegExpNode* on_success) {

ActionNode* result =

- new(on_success->zone()) ActionNode(EMPTY_MATCH_CHECK, on_success);

+ new (on_success->zone()) ActionNode(EMPTY_MATCH_CHECK, on_success);

result->data_.u_empty_match_check.start_register = start_register;

result->data_.u_empty_match_check.repetition_register = repetition_register;

result->data_.u_empty_match_check.repetition_limit = repetition_limit;

@@ -847,10 +827,8 @@ ActionNode* ActionNode::EmptyMatchCheck(intptr_t start_register,

}

-#define DEFINE_ACCEPT(Type) \

- void Type##Node::Accept(NodeVisitor* visitor) { \

- visitor->Visit##Type(this); \

- }

+#define DEFINE_ACCEPT(Type) \

+ void Type##Node::Accept(NodeVisitor* visitor) { visitor->Visit##Type(this); }

FOR_EACH_NODE_TYPE(DEFINE_ACCEPT)

#undef DEFINE_ACCEPT

@@ -870,14 +848,12 @@ void ChoiceNode::GenerateGuard(RegExpMacroAssembler* macro_assembler,

switch (guard->op()) {

case Guard::LT:

ASSERT(!trace->mentions_reg(guard->reg()));

- macro_assembler->IfRegisterGE(guard->reg(),

- guard->value(),

+ macro_assembler->IfRegisterGE(guard->reg(), guard->value(),

trace->backtrack());

break;

case Guard::GEQ:

ASSERT(!trace->mentions_reg(guard->reg()));

- macro_assembler->IfRegisterLT(guard->reg(),

- guard->value(),

+ macro_assembler->IfRegisterLT(guard->reg(), guard->value(),

trace->backtrack());

break;

}

@@ -919,10 +895,7 @@ static inline bool EmitSimpleCharacter(Zone* zone,

RegExpMacroAssembler* assembler = compiler->macro_assembler();

bool bound_checked = false;

if (!preloaded) {

- assembler->LoadCurrentCharacter(

- cp_offset,

- on_failure,

- check);

+ assembler->LoadCurrentCharacter(cp_offset, on_failure, check);

bound_checked = true;

}

assembler->CheckNotCharacter(c, on_failure);

@@ -995,9 +968,7 @@ static bool ShortCutEmitCharacterPair(RegExpMacroAssembler* macro_assembler,

// trick. We avoid the theoretical case where negative numbers are

// involved in order to simplify code generation.

uint16_t mask = char_mask ^ diff;

- macro_assembler->CheckNotCharacterAfterMinusAnd(c1 - diff,

- diff,

- mask,

+ macro_assembler->CheckNotCharacterAfterMinusAnd(c1 - diff, diff, mask,

on_failure);

return true;

}

@@ -1036,11 +1007,8 @@ static inline bool EmitAtomLetter(Zone* zone,

ASSERT(unibrow::Ecma262UnCanonicalize::kMaxWidth == 4);

switch (length) {

case 2: {

- if (ShortCutEmitCharacterPair(macro_assembler,

- one_byte,

- chars[0],

- chars[1],

- on_failure)) {

+ if (ShortCutEmitCharacterPair(macro_assembler, one_byte, chars[0],

+ chars[1], on_failure)) {

} else {

macro_assembler->CheckCharacter(chars[0], &ok);

macro_assembler->CheckNotCharacter(chars[1], on_failure);

@@ -1050,7 +1018,7 @@ static inline bool EmitAtomLetter(Zone* zone,

}

case 4:

macro_assembler->CheckCharacter(chars[3], &ok);

- // Fall through!

+ // Fall through!

case 3:

macro_assembler->CheckCharacter(chars[0], &ok);

macro_assembler->CheckCharacter(chars[1], &ok);

@@ -1104,15 +1072,14 @@ static void EmitDoubleBoundaryTest(RegExpMacroAssembler* masm,

// even_label is for ranges[i] to ranges[i + 1] where i - start_index is even.

// odd_label is for ranges[i] to ranges[i + 1] where i - start_index is odd.

-static void EmitUseLookupTable(

- RegExpMacroAssembler* masm,

- ZoneGrowableArray<int>* ranges,

- intptr_t start_index,

- intptr_t end_index,

- intptr_t min_char,

- BlockLabel* fall_through,

- BlockLabel* even_label,

- BlockLabel* odd_label) {

+static void EmitUseLookupTable(RegExpMacroAssembler* masm,

+ ZoneGrowableArray<int>* ranges,

+ intptr_t start_index,

+ intptr_t end_index,

+ intptr_t min_char,

+ BlockLabel* fall_through,

+ BlockLabel* even_label,

+ BlockLabel* odd_label) {

static const intptr_t kSize = RegExpMacroAssembler::kTableSize;

static const intptr_t kMask = RegExpMacroAssembler::kTableMask;

@@ -1154,8 +1121,7 @@ static void EmitUseLookupTable(

}

// TODO(erikcorry): Cache these.

const TypedData& ba = TypedData::ZoneHandle(

- masm->zone(),

- TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));

+ masm->zone(), TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));

for (intptr_t i = 0; i < kSize; i++) {

ba.SetUint8(i, templ[i]);

}

@@ -1174,11 +1140,8 @@ static void CutOutRange(RegExpMacroAssembler* masm,

bool odd = (((cut_index - start_index) & 1) == 1);

BlockLabel* in_range_label = odd ? odd_label : even_label;

BlockLabel dummy;

- EmitDoubleBoundaryTest(masm,

- ranges->At(cut_index),

- ranges->At(cut_index + 1) - 1,

- &dummy,

- in_range_label,

+ EmitDoubleBoundaryTest(masm, ranges->At(cut_index),

+ ranges->At(cut_index + 1) - 1, &dummy, in_range_label,

&dummy);

ASSERT(!dummy.IsLinked());

// Cut out the single range by rewriting the array. This creates a new

@@ -1231,8 +1194,7 @@ static void SplitSearchSpace(ZoneGrowableArray<int>* ranges,

// punctuation).

if (*border - 1 > Symbols::kMaxOneCharCodeSymbol && // Latin1 case.

end_index - start_index > (*new_start_index - start_index) * 2 &&

- last - first > kSize * 2 &&

- binary_chop_index > *new_start_index &&

+ last - first > kSize * 2 && binary_chop_index > *new_start_index &&

ranges->At(binary_chop_index) >= first + 2 * kSize) {

intptr_t scan_forward_for_section_border = binary_chop_index;

intptr_t new_border = (ranges->At(binary_chop_index) | kMask) + 1;

@@ -1290,8 +1252,8 @@ static void GenerateBranches(RegExpMacroAssembler* masm,

// Another almost trivial case: There is one interval in the middle that is

// different from the end intervals.

if (start_index + 1 == end_index) {

- EmitDoubleBoundaryTest(

- masm, first, last, fall_through, even_label, odd_label);

+ EmitDoubleBoundaryTest(masm, first, last, fall_through, even_label,

+ odd_label);

return;

}

@@ -1309,18 +1271,11 @@ static void GenerateBranches(RegExpMacroAssembler* masm,

}

if (cut == kNoCutIndex) cut = start_index;

- CutOutRange(

- masm, ranges, start_index, end_index, cut, even_label, odd_label);

+ CutOutRange(masm, ranges, start_index, end_index, cut, even_label,

+ odd_label);

ASSERT(end_index - start_index >= 2);

- GenerateBranches(masm,

- ranges,

- start_index + 1,

- end_index - 1,

- min_char,

- max_char,

- fall_through,

- even_label,

- odd_label);

+ GenerateBranches(masm, ranges, start_index + 1, end_index - 1, min_char,

+ max_char, fall_through, even_label, odd_label);

return;

}

@@ -1329,28 +1284,15 @@ static void GenerateBranches(RegExpMacroAssembler* masm,

static const intptr_t kBits = RegExpMacroAssembler::kTableSizeBits;

if ((max_char >> kBits) == (min_char >> kBits)) {

- EmitUseLookupTable(masm,

- ranges,

- start_index,

- end_index,

- min_char,

- fall_through,

- even_label,

- odd_label);

+ EmitUseLookupTable(masm, ranges, start_index, end_index, min_char,

+ fall_through, even_label, odd_label);

return;

}

if ((min_char >> kBits) != (first >> kBits)) {

masm->CheckCharacterLT(first, odd_label);

- GenerateBranches(masm,

- ranges,

- start_index + 1,

- end_index,

- first,

- max_char,

- fall_through,

- odd_label,

- even_label);

+ GenerateBranches(masm, ranges, start_index + 1, end_index, first, max_char,

+ fall_through, odd_label, even_label);

return;

}

@@ -1358,12 +1300,8 @@ static void GenerateBranches(RegExpMacroAssembler* masm,

intptr_t new_end_index = 0;

intptr_t border = 0;

- SplitSearchSpace(ranges,

- start_index,

- end_index,

- &new_start_index,

- &new_end_index,

- &border);

+ SplitSearchSpace(ranges, start_index, end_index, &new_start_index,

+ &new_end_index, &border);

BlockLabel handle_rest;

BlockLabel* above = &handle_rest;

@@ -1386,34 +1324,20 @@ static void GenerateBranches(RegExpMacroAssembler* masm,

ASSERT(ranges->At(new_end_index) < border);

ASSERT(border < ranges->At(new_start_index) ||

(border == ranges->At(new_start_index) &&

- new_start_index == end_index &&

- new_end_index == end_index - 1 &&

+ new_start_index == end_index && new_end_index == end_index - 1 &&

border == last + 1));

ASSERT(new_start_index == 0 || border >= ranges->At(new_start_index - 1));

masm->CheckCharacterGT(border - 1, above);

BlockLabel dummy;

- GenerateBranches(masm,

- ranges,

- start_index,

- new_end_index,

- min_char,

- border - 1,

- &dummy,

- even_label,

- odd_label);

+ GenerateBranches(masm, ranges, start_index, new_end_index, min_char,

+ border - 1, &dummy, even_label, odd_label);

if (handle_rest.IsLinked()) {

masm->BindBlock(&handle_rest);

bool flip = (new_start_index & 1) != (start_index & 1);

- GenerateBranches(masm,

- ranges,

- new_start_index,

- end_index,

- border,

- max_char,

- &dummy,

- flip ? odd_label : even_label,

+ GenerateBranches(masm, ranges, new_start_index, end_index, border, max_char,

+ &dummy, flip ? odd_label : even_label,

flip ? even_label : odd_label);

}

@@ -1460,8 +1384,7 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,

return;

}

- if (last_valid_range == 0 &&

- ranges->At(0).IsEverything(max_char)) {

+ if (last_valid_range == 0 && ranges->At(0).IsEverything(max_char)) {

if (cc->is_negated()) {

macro_assembler->GoTo(on_failure);

} else {

@@ -1472,8 +1395,7 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,

}

return;

}

- if (last_valid_range == 0 &&

- !cc->is_negated() &&

+ if (last_valid_range == 0 && !cc->is_negated() &&

ranges->At(0).IsEverything(max_char)) {

// This is a common case hit by non-anchored expressions.

if (check_offset) {

@@ -1487,9 +1409,9 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,

}

if (cc->is_standard() &&

- macro_assembler->CheckSpecialCharacterClass(cc->standard_type(),

- on_failure)) {

- return;

+ macro_assembler->CheckSpecialCharacterClass(cc->standard_type(),

+ on_failure)) {

+ return;

}

@@ -1500,7 +1422,7 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,

// was already one there we fall through for success on that entry.

// Subsequent entries have alternating meaning (success/failure).

ZoneGrowableArray<int>* range_boundaries =

- new(zone) ZoneGrowableArray<int>(last_valid_range);

+ new (zone) ZoneGrowableArray<int>(last_valid_range);

bool zeroth_entry_is_failure = !cc->is_negated();

@@ -1520,21 +1442,18 @@ static void EmitCharClass(RegExpMacroAssembler* macro_assembler,

}

BlockLabel fall_through;

- GenerateBranches(macro_assembler,

- range_boundaries,

+ GenerateBranches(macro_assembler, range_boundaries,

0, // start_index.

end_index,

0, // min_char.

- max_char,

- &fall_through,

+ max_char, &fall_through,

zeroth_entry_is_failure ? &fall_through : on_failure,

zeroth_entry_is_failure ? on_failure : &fall_through);

macro_assembler->BindBlock(&fall_through);

}

-RegExpNode::~RegExpNode() {

+RegExpNode::~RegExpNode() {}

RegExpNode::LimitResult RegExpNode::LimitVersions(RegExpCompiler* compiler,

@@ -1567,8 +1486,7 @@ RegExpNode::LimitResult RegExpNode::LimitVersions(RegExpCompiler* compiler,

// We are being asked to make a non-generic version. Keep track of how many

// non-generic versions we generate so as not to overdo it.

trace_count_++;

- if (kRegexpOptimization &&

- trace_count_ < kMaxCopiesCodeGenerated &&

+ if (kRegexpOptimization && trace_count_ < kMaxCopiesCodeGenerated &&

compiler->recursion_depth() <= RegExpCompiler::kMaxRecursion) {

return CONTINUE;

}

@@ -1586,9 +1504,7 @@ intptr_t ActionNode::EatsAtLeast(intptr_t still_to_find,

bool not_at_start) {

if (budget <= 0) return 0;

if (action_type_ == POSITIVE_SUBMATCH_SUCCESS) return 0; // Rewinds input!

- return on_success()->EatsAtLeast(still_to_find,

- budget - 1,

- not_at_start);

+ return on_success()->EatsAtLeast(still_to_find, budget - 1, not_at_start);

}

@@ -1615,9 +1531,7 @@ intptr_t AssertionNode::EatsAtLeast(intptr_t still_to_find,

// that won't prevent us from preloading a lot of characters for the other

// branches in the node graph.

if (assertion_type() == AT_START && not_at_start) return still_to_find;

- return on_success()->EatsAtLeast(still_to_find,

- budget - 1,

- not_at_start);

+ return on_success()->EatsAtLeast(still_to_find, budget - 1, not_at_start);

}

@@ -1636,9 +1550,7 @@ intptr_t BackReferenceNode::EatsAtLeast(intptr_t still_to_find,

intptr_t budget,

bool not_at_start) {

if (budget <= 0) return 0;

- return on_success()->EatsAtLeast(still_to_find,

- budget - 1,

- not_at_start);

+ return on_success()->EatsAtLeast(still_to_find, budget - 1, not_at_start);

}

@@ -1649,9 +1561,8 @@ intptr_t TextNode::EatsAtLeast(intptr_t still_to_find,

if (answer >= still_to_find) return answer;

if (budget <= 0) return answer;

// We are not at start after this node so we set the last argument to 'true'.

- return answer + on_success()->EatsAtLeast(still_to_find - answer,

- budget - 1,

- true);

+ return answer +

+ on_success()->EatsAtLeast(still_to_find - answer, budget - 1, true);

}

@@ -1701,20 +1612,14 @@ intptr_t ChoiceNode::EatsAtLeastHelper(intptr_t still_to_find,

intptr_t LoopChoiceNode::EatsAtLeast(intptr_t still_to_find,

intptr_t budget,

bool not_at_start) {

- return EatsAtLeastHelper(still_to_find,

- budget - 1,

- loop_node_,

- not_at_start);

+ return EatsAtLeastHelper(still_to_find, budget - 1, loop_node_, not_at_start);

}

intptr_t ChoiceNode::EatsAtLeast(intptr_t still_to_find,

intptr_t budget,

bool not_at_start) {

- return EatsAtLeastHelper(still_to_find,

- budget,

- NULL,

- not_at_start);

+ return EatsAtLeastHelper(still_to_find, budget, NULL, not_at_start);

}

@@ -1761,8 +1666,8 @@ bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,

QuickCheckDetails* details,

bool fall_through_on_failure) {

if (details->characters() == 0) return false;

- GetQuickCheckDetails(

- details, compiler, 0, trace->at_start() == Trace::FALSE_VALUE);

+ GetQuickCheckDetails(details, compiler, 0,

+ trace->at_start() == Trace::FALSE_VALUE);

if (details->cannot_match()) return false;

if (!details->Rationalize(compiler->one_byte())) return false;

ASSERT(details->characters() == 1 ||

@@ -1778,10 +1683,9 @@ bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,

// any choice would eat, so if the bounds check fails, then none of the

// choices can succeed, so we can just immediately backtrack, rather

// than go to the next choice.

- assembler->LoadCurrentCharacter(trace->cp_offset(),

- bounds_check_trace->backtrack(),

- !preload_has_checked_bounds,

- details->characters());

+ assembler->LoadCurrentCharacter(

+ trace->cp_offset(), bounds_check_trace->backtrack(),

+ !preload_has_checked_bounds, details->characters());

}

@@ -1948,7 +1852,7 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,

// A mask and compare is only perfect if the differing bits form a

// number like 00011111 with one single block of trailing 1s.

if ((differing_bits & (differing_bits + 1)) == 0 &&

- from + differing_bits == to) {

+ from + differing_bits == to) {

pos->determines_perfectly = true;

}

uint32_t common_bits = ~SmearBitsRight(differing_bits);

@@ -1985,10 +1889,8 @@ void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,

}

ASSERT(characters_filled_in != details->characters());

if (!details->cannot_match()) {

- on_success()-> GetQuickCheckDetails(details,

- compiler,

- characters_filled_in,

- true);

+ on_success()->GetQuickCheckDetails(details, compiler, characters_filled_in,

+ true);

}

@@ -2036,8 +1938,7 @@ void QuickCheckDetails::Merge(QuickCheckDetails* other, intptr_t from_index) {

for (intptr_t i = from_index; i < characters_; i++) {

QuickCheckDetails::Position* pos = positions(i);

QuickCheckDetails::Position* other_pos = other->positions(i);

- if (pos->mask != other_pos->mask ||

- pos->value != other_pos->value ||

+ if (pos->mask != other_pos->mask || pos->value != other_pos->value ||

!other_pos->determines_perfectly) {

// Our mask-compare operation will be approximate unless we have the

// exact same operation on both sides of the alternation.

@@ -2059,9 +1960,8 @@ class VisitMarker : public ValueObject {

ASSERT(!info->visited);

info->visited = true;

}

- ~VisitMarker() {

- info_->visited = false;

- }

+ ~VisitMarker() { info_->visited = false; }

private:

NodeInfo* info_;

};

@@ -2087,8 +1987,8 @@ RegExpNode* SeqRegExpNode::FilterSuccessor(intptr_t depth, bool ignore_case) {

// We need to check for the following characters: 0x39c 0x3bc 0x178.

static inline bool RangeContainsLatin1Equivalents(CharacterRange range) {

// TODO(dcarney): this could be a lot more efficient.

- return range.Contains(0x39c) ||

- range.Contains(0x3bc) || range.Contains(0x178);

+ return range.Contains(0x39c) || range.Contains(0x3bc) ||

+ range.Contains(0x178);

}

@@ -2150,8 +2050,7 @@ RegExpNode* TextNode::FilterOneByte(intptr_t depth, bool ignore_case) {

// Now they are in order so we only need to look at the first.

intptr_t range_count = ranges->length();

if (cc->is_negated()) {

- if (range_count != 0 &&

- ranges->At(0).from() == 0 &&

+ if (range_count != 0 && ranges->At(0).from() == 0 &&

ranges->At(0).to() >= Symbols::kMaxOneCharCodeSymbol) {

// This will be handled in a later filter.

if (ignore_case && RangesContainLatin1Equivalents(ranges)) continue;

@@ -2226,7 +2125,7 @@ RegExpNode* ChoiceNode::FilterOneByte(intptr_t depth, bool ignore_case) {

// Only some of the nodes survived the filtering. We need to rebuild the

// alternatives list.

ZoneGrowableArray<GuardedAlternative>* new_alternatives =

- new(Z) ZoneGrowableArray<GuardedAlternative>(surviving);

+ new (Z) ZoneGrowableArray<GuardedAlternative>(surviving);

for (intptr_t i = 0; i < choice_count; i++) {

RegExpNode* replacement =

(*alternatives_)[i].node()->FilterOneByte(depth - 1, ignore_case);

@@ -2269,10 +2168,8 @@ void LoopChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,

bool not_at_start) {

if (body_can_be_zero_length_ || info()->visited) return;

VisitMarker marker(info());

- return ChoiceNode::GetQuickCheckDetails(details,

- compiler,

- characters_filled_in,

- not_at_start);

+ return ChoiceNode::GetQuickCheckDetails(details, compiler,

+ characters_filled_in, not_at_start);

}

@@ -2297,15 +2194,12 @@ void ChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,

not_at_start = (not_at_start || not_at_start_);

intptr_t choice_count = alternatives_->length();

ASSERT(choice_count > 0);

- (*alternatives_)[0].node()->GetQuickCheckDetails(details,

- compiler,

- characters_filled_in,

- not_at_start);

+ (*alternatives_)[0].node()->GetQuickCheckDetails(

+ details, compiler, characters_filled_in, not_at_start);

for (intptr_t i = 1; i < choice_count; i++) {

QuickCheckDetails new_details(details->characters());

RegExpNode* node = (*alternatives_)[i].node();

- node->GetQuickCheckDetails(&new_details, compiler,

- characters_filled_in,

+ node->GetQuickCheckDetails(&new_details, compiler, characters_filled_in,

not_at_start);

// Here we merge the quick match details of the two branches.

details->Merge(&new_details, characters_filled_in);

@@ -2357,11 +2251,9 @@ static void EmitHat(RegExpCompiler* compiler,

}

// We already checked that we are not at the start of input so it must be

// OK to load the previous character.

- assembler->LoadCurrentCharacter(new_trace.cp_offset() -1,

- new_trace.backtrack(),

- false);

- if (!assembler->CheckSpecialCharacterClass('n',

- new_trace.backtrack())) {

+ assembler->LoadCurrentCharacter(new_trace.cp_offset() - 1,

+ new_trace.backtrack(), false);

+ if (!assembler->CheckSpecialCharacterClass('n', new_trace.backtrack())) {

// Newline means \n, \r, 0x2028 or 0x2029.

if (!compiler->one_byte()) {

assembler->CheckCharacterAfterAnd(0x2028, 0xfffe, &ok);

@@ -2383,22 +2275,19 @@ void AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, Trace* trace) {

if (lookahead == NULL) {

intptr_t eats_at_least =

Utils::Minimum(kMaxLookaheadForBoyerMoore,

- EatsAtLeast(kMaxLookaheadForBoyerMoore,

- kRecursionBudget,

+ EatsAtLeast(kMaxLookaheadForBoyerMoore, kRecursionBudget,

not_at_start));

if (eats_at_least >= 1) {

BoyerMooreLookahead* bm =

- new(Z) BoyerMooreLookahead(eats_at_least, compiler, Z);

+ new (Z) BoyerMooreLookahead(eats_at_least, compiler, Z);

FillInBMInfo(0, kRecursionBudget, bm, not_at_start);

- if (bm->at(0)->is_non_word())

- next_is_word_character = Trace::FALSE_VALUE;

+ if (bm->at(0)->is_non_word()) next_is_word_character = Trace::FALSE_VALUE;

if (bm->at(0)->is_word()) next_is_word_character = Trace::TRUE_VALUE;

}

} else {

if (lookahead->at(0)->is_non_word())

next_is_word_character = Trace::FALSE_VALUE;

- if (lookahead->at(0)->is_word())

- next_is_word_character = Trace::TRUE_VALUE;

+ if (lookahead->at(0)->is_word()) next_is_word_character = Trace::TRUE_VALUE;

}

bool at_boundary = (assertion_type_ == AssertionNode::AT_BOUNDARY);

if (next_is_word_character == Trace::UNKNOWN) {

@@ -2442,12 +2331,12 @@ void AssertionNode::BacktrackIfPrevious(

BlockLabel fall_through, dummy;

- BlockLabel* non_word = backtrack_if_previous == kIsNonWord ?

- new_trace.backtrack() :

- &fall_through;

- BlockLabel* word = backtrack_if_previous == kIsNonWord ?

- &fall_through :

- new_trace.backtrack();

+ BlockLabel* non_word = backtrack_if_previous == kIsNonWord

+ ? new_trace.backtrack()

+ : &fall_through;

+ BlockLabel* word = backtrack_if_previous == kIsNonWord

+ ? &fall_through

+ : new_trace.backtrack();

if (new_trace.cp_offset() == 0) {

// The start of input counts as a non-word character, so the question is

@@ -2472,9 +2361,7 @@ void AssertionNode::GetQuickCheckDetails(QuickCheckDetails* details,

details->set_cannot_match();

return;

}

- return on_success()->GetQuickCheckDetails(details,

- compiler,

- filled_in,

+ return on_success()->GetQuickCheckDetails(details, compiler, filled_in,

not_at_start);

}

@@ -2501,8 +2388,7 @@ void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {

on_success()->Emit(compiler, &at_start_trace);

return;

}

- }

- break;

+ } break;

case AFTER_NEWLINE:

EmitHat(compiler, on_success(), trace);

return;

@@ -2600,13 +2486,9 @@ void TextNode::TextEmitPass(RegExpCompiler* compiler,

break;

}

if (emit_function != NULL) {

- bool bound_checked = emit_function(Z,

- compiler,

- quarks->At(j),

- backtrack,

- cp_offset + j,

- *checked_up_to < cp_offset + j,

- preloaded);

+ bool bound_checked = emit_function(

+ Z, compiler, quarks->At(j), backtrack, cp_offset + j,

+ *checked_up_to < cp_offset + j, preloaded);

if (bound_checked) UpdateBoundsCheck(cp_offset + j, checked_up_to);

}

@@ -2616,14 +2498,8 @@ void TextNode::TextEmitPass(RegExpCompiler* compiler,

if (first_element_checked && i == 0) continue;

if (DeterminedAlready(quick_check, elm.cp_offset())) continue;

RegExpCharacterClass* cc = elm.char_class();

- EmitCharClass(assembler,

- cc,

- one_byte,

- backtrack,

- cp_offset,

- *checked_up_to < cp_offset,

- preloaded,

- Z);

+ EmitCharClass(assembler, cc, one_byte, backtrack, cp_offset,

+ *checked_up_to < cp_offset, preloaded, Z);

UpdateBoundsCheck(cp_offset, checked_up_to);

}

@@ -2678,12 +2554,8 @@ void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {

if (trace->characters_preloaded() == 1) {

for (intptr_t pass = kFirstRealPass; pass <= kLastPass; pass++) {

if (!SkipPass(pass, compiler->ignore_case())) {

- TextEmitPass(compiler,

- static_cast<TextEmitPassType>(pass),

- true,

- trace,

- false,

- &bound_checked_to);

+ TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), true, trace,

+ false, &bound_checked_to);

}

first_elt_done = true;

@@ -2691,12 +2563,8 @@ void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {

for (intptr_t pass = kFirstRealPass; pass <= kLastPass; pass++) {

if (!SkipPass(pass, compiler->ignore_case())) {

- TextEmitPass(compiler,

- static_cast<TextEmitPassType>(pass),

- false,

- trace,

- first_elt_done,

- &bound_checked_to);

+ TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), false, trace,

+ first_elt_done, &bound_checked_to);

}

@@ -2729,8 +2597,8 @@ void Trace::AdvanceCurrentPositionInTrace(intptr_t by,

compiler->SetRegExpTooBig();

cp_offset_ = 0;

}

- bound_checked_up_to_ = Utils::Maximum(static_cast<intptr_t>(0),

- bound_checked_up_to_ - by);

+ bound_checked_up_to_ =

+ Utils::Maximum(static_cast<intptr_t>(0), bound_checked_up_to_ - by);

}

@@ -2849,8 +2717,8 @@ void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {

intptr_t ChoiceNode::CalculatePreloadCharacters(RegExpCompiler* compiler,

intptr_t eats_at_least) {

- intptr_t preload_characters = Utils::Minimum(static_cast<intptr_t>(4),

- eats_at_least);

+ intptr_t preload_characters =

+ Utils::Minimum(static_cast<intptr_t>(4), eats_at_least);

if (compiler->macro_assembler()->CanReadUnaligned()) {

bool one_byte = compiler->one_byte();

if (one_byte) {

@@ -2876,7 +2744,7 @@ struct AlternativeGeneration {

: possible_success(),

expects_preload(false),

after(),

- quick_check_details() { }

+ quick_check_details() {}

BlockLabel possible_success;

bool expects_preload;

BlockLabel after;

@@ -2888,8 +2756,7 @@ struct AlternativeGeneration {

// size then it is on the stack, otherwise the excess is on the heap.

class AlternativeGenerationList {

public:

- explicit AlternativeGenerationList(intptr_t count)

- : alt_gens_(count) {

+ explicit AlternativeGenerationList(intptr_t count) : alt_gens_(count) {

for (intptr_t i = 0; i < count && i < kAFew; i++) {

alt_gens_.Add(a_few_alt_gens_ + i);

}

@@ -2904,9 +2771,7 @@ class AlternativeGenerationList {

}

- AlternativeGeneration* at(intptr_t i) {

- return alt_gens_[i];

- }

+ AlternativeGeneration* at(intptr_t i) { return alt_gens_[i]; }

private:

static const intptr_t kAFew = 10;

@@ -2920,20 +2785,20 @@ class AlternativeGenerationList {

// The '2' variant is inclusive from and exclusive to.

// This covers \s as defined in ECMA-262 5.1, 15.10.2.12,

// which include WhiteSpace (7.2) or LineTerminator (7.3) values.

-static const intptr_t kSpaceRanges[] = { '\t', '\r' + 1, ' ', ' ' + 1,

- 0x00A0, 0x00A1, 0x1680, 0x1681, 0x180E, 0x180F, 0x2000, 0x200B,

- 0x2028, 0x202A, 0x202F, 0x2030, 0x205F, 0x2060, 0x3000, 0x3001,

- 0xFEFF, 0xFF00, 0x10000 };

+static const intptr_t kSpaceRanges[] = {

+ '\t', '\r' + 1, ' ', ' ' + 1, 0x00A0, 0x00A1, 0x1680, 0x1681,

+ 0x180E, 0x180F, 0x2000, 0x200B, 0x2028, 0x202A, 0x202F, 0x2030,

+ 0x205F, 0x2060, 0x3000, 0x3001, 0xFEFF, 0xFF00, 0x10000};

static const intptr_t kSpaceRangeCount = ARRAY_SIZE(kSpaceRanges);

-static const intptr_t kWordRanges[] = {

- '0', '9' + 1, 'A', 'Z' + 1, '_', '_' + 1, 'a', 'z' + 1, 0x10000 };

+static const intptr_t kWordRanges[] = {'0', '9' + 1, 'A', 'Z' + 1, '_',

+ '_' + 1, 'a', 'z' + 1, 0x10000};

static const intptr_t kWordRangeCount = ARRAY_SIZE(kWordRanges);

-static const intptr_t kDigitRanges[] = { '0', '9' + 1, 0x10000 };

+static const intptr_t kDigitRanges[] = {'0', '9' + 1, 0x10000};

static const intptr_t kDigitRangeCount = ARRAY_SIZE(kDigitRanges);

-static const intptr_t kSurrogateRanges[] = { 0xd800, 0xe000, 0x10000 };

+static const intptr_t kSurrogateRanges[] = {0xd800, 0xe000, 0x10000};

static const intptr_t kSurrogateRangeCount = ARRAY_SIZE(kSurrogateRanges);

-static const intptr_t kLineTerminatorRanges[] = {

- 0x000A, 0x000B, 0x000D, 0x000E, 0x2028, 0x202A, 0x10000 };

+static const intptr_t kLineTerminatorRanges[] = {0x000A, 0x000B, 0x000D, 0x000E,

+ 0x2028, 0x202A, 0x10000};

static const intptr_t kLineTerminatorRangeCount =

ARRAY_SIZE(kLineTerminatorRanges);

@@ -2952,7 +2817,8 @@ void BoyerMoorePositionInfo::SetInterval(const Interval& interval) {

if (interval.to() - interval.from() >= kMapSize - 1) {

if (map_count_ != kMapSize) {

map_count_ = kMapSize;

- for (intptr_t i = 0; i < kMapSize; i++) (*map_)[i] = true;

+ for (intptr_t i = 0; i < kMapSize; i++)

+ (*map_)[i] = true;

}

return;

}

@@ -2971,23 +2837,24 @@ void BoyerMoorePositionInfo::SetAll() {

s_ = w_ = d_ = kLatticeUnknown;

if (map_count_ != kMapSize) {

map_count_ = kMapSize;

- for (intptr_t i = 0; i < kMapSize; i++) (*map_)[i] = true;

+ for (intptr_t i = 0; i < kMapSize; i++)

+ (*map_)[i] = true;

}

-BoyerMooreLookahead::BoyerMooreLookahead(

- intptr_t length, RegExpCompiler* compiler, Zone* zone)

- : length_(length),

- compiler_(compiler) {

+BoyerMooreLookahead::BoyerMooreLookahead(intptr_t length,

+ RegExpCompiler* compiler,

+ Zone* zone)

+ : length_(length), compiler_(compiler) {

if (compiler->one_byte()) {

max_char_ = Symbols::kMaxOneCharCodeSymbol;

} else {

max_char_ = Utf16::kMaxCodeUnit;

}

- bitmaps_ = new(zone) ZoneGrowableArray<BoyerMoorePositionInfo*>(length);

+ bitmaps_ = new (zone) ZoneGrowableArray<BoyerMoorePositionInfo*>(length);

for (intptr_t i = 0; i < length; i++) {

- bitmaps_->Add(new(zone) BoyerMoorePositionInfo(zone));

+ bitmaps_->Add(new (zone) BoyerMoorePositionInfo(zone));

}

@@ -3000,8 +2867,7 @@ bool BoyerMooreLookahead::FindWorthwhileInterval(intptr_t* from, intptr_t* to) {

// If more than 32 characters out of 128 can occur it is unlikely that we can

// be lucky enough to step forwards much of the time.

const intptr_t kMaxMax = 32;

- for (intptr_t max_number_of_chars = 4;

- max_number_of_chars < kMaxMax;

+ for (intptr_t max_number_of_chars = 4; max_number_of_chars < kMaxMax;

max_number_of_chars *= 2) {

biggest_points =

FindBestInterval(max_number_of_chars, biggest_points, from, to);

@@ -3017,22 +2883,24 @@ bool BoyerMooreLookahead::FindWorthwhileInterval(intptr_t* from, intptr_t* to) {

// of points as the product of width-of-the-range and

// probability-of-finding-one-of-the-characters, where the probability is

// calculated using the frequency distribution of the sample subject string.

-intptr_t BoyerMooreLookahead::FindBestInterval(

- intptr_t max_number_of_chars,

- intptr_t old_biggest_points,

- intptr_t* from,

- intptr_t* to) {

+intptr_t BoyerMooreLookahead::FindBestInterval(intptr_t max_number_of_chars,

+ intptr_t old_biggest_points,

+ intptr_t* from,

+ intptr_t* to) {

intptr_t biggest_points = old_biggest_points;

static const intptr_t kSize = RegExpMacroAssembler::kTableSize;

- for (intptr_t i = 0; i < length_; ) {

- while (i < length_ && Count(i) > max_number_of_chars) i++;

+ for (intptr_t i = 0; i < length_;) {

+ while (i < length_ && Count(i) > max_number_of_chars)

+ i++;

if (i == length_) break;

intptr_t remembered_from = i;

bool union_map[kSize];

- for (intptr_t j = 0; j < kSize; j++) union_map[j] = false;

+ for (intptr_t j = 0; j < kSize; j++)

+ union_map[j] = false;

while (i < length_ && Count(i) <= max_number_of_chars) {

BoyerMoorePositionInfo* map = bitmaps_->At(i);

- for (intptr_t j = 0; j < kSize; j++) union_map[j] |= map->at(j);

+ for (intptr_t j = 0; j < kSize; j++)

+ union_map[j] |= map->at(j);

i++;

}

intptr_t frequency = 0;

@@ -3051,8 +2919,9 @@ intptr_t BoyerMooreLookahead::FindBestInterval(

// dividing by 2 we switch off the skipping if the probability of skipping

// is less than 50%. This is because the multibyte mask-and-compare

// skipping in quickcheck is more likely to do well on this case.

- bool in_quickcheck_range = ((i - remembered_from < 4) ||

- (compiler_->one_byte() ? remembered_from <= 4 : remembered_from <= 2));

+ bool in_quickcheck_range =

+ ((i - remembered_from < 4) ||

+ (compiler_->one_byte() ? remembered_from <= 4 : remembered_from <= 2));

// Called 'probability' but it is only a rough estimate and can actually

// be outside the 0-kSize range.

intptr_t probability =

@@ -3140,8 +3009,7 @@ void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {

masm->LoadCurrentCharacter(max_lookahead, &cont, true);

if (max_char_ > kSize) {

masm->CheckCharacterAfterAnd(single_character,

- RegExpMacroAssembler::kTableMask,

- &cont);

+ RegExpMacroAssembler::kTableMask, &cont);

} else {

masm->CheckCharacter(single_character, &cont);

}

@@ -3152,10 +3020,10 @@ void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {

}

const TypedData& boolean_skip_table = TypedData::ZoneHandle(

- compiler_->zone(),

- TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));

- intptr_t skip_distance = GetSkipTable(

- min_lookahead, max_lookahead, boolean_skip_table);

+ compiler_->zone(),

+ TypedData::New(kTypedDataUint8ArrayCid, kSize, Heap::kOld));

+ intptr_t skip_distance =

+ GetSkipTable(min_lookahead, max_lookahead, boolean_skip_table);

ASSERT(skip_distance != 0);

BlockLabel cont, again;

@@ -3269,18 +3137,18 @@ void ChoiceNode::AssertGuardsMentionRegisters(Trace* trace) {

void ChoiceNode::SetUpPreLoad(RegExpCompiler* compiler,

Trace* current_trace,

PreloadState* state) {

- if (state->eats_at_least_ == PreloadState::kEatsAtLeastNotYetInitialized) {

- // Save some time by looking at most one machine word ahead.

- state->eats_at_least_ =

- EatsAtLeast(compiler->one_byte() ? 4 : 2, kRecursionBudget,

- current_trace->at_start() == Trace::FALSE_VALUE);

- }

- state->preload_characters_ =

- CalculatePreloadCharacters(compiler, state->eats_at_least_);

+ if (state->eats_at_least_ == PreloadState::kEatsAtLeastNotYetInitialized) {

+ // Save some time by looking at most one machine word ahead.

+ state->eats_at_least_ =

+ EatsAtLeast(compiler->one_byte() ? 4 : 2, kRecursionBudget,

+ current_trace->at_start() == Trace::FALSE_VALUE);

+ }

+ state->preload_characters_ =

+ CalculatePreloadCharacters(compiler, state->eats_at_least_);

- state->preload_is_current_ =

- (current_trace->characters_preloaded() == state->preload_characters_);

- state->preload_has_checked_bounds_ = state->preload_is_current_;

+ state->preload_is_current_ =

+ (current_trace->characters_preloaded() == state->preload_characters_);

+ state->preload_has_checked_bounds_ = state->preload_is_current_;

}

@@ -3311,12 +3179,8 @@ void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {

AlternativeGenerationList alt_gens(choice_count);

if (choice_count > 1 && text_length != kNodeIsTooComplexForGreedyLoops) {

- trace = EmitGreedyLoop(compiler,

- trace,

- &alt_gens,

- &preload,

- &greedy_loop_state,

- text_length);

+ trace = EmitGreedyLoop(compiler, trace, &alt_gens, &preload,

+ &greedy_loop_state, text_length);

} else {

// TODO(erikcorry): Delete this. We don't need this label, but it makes us

// match the traces produced pre-cleanup.

@@ -3325,11 +3189,7 @@ void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {

preload.eats_at_least_ = EmitOptimizedUnanchoredSearch(compiler, trace);

- EmitChoices(compiler,

- &alt_gens,

- 0,

- trace,

- &preload);

+ EmitChoices(compiler, &alt_gens, 0, trace, &preload);

}

// At this point we need to generate slow checks for the alternatives where

@@ -3347,11 +3207,8 @@ void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {

}

bool next_expects_preload =

i == choice_count - 1 ? false : alt_gens.at(i + 1)->expects_preload;

- EmitOutOfLineContinuation(compiler,

- &new_trace,

- alternatives_->At(i),

- alt_gen,

- preload.preload_characters_,

+ EmitOutOfLineContinuation(compiler, &new_trace, alternatives_->At(i),

+ alt_gen, preload.preload_characters_,

next_expects_preload);

}

@@ -3388,11 +3245,7 @@ Trace* ChoiceNode::EmitGreedyLoop(RegExpCompiler* compiler,

Trace* new_trace = greedy_loop_state->counter_backtrack_trace();

- EmitChoices(compiler,

- alt_gens,

- 1,

- new_trace,

- preload);

+ EmitChoices(compiler, alt_gens, 1, new_trace, preload);

macro_assembler->BindBlock(greedy_loop_state->label());

// If we have unwound to the bottom then backtrack.

@@ -3436,12 +3289,11 @@ intptr_t ChoiceNode::EmitOptimizedUnanchoredSearch(RegExpCompiler* compiler,

// small alternation.

BoyerMooreLookahead* bm = bm_info(false);

if (bm == NULL) {

- eats_at_least = Utils::Minimum(kMaxLookaheadForBoyerMoore,

- EatsAtLeast(kMaxLookaheadForBoyerMoore,

- kRecursionBudget,

- false));

+ eats_at_least = Utils::Minimum(

+ kMaxLookaheadForBoyerMoore,

+ EatsAtLeast(kMaxLookaheadForBoyerMoore, kRecursionBudget, false));

if (eats_at_least >= 1) {

- bm = new(Z) BoyerMooreLookahead(eats_at_least, compiler, Z);

+ bm = new (Z) BoyerMooreLookahead(eats_at_least, compiler, Z);

GuardedAlternative alt0 = alternatives_->At(0);

alt0.node()->FillInBMInfo(0, kRecursionBudget, bm, false);

}

@@ -3476,9 +3328,8 @@ void ChoiceNode::EmitChoices(RegExpCompiler* compiler,

ZoneGrowableArray<Guard*>* guards = alternative.guards();

intptr_t guard_count = (guards == NULL) ? 0 : guards->length();

Trace new_trace(*trace);

- new_trace.set_characters_preloaded(preload->preload_is_current_ ?

- preload->preload_characters_ :

- 0);

+ new_trace.set_characters_preloaded(

+ preload->preload_is_current_ ? preload->preload_characters_ : 0);

if (preload->preload_has_checked_bounds_) {

new_trace.set_bound_checked_up_to(preload->preload_characters_);

}

@@ -3491,13 +3342,10 @@ void ChoiceNode::EmitChoices(RegExpCompiler* compiler,

bool generate_full_check_inline = false;

if (kRegexpOptimization &&

try_to_emit_quick_check_for_alternative(i == 0) &&

- alternative.node()->EmitQuickCheck(compiler,

- trace,

- &new_trace,

- preload->preload_has_checked_bounds_,

- &alt_gen->possible_success,

- &alt_gen->quick_check_details,

- fall_through_on_failure)) {

+ alternative.node()->EmitQuickCheck(

+ compiler, trace, &new_trace, preload->preload_has_checked_bounds_,

+ &alt_gen->possible_success, &alt_gen->quick_check_details,

+ fall_through_on_failure)) {

// Quick check was generated for this choice.

preload->preload_is_current_ = true;

preload->preload_has_checked_bounds_ = true;

@@ -3569,9 +3417,7 @@ void ChoiceNode::EmitOutOfLineContinuation(RegExpCompiler* compiler,

// Reload the current character, since the next quick check expects that.

// We don't need to check bounds here because we only get into this

// code through a quick check which already did the checked load.

- macro_assembler->LoadCurrentCharacter(trace->cp_offset(),

- NULL,

- false,

+ macro_assembler->LoadCurrentCharacter(trace->cp_offset(), NULL, false,

preload_characters);

macro_assembler->GoTo(&(alt_gen->after));

} else {

@@ -3594,35 +3440,33 @@ void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {

switch (action_type_) {

case STORE_POSITION: {

- Trace::DeferredCapture

- new_capture(data_.u_position_register.reg,

- data_.u_position_register.is_capture,

- trace);

+ Trace::DeferredCapture new_capture(data_.u_position_register.reg,

+ data_.u_position_register.is_capture,

+ trace);

Trace new_trace = *trace;

new_trace.add_action(&new_capture);

on_success()->Emit(compiler, &new_trace);

break;

}

case INCREMENT_REGISTER: {

- Trace::DeferredIncrementRegister

- new_increment(data_.u_increment_register.reg);

+ Trace::DeferredIncrementRegister new_increment(

+ data_.u_increment_register.reg);

Trace new_trace = *trace;

new_trace.add_action(&new_increment);

on_success()->Emit(compiler, &new_trace);

break;

}

case SET_REGISTER: {

- Trace::DeferredSetRegister

- new_set(data_.u_store_register.reg, data_.u_store_register.value);

+ Trace::DeferredSetRegister new_set(data_.u_store_register.reg,

+ data_.u_store_register.value);

Trace new_trace = *trace;

new_trace.add_action(&new_set);

on_success()->Emit(compiler, &new_trace);

break;

}

case CLEAR_CAPTURES: {

- Trace::DeferredClearCaptures

- new_capture(Interval(data_.u_clear_captures.range_from,

- data_.u_clear_captures.range_to));

+ Trace::DeferredClearCaptures new_capture(Interval(

+ data_.u_clear_captures.range_from, data_.u_clear_captures.range_to));

Trace new_trace = *trace;

new_trace.add_action(&new_capture);

on_success()->Emit(compiler, &new_trace);

@@ -3722,8 +3566,7 @@ void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {

ASSERT(start_reg_ + 1 == end_reg_);

if (compiler->ignore_case()) {

- assembler->CheckNotBackReferenceIgnoreCase(start_reg_,

- trace->backtrack());

+ assembler->CheckNotBackReferenceIgnoreCase(start_reg_, trace->backtrack());

} else {

assembler->CheckNotBackReference(start_reg_, trace->backtrack());

}

@@ -3738,16 +3581,15 @@ void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {

#ifdef DEBUG

-class DotPrinter: public NodeVisitor {

+class DotPrinter : public NodeVisitor {

public:

explicit DotPrinter(bool ignore_case) {}

void PrintNode(const char* label, RegExpNode* node);

void Visit(RegExpNode* node);

void PrintAttributes(RegExpNode* from);

void PrintOnFailure(RegExpNode* from, RegExpNode* to);

-#define DECLARE_VISIT(Type) \

- virtual void Visit##Type(Type##Node* that);

-FOR_EACH_NODE_TYPE(DECLARE_VISIT)

+#define DECLARE_VISIT(Type) virtual void Visit##Type(Type##Node* that);

+ FOR_EACH_NODE_TYPE(DECLARE_VISIT)

#undef DECLARE_VISIT

};

@@ -3813,19 +3655,21 @@ class AttributePrinter : public ValueObject {

void DotPrinter::PrintAttributes(RegExpNode* that) {

- OS::Print(" a%p [shape=Mrecord, color=grey, fontcolor=grey, "

- "margin=0.1, fontsize=10, label=\"{", that);

+ OS::Print(

+ " a%p [shape=Mrecord, color=grey, fontcolor=grey, "

+ "margin=0.1, fontsize=10, label=\"{",

+ that);

AttributePrinter printer;

NodeInfo* info = that->info();

printer.PrintBit("NI", info->follows_newline_interest);

printer.PrintBit("WI", info->follows_word_interest);

printer.PrintBit("SI", info->follows_start_interest);

BlockLabel* label = that->label();

- if (label->IsBound())

- printer.PrintPositive("@", label->Position());

- OS::Print("}\"];\n"

- " a%p -> n%p [style=dashed, color=grey, arrowhead=none];\n",

- that, that);

+ if (label->IsBound()) printer.PrintPositive("@", label->Position());

+ OS::Print(

+ "}\"];\n"

+ " a%p -> n%p [style=dashed, color=grey, arrowhead=none];\n",

+ that, that);

}

@@ -3985,20 +3829,20 @@ void RegExpEngine::DotPrint(const char* label,

RegExpNode* RegExpAtom::ToNode(RegExpCompiler* compiler,

RegExpNode* on_success) {

ZoneGrowableArray<TextElement>* elms =

- new(OZ) ZoneGrowableArray<TextElement>(1);

+ new (OZ) ZoneGrowableArray<TextElement>(1);

elms->Add(TextElement::Atom(this));

- return new(OZ) TextNode(elms, on_success);

+ return new (OZ) TextNode(elms, on_success);

}

RegExpNode* RegExpText::ToNode(RegExpCompiler* compiler,

RegExpNode* on_success) {

ZoneGrowableArray<TextElement>* elms =

- new(OZ) ZoneGrowableArray<TextElement>(1);

- for (intptr_t i = 0; i < elements()->length(); i++) {

+ new (OZ) ZoneGrowableArray<TextElement>(1);

+ for (intptr_t i = 0; i < elements()->length(); i++) {

elms->Add(elements()->At(i));

}

- return new(OZ) TextNode(elms, on_success);

+ return new (OZ) TextNode(elms, on_success);

}

@@ -4022,7 +3866,7 @@ static bool CompareInverseRanges(ZoneGrowableArray<CharacterRange>* ranges,

return false;

}

range = ranges->At((i >> 1) + 1);

- if (special_class[i+1] != range.from()) {

+ if (special_class[i + 1] != range.from()) {

return false;

}

@@ -4069,14 +3913,12 @@ bool RegExpCharacterClass::is_standard() {

set_.set_standard_set_type('S');

return true;

}

- if (CompareInverseRanges(set_.ranges(),

- kLineTerminatorRanges,

+ if (CompareInverseRanges(set_.ranges(), kLineTerminatorRanges,

kLineTerminatorRangeCount)) {

set_.set_standard_set_type('.');

return true;

}

- if (CompareRanges(set_.ranges(),

- kLineTerminatorRanges,

+ if (CompareRanges(set_.ranges(), kLineTerminatorRanges,

kLineTerminatorRangeCount)) {

set_.set_standard_set_type('n');

return true;

@@ -4095,7 +3937,7 @@ bool RegExpCharacterClass::is_standard() {

RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,

RegExpNode* on_success) {

- return new(OZ) TextNode(this, on_success);

+ return new (OZ) TextNode(this, on_success);

}

@@ -4103,11 +3945,10 @@ RegExpNode* RegExpDisjunction::ToNode(RegExpCompiler* compiler,

RegExpNode* on_success) {

ZoneGrowableArray<RegExpTree*>* alternatives = this->alternatives();

intptr_t length = alternatives->length();

- ChoiceNode* result =

- new(OZ) ChoiceNode(length, OZ);

+ ChoiceNode* result = new (OZ) ChoiceNode(length, OZ);

for (intptr_t i = 0; i < length; i++) {

- GuardedAlternative alternative(alternatives->At(i)->ToNode(compiler,

- on_success));

+ GuardedAlternative alternative(

+ alternatives->At(i)->ToNode(compiler, on_success));

result->AddAlternative(alternative);

}

return result;

@@ -4116,12 +3957,7 @@ RegExpNode* RegExpDisjunction::ToNode(RegExpCompiler* compiler,

RegExpNode* RegExpQuantifier::ToNode(RegExpCompiler* compiler,

RegExpNode* on_success) {

- return ToNode(min(),

- max(),

- is_greedy(),

- body(),

- compiler,

- on_success);

+ return ToNode(min(), max(), is_greedy(), body(), compiler, on_success);

}

@@ -4207,14 +4043,13 @@ RegExpNode* RegExpQuantifier::ToNode(intptr_t min,

// Only unroll if there are no captures and the body can't be

// empty.

{

- RegExpExpansionLimiter limiter(

- compiler, min + ((max != min) ? 1 : 0));

+ RegExpExpansionLimiter limiter(compiler, min + ((max != min) ? 1 : 0));

if (min > 0 && min <= kMaxUnrolledMinMatches && limiter.ok_to_expand()) {

intptr_t new_max = (max == kInfinity) ? max : max - min;

// Recurse once to get the loop or optional matches after the fixed

// ones.

- RegExpNode* answer = ToNode(

- 0, new_max, is_greedy, body, compiler, on_success, true);

+ RegExpNode* answer =

+ ToNode(0, new_max, is_greedy, body, compiler, on_success, true);

// Unroll the forced matches from 0 to min. This can cause chains of

// TextNodes (which the parser does not generate). These should be

// combined if it turns out they hinder good code generation.

@@ -4231,7 +4066,7 @@ RegExpNode* RegExpQuantifier::ToNode(intptr_t min,

// Unroll the optional matches up to max.

RegExpNode* answer = on_success;

for (intptr_t i = 0; i < max; i++) {

- ChoiceNode* alternation = new(zone) ChoiceNode(2, zone);

+ ChoiceNode* alternation = new (zone) ChoiceNode(2, zone);

if (is_greedy) {

alternation->AddAlternative(

GuardedAlternative(body->ToNode(compiler, answer)));

@@ -4251,22 +4086,20 @@ RegExpNode* RegExpQuantifier::ToNode(intptr_t min,

bool has_min = min > 0;

bool has_max = max < RegExpTree::kInfinity;

bool needs_counter = has_min || has_max;

- intptr_t reg_ctr = needs_counter

- ? compiler->AllocateRegister()

- : RegExpCompiler::kNoRegister;

- LoopChoiceNode* center = new(zone) LoopChoiceNode(body->min_match() == 0,

- zone);

+ intptr_t reg_ctr = needs_counter ? compiler->AllocateRegister()

+ : RegExpCompiler::kNoRegister;

+ LoopChoiceNode* center =

+ new (zone) LoopChoiceNode(body->min_match() == 0, zone);

if (not_at_start) center->set_not_at_start();

- RegExpNode* loop_return = needs_counter

- ? static_cast<RegExpNode*>(ActionNode::IncrementRegister(reg_ctr, center))

- : static_cast<RegExpNode*>(center);

+ RegExpNode* loop_return =

+ needs_counter ? static_cast<RegExpNode*>(

+ ActionNode::IncrementRegister(reg_ctr, center))

+ : static_cast<RegExpNode*>(center);

if (body_can_be_empty) {

// If the body can be empty we need to check if it was and then

// backtrack.

- loop_return = ActionNode::EmptyMatchCheck(body_start_reg,

- reg_ctr,

- min,

- loop_return);

+ loop_return =

+ ActionNode::EmptyMatchCheck(body_start_reg, reg_ctr, min, loop_return);

}

RegExpNode* body_node = body->ToNode(compiler, loop_return);

if (body_can_be_empty) {

@@ -4280,13 +4113,12 @@ RegExpNode* RegExpQuantifier::ToNode(intptr_t min,

}

GuardedAlternative body_alt(body_node);

if (has_max) {

- Guard* body_guard =

- new(zone) Guard(reg_ctr, Guard::LT, max);

+ Guard* body_guard = new (zone) Guard(reg_ctr, Guard::LT, max);

body_alt.AddGuard(body_guard, zone);

}

GuardedAlternative rest_alt(on_success);

if (has_min) {

- Guard* rest_guard = new(zone) Guard(reg_ctr, Guard::GEQ, min);

+ Guard* rest_guard = new (zone) Guard(reg_ctr, Guard::GEQ, min);

rest_alt.AddGuard(rest_guard, zone);

}

if (is_greedy) {

@@ -4331,17 +4163,14 @@ RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,

CharacterRange::AddClassEscape('n', newline_ranges);

RegExpCharacterClass* newline_atom = new RegExpCharacterClass('n');

TextNode* newline_matcher = new TextNode(

- newline_atom,

- ActionNode::PositiveSubmatchSuccess(stack_pointer_register,

- position_register,

- 0, // No captures inside.

- -1, // Ignored if no captures.

- on_success));

+ newline_atom, ActionNode::PositiveSubmatchSuccess(

+ stack_pointer_register, position_register,

+ 0, // No captures inside.

+ -1, // Ignored if no captures.

+ on_success));

// Create an end-of-input matcher.

RegExpNode* end_of_line = ActionNode::BeginSubmatch(

- stack_pointer_register,

- position_register,

- newline_matcher);

+ stack_pointer_register, position_register, newline_matcher);

// Add the two alternatives to the ChoiceNode.

GuardedAlternative eol_alternative(end_of_line);

result->AddAlternative(eol_alternative);

@@ -4358,10 +4187,9 @@ RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,

RegExpNode* RegExpBackReference::ToNode(RegExpCompiler* compiler,

RegExpNode* on_success) {

- return new(OZ)

+ return new (OZ)

BackReferenceNode(RegExpCapture::StartRegister(index()),

- RegExpCapture::EndRegister(index()),

- on_success);

+ RegExpCapture::EndRegister(index()), on_success);

}

@@ -4380,20 +4208,16 @@ RegExpNode* RegExpLookahead::ToNode(RegExpCompiler* compiler,

const intptr_t register_of_first_capture = 2;

intptr_t register_count = capture_count_ * registers_per_capture;

intptr_t register_start =

- register_of_first_capture + capture_from_ * registers_per_capture;

+ register_of_first_capture + capture_from_ * registers_per_capture;

RegExpNode* success;

if (is_positive()) {

RegExpNode* node = ActionNode::BeginSubmatch(

- stack_pointer_register,

- position_register,

- body()->ToNode(

- compiler,

- ActionNode::PositiveSubmatchSuccess(stack_pointer_register,

- position_register,

- register_count,

- register_start,

- on_success)));

+ stack_pointer_register, position_register,

+ body()->ToNode(compiler,

+ ActionNode::PositiveSubmatchSuccess(

+ stack_pointer_register, position_register,

+ register_count, register_start, on_success)));

return node;

} else {

// We use a ChoiceNode for a negative lookahead because it has most of

@@ -4408,19 +4232,12 @@ RegExpNode* RegExpLookahead::ToNode(RegExpCompiler* compiler,

// checks.

GuardedAlternative body_alt(

- body()->ToNode(

- compiler,

- success = new(OZ) NegativeSubmatchSuccess(stack_pointer_register,

- position_register,

- register_count,

- register_start,

- OZ)));

- ChoiceNode* choice_node =

- new(OZ) NegativeLookaheadChoiceNode(body_alt,

- GuardedAlternative(on_success),

- OZ);

- return ActionNode::BeginSubmatch(stack_pointer_register,

- position_register,

+ body()->ToNode(compiler, success = new (OZ) NegativeSubmatchSuccess(

+ stack_pointer_register, position_register,

+ register_count, register_start, OZ)));

+ ChoiceNode* choice_node = new (OZ) NegativeLookaheadChoiceNode(

+ body_alt, GuardedAlternative(on_success), OZ);

+ return ActionNode::BeginSubmatch(stack_pointer_register, position_register,

choice_node);

}

@@ -4467,13 +4284,13 @@ static void AddClass(const intptr_t* elmv,

}

-static void AddClassNegated(const intptr_t *elmv,

+static void AddClassNegated(const intptr_t* elmv,

intptr_t elmc,

ZoneGrowableArray<CharacterRange>* ranges) {

elmc--;

ASSERT(elmv[elmc] == 0x10000);

ASSERT(elmv[0] != 0x0000);

- ASSERT(elmv[elmc-1] != Utf16::kMaxCodeUnit);

+ ASSERT(elmv[elmc - 1] != Utf16::kMaxCodeUnit);

uint16_t last = 0x0000;

for (intptr_t i = 0; i < elmc; i += 2) {

ASSERT(last <= elmv[i] - 1);

@@ -4507,9 +4324,7 @@ void CharacterRange::AddClassEscape(uint16_t type,

AddClassNegated(kDigitRanges, kDigitRangeCount, ranges);

break;

case '.':

- AddClassNegated(kLineTerminatorRanges,

- kLineTerminatorRangeCount,

- ranges);

+ AddClassNegated(kLineTerminatorRanges, kLineTerminatorRangeCount, ranges);

break;

// This is not a character range as defined by the spec but a

// convenient shorthand for a character class that matches any

@@ -4520,9 +4335,7 @@ void CharacterRange::AddClassEscape(uint16_t type,

// This is the set of characters matched by the $ and ^ symbols

// in multiline mode.

case 'n':

- AddClass(kLineTerminatorRanges,

- kLineTerminatorRangeCount,

- ranges);

+ AddClass(kLineTerminatorRanges, kLineTerminatorRangeCount, ranges);

break;

default:

UNREACHABLE();

@@ -4531,9 +4344,9 @@ void CharacterRange::AddClassEscape(uint16_t type,

void CharacterRange::AddCaseEquivalents(

- ZoneGrowableArray<CharacterRange>* ranges,

- bool is_one_byte,

- Zone* zone) {

+ ZoneGrowableArray<CharacterRange>* ranges,

+ bool is_one_byte,

+ Zone* zone) {

uint16_t bottom = from();

uint16_t top = to();

if (is_one_byte && !RangeContainsLatin1Equivalents(*this)) {

@@ -4548,7 +4361,8 @@ void CharacterRange::AddCaseEquivalents(

int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];

if (top == bottom) {

// If this is a singleton we just expand the one character.

- intptr_t length = jsregexp_uncanonicalize.get(bottom, '\0', chars); // NOLINT

+ intptr_t length =

+ jsregexp_uncanonicalize.get(bottom, '\0', chars); // NOLINT

for (intptr_t i = 0; i < length; i++) {

uint32_t chr = chars[i];

if (chr != bottom) {

@@ -4586,7 +4400,7 @@ void CharacterRange::AddCaseEquivalents(

block_end = range[0];

}

intptr_t end = (block_end > top) ? top : block_end;

- length = jsregexp_uncanonicalize.get(block_end, '\0', range); // NOLINT

+ length = jsregexp_uncanonicalize.get(block_end, '\0', range); // NOLINT

for (intptr_t i = 0; i < length; i++) {

uint32_t c = range[i];

uint16_t range_from = c - (block_end - pos);

@@ -4644,9 +4458,9 @@ static void MoveRanges(ZoneGrowableArray<CharacterRange>* list,

static intptr_t InsertRangeInCanonicalList(

- ZoneGrowableArray<CharacterRange>* list,

- intptr_t count,

- CharacterRange insert) {

+ ZoneGrowableArray<CharacterRange>* list,

+ intptr_t count,

+ CharacterRange insert) {

// Inserts a range into list[0..count[, which must be sorted

// by from value and non-overlapping and non-adjacent, using at most

// list[0..count] for the result. Returns the number of resulting

@@ -4734,11 +4548,10 @@ void CharacterRange::Canonicalize(

// list, in order).

// Notice that inserting a range can reduce the number of ranges in the

// result due to combining of adjacent and overlapping ranges.

- intptr_t read = i; // Range to insert.

+ intptr_t read = i; // Range to insert.

intptr_t num_canonical = i; // Length of canonicalized part of list.

do {

- num_canonical = InsertRangeInCanonicalList(character_ranges,

- num_canonical,

+ num_canonical = InsertRangeInCanonicalList(character_ranges, num_canonical,

character_ranges->At(read));

read++;

} while (read < n);

@@ -4776,8 +4589,7 @@ void CharacterRange::Negate(ZoneGrowableArray<CharacterRange>* ranges,

// Workaround for the fact that ZoneGrowableArray does not have contains().

-static bool ArrayContains(ZoneGrowableArray<unsigned>* array,

- unsigned value) {

+static bool ArrayContains(ZoneGrowableArray<unsigned>* array, unsigned value) {

for (intptr_t i = 0; i < array->length(); i++) {

if (array->At(i) == value) {

return true;

@@ -4792,7 +4604,7 @@ void OutSet::Set(unsigned value, Zone* zone) {

first_ |= (1 << value);

} else {

if (remaining_ == NULL)

- remaining_ = new(zone) ZoneGrowableArray<unsigned>(1);

+ remaining_ = new (zone) ZoneGrowableArray<unsigned>(1);

bool remaining_contains_value = ArrayContains(remaining_, value);

if (remaining_->is_empty() || !remaining_contains_value) {

@@ -4818,8 +4630,7 @@ bool OutSet::Get(unsigned value) const {

void Analysis::EnsureAnalyzed(RegExpNode* that) {

- if (that->info()->been_analyzed || that->info()->being_analyzed)

- return;

+ if (that->info()->been_analyzed || that->info()->being_analyzed) return;

that->info()->being_analyzed = true;

that->Accept(this);

that->info()->being_analyzed = false;

@@ -4967,8 +4778,7 @@ void TextNode::FillInBMInfo(intptr_t initial_offset,

if (bm->compiler()->ignore_case()) {

int32_t chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];

intptr_t length = GetCaseIndependentLetters(

- character,

- bm->max_char() == Symbols::kMaxOneCharCodeSymbol,

+ character, bm->max_char() == Symbols::kMaxOneCharCodeSymbol,

chars);

for (intptr_t j = 0; j < length; j++) {

bm->Set(offset, chars[j]);

@@ -4987,8 +4797,8 @@ void TextNode::FillInBMInfo(intptr_t initial_offset,

for (intptr_t k = 0; k < ranges->length(); k++) {

CharacterRange& range = (*ranges)[k];

if (range.from() > max_char) continue;

- intptr_t to = Utils::Minimum(max_char,

- static_cast<intptr_t>(range.to()));

+ intptr_t to =

+ Utils::Minimum(max_char, static_cast<intptr_t>(range.to()));

bm->SetInterval(offset, Interval(range.from(), to));

}

@@ -4999,9 +4809,7 @@ void TextNode::FillInBMInfo(intptr_t initial_offset,

if (initial_offset == 0) set_bm_info(not_at_start, bm);

return;

}

- on_success()->FillInBMInfo(offset,

- budget - 1,

- bm,

+ on_success()->FillInBMInfo(offset, budget - 1, bm,

true); // Not at start after a text node.

if (initial_offset == 0) set_bm_info(not_at_start, bm);

}

@@ -5039,10 +4847,8 @@ RegExpEngine::CompilationResult RegExpEngine::CompileIR(

// I'm not sure the performance gains are relevant enough.

// Wrap the body of the regexp in capture #0.

- RegExpNode* captured_body = RegExpCapture::ToNode(data->tree,

- 0,

- &compiler,

- compiler.accept());

+ RegExpNode* captured_body =

+ RegExpCapture::ToNode(data->tree, 0, &compiler, compiler.accept());

RegExpNode* node = captured_body;

bool is_end_anchored = data->tree->IsAnchoredAtEnd();

@@ -5051,23 +4857,17 @@ RegExpEngine::CompilationResult RegExpEngine::CompileIR(

if (!is_start_anchored) {

// Add a .*? at the beginning, outside the body capture, unless

// this expression is anchored at the beginning.

- RegExpNode* loop_node =

- RegExpQuantifier::ToNode(0,

- RegExpTree::kInfinity,

- false,

- new(zone) RegExpCharacterClass('*'),

- &compiler,

- captured_body,

- data->contains_anchor);

+ RegExpNode* loop_node = RegExpQuantifier::ToNode(

+ 0, RegExpTree::kInfinity, false, new (zone) RegExpCharacterClass('*'),

+ &compiler, captured_body, data->contains_anchor);

if (data->contains_anchor) {

// Unroll loop once, to take care of the case that might start

// at the start of input.

- ChoiceNode* first_step_node = new(zone) ChoiceNode(2, zone);

+ ChoiceNode* first_step_node = new (zone) ChoiceNode(2, zone);

first_step_node->AddAlternative(GuardedAlternative(captured_body));

- first_step_node->AddAlternative(GuardedAlternative(

- new(zone) TextNode(

- new(zone) RegExpCharacterClass('*'), loop_node)));

+ first_step_node->AddAlternative(GuardedAlternative(new (zone) TextNode(

+ new (zone) RegExpCharacterClass('*'), loop_node)));

node = first_step_node;

} else {

node = loop_node;

@@ -5082,7 +4882,7 @@ RegExpEngine::CompilationResult RegExpEngine::CompileIR(

}

- if (node == NULL) node = new(zone) EndNode(EndNode::BACKTRACK, zone);

+ if (node == NULL) node = new (zone) EndNode(EndNode::BACKTRACK, zone);

data->node = node;

Analysis analysis(ignore_case, is_one_byte);

analysis.EnsureAnalyzed(node);

@@ -5094,17 +4894,13 @@ RegExpEngine::CompilationResult RegExpEngine::CompileIR(

// Native regexp implementation.

IRRegExpMacroAssembler* macro_assembler =

- new(zone) IRRegExpMacroAssembler(specialization_cid,

- data->capture_count,

- parsed_function,

- ic_data_array,

- zone);

+ new (zone) IRRegExpMacroAssembler(specialization_cid, data->capture_count,

+ parsed_function, ic_data_array, zone);

// Inserted here, instead of in Assembler, because it depends on information

// in the AST that isn't replicated in the Node structure.

static const intptr_t kMaxBacksearchLimit = 1024;

- if (is_end_anchored &&

- !is_start_anchored &&

+ if (is_end_anchored && !is_start_anchored &&

max_length < kMaxBacksearchLimit) {

macro_assembler->SetCurrentPositionFromEnd(max_length);

}

@@ -5117,10 +4913,7 @@ RegExpEngine::CompilationResult RegExpEngine::CompileIR(

}

RegExpEngine::CompilationResult result =

- compiler.Assemble(macro_assembler,

- node,

- data->capture_count,

- pattern);

+ compiler.Assemble(macro_assembler, node, data->capture_count, pattern);

if (FLAG_trace_irregexp) {

macro_assembler->PrintBlocks();

@@ -5156,10 +4949,8 @@ RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(

// I'm not sure the performance gains are relevant enough.

// Wrap the body of the regexp in capture #0.

- RegExpNode* captured_body = RegExpCapture::ToNode(data->tree,

- 0,

- &compiler,

- compiler.accept());

+ RegExpNode* captured_body =

+ RegExpCapture::ToNode(data->tree, 0, &compiler, compiler.accept());

RegExpNode* node = captured_body;

bool is_end_anchored = data->tree->IsAnchoredAtEnd();

@@ -5168,23 +4959,17 @@ RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(

if (!is_start_anchored) {

// Add a .*? at the beginning, outside the body capture, unless

// this expression is anchored at the beginning.

- RegExpNode* loop_node =

- RegExpQuantifier::ToNode(0,

- RegExpTree::kInfinity,

- false,

- new(zone) RegExpCharacterClass('*'),

- &compiler,

- captured_body,

- data->contains_anchor);

+ RegExpNode* loop_node = RegExpQuantifier::ToNode(

+ 0, RegExpTree::kInfinity, false, new (zone) RegExpCharacterClass('*'),

+ &compiler, captured_body, data->contains_anchor);

if (data->contains_anchor) {

// Unroll loop once, to take care of the case that might start

// at the start of input.

- ChoiceNode* first_step_node = new(zone) ChoiceNode(2, zone);

+ ChoiceNode* first_step_node = new (zone) ChoiceNode(2, zone);

first_step_node->AddAlternative(GuardedAlternative(captured_body));

- first_step_node->AddAlternative(GuardedAlternative(

- new(zone) TextNode(

- new(zone) RegExpCharacterClass('*'), loop_node)));

+ first_step_node->AddAlternative(GuardedAlternative(new (zone) TextNode(

+ new (zone) RegExpCharacterClass('*'), loop_node)));

node = first_step_node;

} else {

node = loop_node;

@@ -5199,7 +4984,7 @@ RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(

}

- if (node == NULL) node = new(zone) EndNode(EndNode::BACKTRACK, zone);

+ if (node == NULL) node = new (zone) EndNode(EndNode::BACKTRACK, zone);

data->node = node;

Analysis analysis(ignore_case, is_one_byte);

analysis.EnsureAnalyzed(node);

@@ -5212,13 +4997,12 @@ RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(

ZoneGrowableArray<uint8_t> buffer(zone, 1024);

BytecodeRegExpMacroAssembler* macro_assembler =

- new(zone) BytecodeRegExpMacroAssembler(&buffer, zone);

+ new (zone) BytecodeRegExpMacroAssembler(&buffer, zone);

// Inserted here, instead of in Assembler, because it depends on information

// in the AST that isn't replicated in the Node structure.

static const intptr_t kMaxBacksearchLimit = 1024;

- if (is_end_anchored &&

- !is_start_anchored &&

+ if (is_end_anchored && !is_start_anchored &&

max_length < kMaxBacksearchLimit) {

macro_assembler->SetCurrentPositionFromEnd(max_length);

}

@@ -5231,10 +5015,7 @@ RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(

}

RegExpEngine::CompilationResult result =

- compiler.Assemble(macro_assembler,

- node,

- data->capture_count,

- pattern);

+ compiler.Assemble(macro_assembler, node, data->capture_count, pattern);

if (FLAG_trace_irregexp) {

macro_assembler->PrintBlocks();

@@ -5244,29 +5025,29 @@ RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(

}

-static void CreateSpecializedFunction(Thread* thread, Zone* zone,

+static void CreateSpecializedFunction(Thread* thread,

+ Zone* zone,

const RegExp& regexp,

intptr_t specialization_cid,

const Object& owner) {

const intptr_t kParamCount = RegExpMacroAssembler::kParamCount;

- Function& fn = Function::Handle(zone, Function::New(

- Symbols::ColonMatcher(),

- RawFunction::kIrregexpFunction,

- true, // Static.

- false, // Not const.

- false, // Not abstract.

- false, // Not external.

- false, // Not native.

- owner,

- TokenPosition::kMinSource));

+ Function& fn =

+ Function::Handle(zone, Function::New(Symbols::ColonMatcher(),

+ RawFunction::kIrregexpFunction,

+ true, // Static.

+ false, // Not const.

+ false, // Not abstract.

+ false, // Not external.

+ false, // Not native.

+ owner, TokenPosition::kMinSource));

// TODO(zerny): Share these arrays between all irregexp functions.

fn.set_num_fixed_parameters(kParamCount);

- fn.set_parameter_types(Array::Handle(zone, Array::New(kParamCount,

- Heap::kOld)));

- fn.set_parameter_names(Array::Handle(zone, Array::New(kParamCount,

- Heap::kOld)));

+ fn.set_parameter_types(

+ Array::Handle(zone, Array::New(kParamCount, Heap::kOld)));

+ fn.set_parameter_names(

+ Array::Handle(zone, Array::New(kParamCount, Heap::kOld)));

fn.SetParameterTypeAt(RegExpMacroAssembler::kParamRegExpIndex,

Object::dynamic_type());

fn.SetParameterNameAt(RegExpMacroAssembler::kParamRegExpIndex,

@@ -5310,19 +5091,19 @@ RawRegExp* RegExpEngine::CreateRegExp(Thread* thread,

// TODO(zerny): We might want to use normal string searching algorithms

// for simple patterns.

regexp.set_is_complex();

- regexp.set_is_global(); // All dart regexps are global.

+ regexp.set_is_global(); // All dart regexps are global.

if (!FLAG_interpret_irregexp) {

const Library& lib = Library::Handle(zone, Library::CoreLibrary());

- const Class& owner = Class::Handle(zone,

- lib.LookupClass(Symbols::RegExp()));

+ const Class& owner =

+ Class::Handle(zone, lib.LookupClass(Symbols::RegExp()));

CreateSpecializedFunction(thread, zone, regexp, kOneByteStringCid, owner);

CreateSpecializedFunction(thread, zone, regexp, kTwoByteStringCid, owner);

- CreateSpecializedFunction(thread, zone,

- regexp, kExternalOneByteStringCid, owner);

- CreateSpecializedFunction(thread, zone,

- regexp, kExternalTwoByteStringCid, owner);

+ CreateSpecializedFunction(thread, zone, regexp, kExternalOneByteStringCid,

+ owner);

+ CreateSpecializedFunction(thread, zone, regexp, kExternalTwoByteStringCid,

+ owner);

}

return regexp.raw();

« no previous file with comments | « runtime/vm/regexp.h ('k') | runtime/vm/regexp_assembler.h » ('j') | no next file with comments »