clang-format runtime/vm

runtime/vm/regexp.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/regexp.h"
 
 #include "vm/dart_entry.h"
 #include "vm/regexp_assembler.h"
 #include "vm/regexp_assembler_bytecode.h"
 #include "vm/regexp_assembler_ir.h"
@@ skipping 252 matching lines @@
     ASSERT((in_character & RegExpMacroAssembler::kTableMask) == in_character);
     if (total_samples_ < 1) return 1;  // Division by zero.
     intptr_t freq_in_per128 =
         (frequencies_[in_character].counter() * 128) / total_samples_;
     return freq_in_per128;
   }
 
  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_; }
     intptr_t character() { return character_; }
 
    private:
     intptr_t counter_;
     intptr_t character_;
 
     DISALLOW_ALLOCATION();
   };
 
 
  private:
   CharacterFrequency frequencies_[RegExpMacroAssembler::kTableSize];
   intptr_t total_samples_;
 };
 
 
 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,
       RegExpNode* start,
       intptr_t capture_count,
       const String& pattern);
 
   inline void AddWork(RegExpNode* node) { work_list_->Add(node); }
 
   static const intptr_t kImplementationOffset = 0;
@@ skipping 37 matching lines @@
   Zone* zone_;
 };
 
 
 class RecursionCheck : public ValueObject {
  public:
   explicit RecursionCheck(RegExpCompiler* compiler) : compiler_(compiler) {
     compiler->IncrementRecursionDepth();
   }
   ~RecursionCheck() { compiler_->DecrementRecursionDepth(); }
+
  private:
   RegExpCompiler* compiler_;
 };
 
 
 static RegExpEngine::CompilationResult IrregexpRegExpTooBig() {
   return RegExpEngine::CompilationResult("RegExp too big");
 }
 
 
 // Attempts to compile the regexp using an Irregexp code generator.  Returns
 // a fixed array or a null handle depending on whether it succeeded.
 RegExpCompiler::RegExpCompiler(intptr_t capture_count,
                                bool ignore_case,
                                bool is_one_byte)
     : next_register_(2 * (capture_count + 1)),
       work_list_(NULL),
       recursion_depth_(0),
       ignore_case_(ignore_case),
       is_one_byte_(is_one_byte),
       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);
 }
 
 
 RegExpEngine::CompilationResult RegExpCompiler::Assemble(
     IRRegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
     intptr_t capture_count,
     const String& pattern) {
   macro_assembler->set_slow_safe(false /* use_slow_safe_regexp_compiler */);
   macro_assembler_ = macro_assembler;
 
   ZoneGrowableArray<RegExpNode*> work_list(0);
   work_list_ = &work_list;
   BlockLabel fail;
   macro_assembler_->PushBacktrack(&fail);
   Trace new_trace;
   start->Emit(this, &new_trace);
   macro_assembler_->BindBlock(&fail);
   macro_assembler_->Fail();
   while (!work_list.is_empty()) {
     work_list.RemoveLast()->Emit(this, &new_trace);
   }
   if (reg_exp_too_big_) return IrregexpRegExpTooBig();
 
   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_);
 }
 
 
 RegExpEngine::CompilationResult RegExpCompiler::Assemble(
     BytecodeRegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
     intptr_t capture_count,
     const String& pattern) {
   macro_assembler->set_slow_safe(false /* use_slow_safe_regexp_compiler */);
   macro_assembler_ = macro_assembler;
@@ skipping 20 matching lines @@
   if (action_type() == ActionNode::CLEAR_CAPTURES) {
     Interval range = static_cast<DeferredClearCaptures*>(this)->range();
     return range.Contains(that);
   } else {
     return reg() == 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;
 }
 
 
 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) {
         *cp_offset = static_cast<DeferredCapture*>(action)->cp_offset();
         return true;
       } else {
         return false;
       }
     }
   }
   return false;
 }
 
 
 // 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();
       for (intptr_t i = range.from(); i <= range.to(); i++)
         affected_registers->Set(i, zone);
       if (range.to() > max_register) max_register = range.to();
     } else {
       affected_registers->Set(action->reg(), zone);
       if (action->reg() > max_register) max_register = action->reg();
     }
@@ skipping 36 matching lines @@
     // to its previous state (or not, if it's safe to ignore it).
     enum DeferredActionUndoType { ACTION_IGNORE, ACTION_RESTORE, ACTION_CLEAR };
     DeferredActionUndoType undo_action = ACTION_IGNORE;
 
     intptr_t value = 0;
     bool absolute = false;
     bool clear = false;
     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()) {
           case ActionNode::SET_REGISTER: {
             Trace::DeferredSetRegister* psr =
                 static_cast<Trace::DeferredSetRegister*>(action);
             if (!absolute) {
               value += psr->value();
               absolute = true;
             }
@@ skipping 103 matching lines @@
   if (backtrack() != NULL) {
     // Here we have a concrete backtrack location.  These are set up by choice
     // nodes and so they indicate that we have a deferred save of the current
     // position which we may need to emit here.
     assembler->PushCurrentPosition();
   }
   Zone* zone = successor->zone();
   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_);
   }
 
   // Create a new trivial state and generate the node with that.
   BlockLabel undo;
   assembler->PushBacktrack(&undo);
   Trace new_state;
   successor->Emit(compiler, &new_state);
 
   // 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();
   } else {
     assembler->PopCurrentPosition();
     assembler->GoTo(backtrack());
   }
 }
 
 
@@ skipping 42 matching lines @@
       return;
     case NEGATIVE_SUBMATCH_SUCCESS:
       // This case is handled in a different virtual method.
       UNREACHABLE();
   }
   UNIMPLEMENTED();
 }
 
 
 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);
 }
 
 
 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;
 }
 
 
 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;
 }
 
 
 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;
 }
 
 
 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;
 }
 
 
 ActionNode* ActionNode::PositiveSubmatchSuccess(intptr_t stack_reg,
                                                 intptr_t position_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;
   result->data_.u_submatch.clear_register_from = clear_register_from;
   return result;
 }
 
 
 ActionNode* ActionNode::EmptyMatchCheck(intptr_t start_register,
                                         intptr_t repetition_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;
   return result;
 }
 
 
-#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
 
 
 void LoopChoiceNode::Accept(NodeVisitor* visitor) {
   visitor->VisitLoopChoice(this);
 }
 
 
 // -------------------------------------------------------------------
 // Emit code.
 
 
 void ChoiceNode::GenerateGuard(RegExpMacroAssembler* macro_assembler,
                                Guard* guard,
                                Trace* trace) {
   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;
   }
 }
 
 
 // Returns the number of characters in the equivalence class, omitting those
 // that cannot occur in the source string because it is ASCII.
 static intptr_t GetCaseIndependentLetters(uint16_t character,
                                           bool one_byte_subject,
@@ skipping 21 matching lines @@
 static inline bool EmitSimpleCharacter(Zone* zone,
                                        RegExpCompiler* compiler,
                                        uint16_t c,
                                        BlockLabel* on_failure,
                                        intptr_t cp_offset,
                                        bool check,
                                        bool preloaded) {
   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);
   return bound_checked;
 }
 
 
 // Only emits non-letters (things that don't have case).  Only used for case
 // independent matches.
 static inline bool EmitAtomNonLetter(Zone* zone,
@@ skipping 52 matching lines @@
     return true;
   }
   ASSERT(c2 > c1);
   uint16_t diff = c2 - c1;
   if (((diff - 1) & diff) == 0 && c1 >= diff) {
     // If the characters differ by 2^n but don't differ by one bit then
     // subtract the difference from the found character, then do the or
     // 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;
   }
   return false;
 }
 
 
 typedef bool EmitCharacterFunction(Zone* zone,
                                    RegExpCompiler* compiler,
                                    uint16_t c,
@@ skipping 18 matching lines @@
   if (length <= 1) return false;
   // We may not need to check against the end of the input string
   // if this character lies before a character that matched.
   if (!preloaded) {
     macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check);
   }
   BlockLabel ok;
   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);
         macro_assembler->BindBlock(&ok);
       }
       break;
     }
     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);
       macro_assembler->CheckNotCharacter(chars[2], on_failure);
       macro_assembler->BindBlock(&ok);
       break;
     default:
       UNREACHABLE();
       break;
   }
@@ skipping 33 matching lines @@
     } else {
       masm->CheckCharacterInRange(first, last, in_range);
     }
     if (out_of_range != fall_through) masm->GoTo(out_of_range);
   }
 }
 
 
 // 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;
 
   intptr_t base = (min_char & ~kMask);
 
   // Assert that everything is on one kTableSize page.
   for (intptr_t i = start_index; i <= end_index; i++) {
     ASSERT((ranges->At(i) & ~kMask) == base);
   }
   ASSERT(start_index == 0 || (ranges->At(start_index - 1) & ~kMask) <= base);
@@ skipping 21 matching lines @@
     for (j = (ranges->At(i) & kMask); j < (ranges->At(i + 1) & kMask); j++) {
       templ[j] = bit;
     }
     bit ^= 1;
   }
   for (intptr_t i = j; i < kSize; i++) {
     templ[i] = bit;
   }
   // 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]);
   }
   masm->CheckBitInTable(ba, on_bit_set);
   if (on_bit_clear != fall_through) masm->GoTo(on_bit_clear);
 }
 
 
 static void CutOutRange(RegExpMacroAssembler* masm,
                         ZoneGrowableArray<int>* ranges,
                         intptr_t start_index,
                         intptr_t end_index,
                         intptr_t cut_index,
                         BlockLabel* even_label,
                         BlockLabel* odd_label) {
   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
   // range that is a merger of the two ranges on either side of the one we
   // are cutting out.  The oddity of the labels is preserved.
   for (intptr_t j = cut_index; j > start_index; j--) {
     (*ranges)[j] = ranges->At(j - 1);
   }
   for (intptr_t j = cut_index + 1; j < end_index; j++) {
     (*ranges)[j] = ranges->At(j + 1);
@@ skipping 32 matching lines @@
   // 128-character space can take up a lot of space in the ranges array if,
   // for example, we only want to match every second character (eg. the lower
   // case characters on some Unicode pages).
   intptr_t binary_chop_index = (end_index + start_index) / 2;
   // The first test ensures that we get to the code that handles the Latin1
   // range with a single not-taken branch, speeding up this important
   // character range (even non-Latin1 charset-based text has spaces and
   // 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;
 
     while (scan_forward_for_section_border < end_index) {
       if (ranges->At(scan_forward_for_section_border) > new_border) {
         *new_start_index = scan_forward_for_section_border;
         *border = new_border;
         break;
       }
@@ skipping 37 matching lines @@
   // Just need to test if the character is before or on-or-after
   // a particular character.
   if (start_index == end_index) {
     EmitBoundaryTest(masm, first, fall_through, even_label, odd_label);
     return;
   }
 
   // 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;
   }
 
   // It's not worth using table lookup if there are very few intervals in the
   // character class.
   if (end_index - start_index <= 6) {
     // It is faster to test for individual characters, so we look for those
     // first, then try arbitrary ranges in the second round.
     static intptr_t kNoCutIndex = -1;
     intptr_t cut = kNoCutIndex;
     for (intptr_t i = start_index; i < end_index; i++) {
       if (ranges->At(i) == ranges->At(i + 1) - 1) {
         cut = i;
         break;
       }
     }
     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;
   }
 
   // If there are a lot of intervals in the regexp, then we will use tables to
   // determine whether the character is inside or outside the character class.
   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;
   }
 
   intptr_t new_start_index = 0;
   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;
   if (border == last + 1) {
     // We didn't find any section that started after the limit, so everything
     // above the border is one of the terminal labels.
     above = (end_index & 1) != (start_index & 1) ? odd_label : even_label;
     ASSERT(new_end_index == end_index - 1);
   }
 
   ASSERT(start_index <= new_end_index);
   ASSERT(new_start_index <= end_index);
   ASSERT(start_index < new_start_index);
   ASSERT(new_end_index < end_index);
   ASSERT(new_end_index + 1 == new_start_index ||
          (new_end_index + 2 == new_start_index &&
           border == ranges->At(new_end_index + 1)));
   ASSERT(min_char < border - 1);
   ASSERT(border < max_char);
   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);
   }
 }
 
 
 static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
                           RegExpCharacterClass* cc,
                           bool one_byte,
                           BlockLabel* on_failure,
                           intptr_t cp_offset,
@@ skipping 26 matching lines @@
   if (last_valid_range < 0) {
     if (!cc->is_negated()) {
       macro_assembler->GoTo(on_failure);
     }
     if (check_offset) {
       macro_assembler->CheckPosition(cp_offset, on_failure);
     }
     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 {
       // This is a common case hit by non-anchored expressions.
       if (check_offset) {
         macro_assembler->CheckPosition(cp_offset, on_failure);
       }
     }
     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) {
       macro_assembler->CheckPosition(cp_offset, on_failure);
     }
     return;
   }
 
   if (!preloaded) {
     macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check_offset);
   }
 
   if (cc->is_standard() &&
-        macro_assembler->CheckSpecialCharacterClass(cc->standard_type(),
-                                                    on_failure)) {
-      return;
+      macro_assembler->CheckSpecialCharacterClass(cc->standard_type(),
+                                                  on_failure)) {
+    return;
   }
 
 
   // A new list with ascending entries.  Each entry is a code unit
   // where there is a boundary between code units that are part of
   // the class and code units that are not.  Normally we insert an
   // entry at zero which goes to the failure label, but if there
   // 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();
 
   for (intptr_t i = 0; i <= last_valid_range; i++) {
     CharacterRange& range = (*ranges)[i];
     if (range.from() == 0) {
       ASSERT(i == 0);
       zeroth_entry_is_failure = !zeroth_entry_is_failure;
     } else {
       range_boundaries->Add(range.from());
     }
     range_boundaries->Add(range.to() + 1);
   }
   intptr_t end_index = range_boundaries->length() - 1;
   if (range_boundaries->At(end_index) > max_char) {
     end_index--;
   }
 
   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,
                                                   Trace* trace) {
   // If we are generating a greedy loop then don't stop and don't reuse code.
   if (trace->stop_node() != NULL) {
     return CONTINUE;
   }
 
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
@@ skipping 12 matching lines @@
       return DONE;
     }
     // Generate generic version of the node and bind the label for later use.
     macro_assembler->BindBlock(&label_);
     return CONTINUE;
   }
 
   // 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;
   }
 
   // If we get here code has been generated for this node too many times or
   // recursion is too deep.  Time to switch to a generic version.  The code for
   // generic versions above can handle deep recursion properly.
   trace->Flush(compiler, this);
   return DONE;
 }
 
 
 intptr_t ActionNode::EatsAtLeast(intptr_t still_to_find,
                                  intptr_t budget,
                                  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);
 }
 
 
 void ActionNode::FillInBMInfo(intptr_t offset,
                               intptr_t budget,
                               BoyerMooreLookahead* bm,
                               bool not_at_start) {
   if (action_type_ == BEGIN_SUBMATCH) {
     bm->SetRest(offset);
   } else if (action_type_ != POSITIVE_SUBMATCH_SUCCESS) {
     on_success()->FillInBMInfo(offset, budget - 1, bm, not_at_start);
   }
   SaveBMInfo(bm, not_at_start, offset);
 }
 
 
 intptr_t AssertionNode::EatsAtLeast(intptr_t still_to_find,
                                     intptr_t budget,
                                     bool not_at_start) {
   if (budget <= 0) return 0;
   // If we know we are not at the start and we are asked "how many characters
   // will you match if you succeed?" then we can answer anything since false
   // implies false.  So lets just return the max answer (still_to_find) since
   // 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);
 }
 
 
 void AssertionNode::FillInBMInfo(intptr_t offset,
                                  intptr_t budget,
                                  BoyerMooreLookahead* bm,
                                  bool not_at_start) {
   // Match the behaviour of EatsAtLeast on this node.
   if (assertion_type() == AT_START && not_at_start) return;
   on_success()->FillInBMInfo(offset, budget - 1, bm, not_at_start);
   SaveBMInfo(bm, not_at_start, offset);
 }
 
 
 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);
 }
 
 
 intptr_t TextNode::EatsAtLeast(intptr_t still_to_find,
                                intptr_t budget,
                                bool not_at_start) {
   intptr_t answer = Length();
   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);
 }
 
 
 intptr_t NegativeLookaheadChoiceNode::EatsAtLeast(intptr_t still_to_find,
                                                   intptr_t budget,
                                                   bool not_at_start) {
   if (budget <= 0) return 0;
   // Alternative 0 is the negative lookahead, alternative 1 is what comes
   // afterwards.
   RegExpNode* node = (*alternatives_)[1].node();
@@ skipping 29 matching lines @@
     if (node_eats_at_least < min) min = node_eats_at_least;
     if (min == 0) return 0;
   }
   return min;
 }
 
 
 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);
 }
 
 
 // Takes the left-most 1-bit and smears it out, setting all bits to its right.
 static inline uint32_t SmearBitsRight(uint32_t v) {
   v |= v >> 1;
   v |= v >> 2;
   v |= v >> 4;
   v |= v >> 8;
   v |= v >> 16;
@@ skipping 26 matching lines @@
 
 
 bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,
                                 Trace* bounds_check_trace,
                                 Trace* trace,
                                 bool preload_has_checked_bounds,
                                 BlockLabel* on_possible_success,
                                 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 ||
          compiler->macro_assembler()->CanReadUnaligned());
   uint32_t mask = details->mask();
   uint32_t value = details->value();
 
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
 
   if (trace->characters_preloaded() != details->characters()) {
     ASSERT(trace->cp_offset() == bounds_check_trace->cp_offset());
     // We are attempting to preload the minimum number of characters
     // 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());
   }
 
 
   bool need_mask = true;
 
   if (details->characters() == 1) {
     // If number of characters preloaded is 1 then we used a byte or 16 bit
     // load so the value is already masked down.
     uint32_t char_mask;
     if (compiler->one_byte()) {
@@ skipping 146 matching lines @@
         CharacterRange range = ranges->At(first_range);
         uint16_t from = range.from();
         uint16_t to = range.to();
         if (to > char_mask) {
           to = char_mask;
         }
         uint32_t differing_bits = (from ^ to);
         // 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);
         uint32_t bits = (from & common_bits);
         for (intptr_t i = first_range + 1; i < ranges->length(); i++) {
           CharacterRange range = ranges->At(i);
           uint16_t from = range.from();
           uint16_t to = range.to();
           if (from > char_mask) continue;
           if (to > char_mask) to = char_mask;
@@ skipping 16 matching lines @@
       }
       characters_filled_in++;
       ASSERT(characters_filled_in <= details->characters());
       if (characters_filled_in == details->characters()) {
         return;
       }
     }
   }
   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);
   }
 }
 
 
 void QuickCheckDetails::Clear() {
   for (int i = 0; i < characters_; i++) {
     positions_[i].mask = 0;
     positions_[i].value = 0;
     positions_[i].determines_perfectly = false;
   }
@@ skipping 27 matching lines @@
   if (other->cannot_match_) {
     return;
   }
   if (cannot_match_) {
     *this = *other;
     return;
   }
   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.
       pos->determines_perfectly = false;
     }
     pos->mask &= other_pos->mask;
     pos->value &= pos->mask;
     other_pos->value &= pos->mask;
     uint16_t differing_bits = (pos->value ^ other_pos->value);
     pos->mask &= ~differing_bits;
     pos->value &= pos->mask;
   }
 }
 
 
 class VisitMarker : public ValueObject {
  public:
   explicit VisitMarker(NodeInfo* info) : info_(info) {
     ASSERT(!info->visited);
     info->visited = true;
   }
-  ~VisitMarker() {
-    info_->visited = false;
-  }
+  ~VisitMarker() { info_->visited = false; }
+
  private:
   NodeInfo* info_;
 };
 
 
 RegExpNode* SeqRegExpNode::FilterOneByte(intptr_t depth, bool ignore_case) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   ASSERT(!info()->visited);
   VisitMarker marker(info());
   return FilterSuccessor(depth - 1, ignore_case);
 }
 
 
 RegExpNode* SeqRegExpNode::FilterSuccessor(intptr_t depth, bool ignore_case) {
   RegExpNode* next = on_success_->FilterOneByte(depth - 1, ignore_case);
   if (next == NULL) return set_replacement(NULL);
   on_success_ = next;
   return set_replacement(this);
 }
 
 
 // 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);
 }
 
 
 static bool RangesContainLatin1Equivalents(
     ZoneGrowableArray<CharacterRange>* ranges) {
   for (intptr_t i = 0; i < ranges->length(); i++) {
     // TODO(dcarney): this could be a lot more efficient.
     if (RangeContainsLatin1Equivalents(ranges->At(i))) return true;
   }
   return false;
@@ skipping 41 matching lines @@
     } else {
       ASSERT(elm.text_type() == TextElement::CHAR_CLASS);
       RegExpCharacterClass* cc = elm.char_class();
       ZoneGrowableArray<CharacterRange>* ranges = cc->ranges();
       if (!CharacterRange::IsCanonical(ranges)) {
         CharacterRange::Canonicalize(ranges);
       }
       // 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;
           return set_replacement(NULL);
         }
       } else {
         if (range_count == 0 ||
             ranges->At(0).from() > Symbols::kMaxOneCharCodeSymbol) {
           // This will be handled in a later filter.
           if (ignore_case && RangesContainLatin1Equivalents(ranges)) continue;
@@ skipping 54 matching lines @@
   }
   if (surviving < 2) return set_replacement(survivor);
 
   set_replacement(this);
   if (surviving == choice_count) {
     return this;
   }
   // 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);
     if (replacement != NULL) {
       (*alternatives_)[i].set_node(replacement);
       new_alternatives->Add((*alternatives_)[i]);
     }
   }
   alternatives_ = new_alternatives;
   return this;
@@ skipping 22 matching lines @@
   return set_replacement(this);
 }
 
 
 void LoopChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,
                                           RegExpCompiler* compiler,
                                           intptr_t characters_filled_in,
                                           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);
 }
 
 
 void LoopChoiceNode::FillInBMInfo(intptr_t offset,
                                   intptr_t budget,
                                   BoyerMooreLookahead* bm,
                                   bool not_at_start) {
   if (body_can_be_zero_length_ || budget <= 0) {
     bm->SetRest(offset);
     SaveBMInfo(bm, not_at_start, offset);
     return;
   }
   ChoiceNode::FillInBMInfo(offset, budget - 1, bm, not_at_start);
   SaveBMInfo(bm, not_at_start, offset);
 }
 
 
 void ChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,
                                       RegExpCompiler* compiler,
                                       intptr_t characters_filled_in,
                                       bool not_at_start) {
   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);
   }
 }
 
 
 // Check for [0-9A-Z_a-z].
 static void EmitWordCheck(RegExpMacroAssembler* assembler,
                           BlockLabel* word,
@@ skipping 31 matching lines @@
   new_trace.InvalidateCurrentCharacter();
 
   BlockLabel ok;
   if (new_trace.cp_offset() == 0) {
     // The start of input counts as a newline in this context, so skip to
     // ok if we are at the start.
     assembler->CheckAtStart(&ok);
   }
   // 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);
     }
     assembler->CheckCharacter('\n', &ok);
     assembler->CheckNotCharacter('\r', new_trace.backtrack());
   }
   assembler->BindBlock(&ok);
   on_success->Emit(compiler, &new_trace);
 }
 
 
 // Emit the code to handle \b and \B (word-boundary or non-word-boundary).
 void AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, Trace* trace) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
   Trace::TriBool next_is_word_character = Trace::UNKNOWN;
   bool not_at_start = (trace->at_start() == Trace::FALSE_VALUE);
   BoyerMooreLookahead* lookahead = bm_info(not_at_start);
   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) {
     BlockLabel before_non_word;
     BlockLabel before_word;
     if (trace->characters_preloaded() != 1) {
       assembler->LoadCurrentCharacter(trace->cp_offset(), &before_non_word);
     }
     // Fall through on non-word.
     EmitWordCheck(assembler, &before_word, &before_non_word, false);
@@ skipping 23 matching lines @@
 void AssertionNode::BacktrackIfPrevious(
     RegExpCompiler* compiler,
     Trace* trace,
     AssertionNode::IfPrevious backtrack_if_previous) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
   Trace new_trace(*trace);
   new_trace.InvalidateCurrentCharacter();
 
   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
     // decided if we are at the start.
     assembler->CheckAtStart(non_word);
   }
   // 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, &dummy, false);
   EmitWordCheck(assembler, word, non_word, backtrack_if_previous == kIsNonWord);
 
   assembler->BindBlock(&fall_through);
   on_success()->Emit(compiler, &new_trace);
 }
 
 
 void AssertionNode::GetQuickCheckDetails(QuickCheckDetails* details,
                                          RegExpCompiler* compiler,
                                          intptr_t filled_in,
                                          bool not_at_start) {
   if (assertion_type_ == AT_START && not_at_start) {
     details->set_cannot_match();
     return;
   }
-  return on_success()->GetQuickCheckDetails(details,
-                                            compiler,
-                                            filled_in,
+  return on_success()->GetQuickCheckDetails(details, compiler, filled_in,
                                             not_at_start);
 }
 
 
 void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
   switch (assertion_type_) {
     case AT_END: {
       BlockLabel ok;
       assembler->CheckPosition(trace->cp_offset(), &ok);
       assembler->GoTo(trace->backtrack());
       assembler->BindBlock(&ok);
       break;
     }
     case AT_START: {
       if (trace->at_start() == Trace::FALSE_VALUE) {
         assembler->GoTo(trace->backtrack());
         return;
       }
       if (trace->at_start() == Trace::UNKNOWN) {
         assembler->CheckNotAtStart(trace->backtrack());
         Trace at_start_trace = *trace;
         at_start_trace.set_at_start(true);
         on_success()->Emit(compiler, &at_start_trace);
         return;
       }
-    }
-    break;
+    } break;
     case AFTER_NEWLINE:
       EmitHat(compiler, on_success(), trace);
       return;
     case AT_BOUNDARY:
     case AT_NON_BOUNDARY: {
       EmitBoundaryCheck(compiler, trace);
       return;
     }
   }
   on_success()->Emit(compiler, trace);
@@ skipping 77 matching lines @@
           case SIMPLE_CHARACTER_MATCH:
             emit_function = &EmitSimpleCharacter;
             break;
           case CASE_CHARACTER_MATCH:
             emit_function = &EmitAtomLetter;
             break;
           default:
             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);
         }
       }
     } else {
       ASSERT(elm.text_type() == TextElement::CHAR_CLASS);
       if (pass == CHARACTER_CLASS_MATCH) {
         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);
       }
     }
   }
 }
 
 
 intptr_t TextNode::Length() {
   TextElement elm = elms_->Last();
   ASSERT(elm.cp_offset() >= 0);
@@ skipping 34 matching lines @@
 
   bool first_elt_done = false;
   intptr_t bound_checked_to = trace->cp_offset() - 1;
   bound_checked_to += trace->bound_checked_up_to();
 
   // If a character is preloaded into the current character register then
   // check that now.
   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;
   }
 
   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);
     }
   }
 
   Trace successor_trace(*trace);
   successor_trace.set_at_start(false);
   successor_trace.AdvanceCurrentPositionInTrace(Length(), compiler);
   RecursionCheck rc(compiler);
   on_success()->Emit(compiler, &successor_trace);
 }
 
@@ skipping 12 matching lines @@
   characters_preloaded_ = 0;
   // Adjust the offsets of the quick check performed information.  This
   // information is used to find out what we already determined about the
   // characters by means of mask and compare.
   quick_check_performed_.Advance(by, compiler->one_byte());
   cp_offset_ += by;
   if (cp_offset_ > RegExpMacroAssembler::kMaxCPOffset) {
     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);
 }
 
 
 void TextNode::MakeCaseIndependent(bool is_one_byte) {
   intptr_t element_count = elms_->length();
   for (intptr_t i = 0; i < element_count; i++) {
     TextElement elm = elms_->At(i);
     if (elm.text_type() == TextElement::CHAR_CLASS) {
       RegExpCharacterClass* cc = elm.char_class();
       // None of the standard character classes is different in the case
@@ skipping 98 matching lines @@
   if (!trace->is_trivial()) {
     trace->Flush(compiler, this);
     return;
   }
   ChoiceNode::Emit(compiler, 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) {
       if (preload_characters > 4) preload_characters = 4;
       // We can't preload 3 characters because there is no machine instruction
       // to do that.  We can't just load 4 because we could be reading
       // beyond the end of the string, which could cause a memory fault.
       if (preload_characters == 3) preload_characters = 2;
     } else {
       if (preload_characters > 2) preload_characters = 2;
     }
   } else {
     if (preload_characters > 1) preload_characters = 1;
   }
   return preload_characters;
 }
 
 
 // This structure is used when generating the alternatives in a choice node.  It
 // records the way the alternative is being code generated.
 struct AlternativeGeneration {
   AlternativeGeneration()
       : possible_success(),
         expects_preload(false),
         after(),
-        quick_check_details() { }
+        quick_check_details() {}
   BlockLabel possible_success;
   bool expects_preload;
   BlockLabel after;
   QuickCheckDetails quick_check_details;
 };
 
 
 // Creates a list of AlternativeGenerations.  If the list has a reasonable
 // 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);
     }
     for (intptr_t i = kAFew; i < count; i++) {
       alt_gens_.Add(new AlternativeGeneration());
     }
   }
   ~AlternativeGenerationList() {
     for (intptr_t i = kAFew; i < alt_gens_.length(); i++) {
       delete alt_gens_[i];
       alt_gens_[i] = NULL;
     }
   }
 
-  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;
   GrowableArray<AlternativeGeneration*> alt_gens_;
   AlternativeGeneration a_few_alt_gens_[kAFew];
 
   DISALLOW_ALLOCATION();
 };
 
 
 // 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);
 
 
 void BoyerMoorePositionInfo::Set(intptr_t character) {
   SetInterval(Interval(character, character));
 }
 
 
 void BoyerMoorePositionInfo::SetInterval(const Interval& interval) {
   s_ = AddRange(s_, kSpaceRanges, kSpaceRangeCount, interval);
   w_ = AddRange(w_, kWordRanges, kWordRangeCount, interval);
   d_ = AddRange(d_, kDigitRanges, kDigitRangeCount, interval);
   surrogate_ =
       AddRange(surrogate_, kSurrogateRanges, kSurrogateRangeCount, 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;
   }
   for (intptr_t i = interval.from(); i <= interval.to(); i++) {
     intptr_t mod_character = (i & kMask);
     if (!map_->At(mod_character)) {
       map_count_++;
       (*map_)[mod_character] = true;
     }
     if (map_count_ == kMapSize) return;
   }
 }
 
 
 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));
   }
 }
 
 
 // Find the longest range of lookahead that has the fewest number of different
 // characters that can occur at a given position.  Since we are optimizing two
 // different parameters at once this is a tradeoff.
 bool BoyerMooreLookahead::FindWorthwhileInterval(intptr_t* from, intptr_t* to) {
   intptr_t biggest_points = 0;
   // 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);
   }
   if (biggest_points == 0) return false;
   return true;
 }
 
 
 // Find the highest-points range between 0 and length_ where the character
 // information is not too vague.  'Too vague' means that there are more than
 // max_number_of_chars that can occur at this position.  Calculates the number
 // 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;
     for (intptr_t j = 0; j < kSize; j++) {
       if (union_map[j]) {
         // Add 1 to the frequency to give a small per-character boost for
         // the cases where our sampling is not good enough and many
         // characters have a frequency of zero.  This means the frequency
         // can theoretically be up to 2*kSize though we treat it mostly as
         // a fraction of kSize.
         frequency += compiler_->frequency_collator()->Frequency(j) + 1;
       }
     }
     // We use the probability of skipping times the distance we are skipping to
     // judge the effectiveness of this.  Actually we have a cut-off:  By
     // 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 =
         (in_quickcheck_range ? kSize / 2 : kSize) - frequency;
     intptr_t points = (i - remembered_from) * probability;
     if (points > biggest_points) {
       *from = remembered_from;
       *to = i - 1;
       biggest_points = points;
     }
@@ skipping 67 matching lines @@
     // The mask-compare can probably handle this better.
     return;
   }
 
   if (found_single_character) {
     BlockLabel cont, again;
     masm->BindBlock(&again);
     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);
     }
     masm->AdvanceCurrentPosition(lookahead_width);
     masm->GoTo(&again);
     masm->BindBlock(&cont);
     return;
   }
 
   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;
 
   masm->BindBlock(&again);
   masm->LoadCurrentCharacter(max_lookahead, &cont, true);
   masm->CheckBitInTable(boolean_skip_table, &cont);
   masm->AdvanceCurrentPosition(skip_distance);
   masm->GoTo(&again);
   masm->BindBlock(&cont);
@@ skipping 93 matching lines @@
       ASSERT(!trace->mentions_reg(guards->At(j)->reg()));
     }
   }
 #endif
 }
 
 
 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_;
 }
 
 
 void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   intptr_t choice_count = alternatives_->length();
 
   AssertGuardsMentionRegisters(trace);
 
   LimitResult limit_result = LimitVersions(compiler, trace);
   if (limit_result == DONE) return;
@@ skipping 10 matching lines @@
 
   PreloadState preload;
   preload.init();
   GreedyLoopState greedy_loop_state(not_at_start());
 
   intptr_t text_length =
       GreedyLoopTextLengthForAlternative(&((*alternatives_)[0]));
   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.
     BlockLabel second_choice;
     compiler->macro_assembler()->BindBlock(&second_choice);
 
     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
   // the quick check was inlined.  We can recognize these because the associated
   // label was bound.
   intptr_t new_flush_budget = trace->flush_budget() / choice_count;
   for (intptr_t i = 0; i < choice_count; i++) {
     AlternativeGeneration* alt_gen = alt_gens.at(i);
     Trace new_trace(*trace);
     // If there are actions to be flushed we have to limit how many times
     // they are flushed.  Take the budget of the parent trace and distribute
     // it fairly amongst the children.
     if (new_trace.actions() != NULL) {
       new_trace.set_flush_budget(new_flush_budget);
     }
     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);
   }
 }
 
 Trace* ChoiceNode::EmitGreedyLoop(RegExpCompiler* compiler,
                                   Trace* trace,
                                   AlternativeGenerationList* alt_gens,
                                   PreloadState* preload,
                                   GreedyLoopState* greedy_loop_state,
                                   intptr_t text_length) {
@@ skipping 16 matching lines @@
   greedy_match_trace.set_stop_node(this);
   greedy_match_trace.set_loop_label(&loop_label);
   (*alternatives_)[0].node()->Emit(compiler, &greedy_match_trace);
   macro_assembler->BindBlock(&greedy_match_failed);
 
   BlockLabel second_choice;  // For use in greedy matches.
   macro_assembler->BindBlock(&second_choice);
 
   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.
   macro_assembler->CheckGreedyLoop(trace->backtrack());
   // Otherwise try the second priority at an earlier position.
   macro_assembler->AdvanceCurrentPosition(-text_length);
   macro_assembler->GoTo(&second_choice);
   return new_trace;
 }
 
@@ skipping 23 matching lines @@
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   // At this point we know that we are at a non-greedy loop that will eat
   // any character one at a time.  Any non-anchored regexp has such a
   // loop prepended to it in order to find where it starts.  We look for
   // a pattern of the form ...abc... where we can look 6 characters ahead
   // and step forwards 3 if the character is not one of abc.  Abc need
   // not be atoms, they can be any reasonably limited character class or
   // 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);
     }
   }
   if (bm != NULL) {
     bm->EmitSkipInstructions(macro_assembler);
   }
   return eats_at_least;
 }
 
@@ skipping 14 matching lines @@
 
   for (intptr_t i = first_choice; i < choice_count; i++) {
     bool is_last = i == choice_count - 1;
     bool fall_through_on_failure = !is_last;
     GuardedAlternative alternative = alternatives_->At(i);
     AlternativeGeneration* alt_gen = alt_gens->at(i);
     alt_gen->quick_check_details.set_characters(preload->preload_characters_);
     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_);
     }
     new_trace.quick_check_performed()->Clear();
     if (not_at_start_) new_trace.set_at_start(Trace::FALSE_VALUE);
     if (!is_last) {
       new_trace.set_backtrack(&alt_gen->after);
     }
     alt_gen->expects_preload = preload->preload_is_current_;
     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;
       // If we generated the quick check to fall through on possible success,
       // we now need to generate the full check inline.
       if (!fall_through_on_failure) {
         macro_assembler->BindBlock(&alt_gen->possible_success);
         new_trace.set_quick_check_performed(&alt_gen->quick_check_details);
         new_trace.set_characters_preloaded(preload->preload_characters_);
         new_trace.set_bound_checked_up_to(preload->preload_characters_);
@@ skipping 51 matching lines @@
     BlockLabel reload_current_char;
     out_of_line_trace.set_backtrack(&reload_current_char);
     for (intptr_t j = 0; j < guard_count; j++) {
       GenerateGuard(macro_assembler, guards->At(j), &out_of_line_trace);
     }
     alternative.node()->Emit(compiler, &out_of_line_trace);
     macro_assembler->BindBlock(&reload_current_char);
     // 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 {
     out_of_line_trace.set_backtrack(&(alt_gen->after));
     for (intptr_t j = 0; j < guard_count; j++) {
       GenerateGuard(macro_assembler, guards->At(j), &out_of_line_trace);
     }
     alternative.node()->Emit(compiler, &out_of_line_trace);
   }
 }
 
 
 void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
   RegExpMacroAssembler* assembler = compiler->macro_assembler();
   LimitResult limit_result = LimitVersions(compiler, trace);
   if (limit_result == DONE) return;
   ASSERT(limit_result == CONTINUE);
 
   RecursionCheck rc(compiler);
 
   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);
       break;
     }
     case BEGIN_SUBMATCH:
       if (!trace->is_trivial()) {
         trace->Flush(compiler, this);
       } else {
         assembler->WriteCurrentPositionToRegister(
@@ skipping 79 matching lines @@
   }
 
   LimitResult limit_result = LimitVersions(compiler, trace);
   if (limit_result == DONE) return;
   ASSERT(limit_result == CONTINUE);
 
   RecursionCheck rc(compiler);
 
   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());
   }
   on_success()->Emit(compiler, trace);
 }
 
 
 // -------------------------------------------------------------------
 // Dot/dotty output
 
 
 #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
 };
 
 
 void DotPrinter::PrintNode(const char* label, RegExpNode* node) {
   OS::Print("digraph G {\n  graph [label=\"");
   for (intptr_t i = 0; label[i]; i++) {
     switch (label[i]) {
       case '\\':
         OS::Print("\\\\");
@@ skipping 45 matching lines @@
     PrintSeparator();
     OS::Print("{%s|%" Pd "}", name, value);
   }
 
  private:
   bool first_;
 };
 
 
 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);
 }
 
 
 void DotPrinter::VisitChoice(ChoiceNode* that) {
   OS::Print("  n%p [shape=Mrecord, label=\"?\"];\n", that);
   for (intptr_t i = 0; i < that->alternatives()->length(); i++) {
     GuardedAlternative alt = that->alternatives()->At(i);
     OS::Print("  n%p -> n%p", that, alt.node());
   }
   for (intptr_t i = 0; i < that->alternatives()->length(); i++) {
@@ skipping 139 matching lines @@
 
 // -------------------------------------------------------------------
 // Tree to graph conversion
 
 // The zone in which we allocate graph nodes.
 #define OZ (on_success->zone())
 
 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);
 }
 
 
 static bool CompareInverseRanges(ZoneGrowableArray<CharacterRange>* ranges,
                                  const intptr_t* special_class,
                                  intptr_t length) {
   length--;  // Remove final 0x10000.
   ASSERT(special_class[length] == 0x10000);
   ASSERT(ranges->length() != 0);
   ASSERT(length != 0);
   ASSERT(special_class[0] != 0);
   if (ranges->length() != (length >> 1) + 1) {
     return false;
   }
   CharacterRange range = ranges->At(0);
   if (range.from() != 0) {
     return false;
   }
   for (intptr_t i = 0; i < length; i += 2) {
     if (special_class[i] != (range.to() + 1)) {
       return false;
     }
     range = ranges->At((i >> 1) + 1);
-    if (special_class[i+1] != range.from()) {
+    if (special_class[i + 1] != range.from()) {
       return false;
     }
   }
   if (range.to() != 0xffff) {
     return false;
   }
   return true;
 }
 
 
@@ skipping 26 matching lines @@
     return true;
   }
   if (CompareRanges(set_.ranges(), kSpaceRanges, kSpaceRangeCount)) {
     set_.set_standard_set_type('s');
     return true;
   }
   if (CompareInverseRanges(set_.ranges(), kSpaceRanges, kSpaceRangeCount)) {
     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;
   }
   if (CompareRanges(set_.ranges(), kWordRanges, kWordRangeCount)) {
     set_.set_standard_set_type('w');
     return true;
   }
   if (CompareInverseRanges(set_.ranges(), kWordRanges, kWordRangeCount)) {
     set_.set_standard_set_type('W');
     return true;
   }
   return false;
 }
 
 
 RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,
                                          RegExpNode* on_success) {
-  return new(OZ) TextNode(this, on_success);
+  return new (OZ) TextNode(this, on_success);
 }
 
 
 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;
 }
 
 
 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);
 }
 
 
 // Scoped object to keep track of how much we unroll quantifier loops in the
 // regexp graph generator.
 class RegExpExpansionLimiter : public ValueObject {
  public:
   static const intptr_t kMaxExpansionFactor = 6;
   RegExpExpansionLimiter(RegExpCompiler* compiler, intptr_t factor)
       : compiler_(compiler),
@@ skipping 65 matching lines @@
   Interval capture_registers = body->CaptureRegisters();
   bool needs_capture_clearing = !capture_registers.is_empty();
   Zone* zone = compiler->zone();
 
   if (body_can_be_empty) {
     body_start_reg = compiler->AllocateRegister();
   } else if (kRegexpOptimization && !needs_capture_clearing) {
     // 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.
         for (intptr_t i = 0; i < min; i++) {
           answer = body->ToNode(compiler, answer);
         }
         return answer;
       }
     }
     if (max <= kMaxUnrolledMaxMatches && min == 0) {
       ASSERT(max > 0);  // Due to the 'if' above.
       RegExpExpansionLimiter limiter(compiler, max);
       if (limiter.ok_to_expand()) {
         // 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)));
             alternation->AddAlternative(GuardedAlternative(on_success));
           } else {
             alternation->AddAlternative(GuardedAlternative(on_success));
             alternation->AddAlternative(
                 GuardedAlternative(body->ToNode(compiler, answer)));
           }
           answer = alternation;
           if (not_at_start) alternation->set_not_at_start();
         }
         return answer;
       }
     }
   }
   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) {
     // If the body can be empty we need to store the start position
     // so we can bail out if it was empty.
     body_node = ActionNode::StorePosition(body_start_reg, false, body_node);
   }
   if (needs_capture_clearing) {
     // Before entering the body of this loop we need to clear captures.
     body_node = ActionNode::ClearCaptures(capture_registers, body_node);
   }
   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) {
     center->AddLoopAlternative(body_alt);
     center->AddContinueAlternative(rest_alt);
   } else {
     center->AddContinueAlternative(rest_alt);
     center->AddLoopAlternative(body_alt);
   }
   if (needs_counter) {
@@ skipping 24 matching lines @@
       intptr_t stack_pointer_register = compiler->AllocateRegister();
       intptr_t position_register = compiler->AllocateRegister();
       // The ChoiceNode to distinguish between a newline and end-of-input.
       ChoiceNode* result = new ChoiceNode(2, on_success->zone());
       // Create a newline atom.
       ZoneGrowableArray<CharacterRange>* newline_ranges =
           new ZoneGrowableArray<CharacterRange>(3);
       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);
       GuardedAlternative end_alternative(AssertionNode::AtEnd(on_success));
       result->AddAlternative(end_alternative);
       return result;
     }
     default:
       UNREACHABLE();
   }
   return on_success;
 }
 
 
 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);
 }
 
 
 RegExpNode* RegExpEmpty::ToNode(RegExpCompiler* compiler,
                                 RegExpNode* on_success) {
   return on_success;
 }
 
 
 RegExpNode* RegExpLookahead::ToNode(RegExpCompiler* compiler,
                                     RegExpNode* on_success) {
   intptr_t stack_pointer_register = compiler->AllocateRegister();
   intptr_t position_register = compiler->AllocateRegister();
 
   const intptr_t registers_per_capture = 2;
   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
     // the characteristics we need.  It has the body of the lookahead as its
     // first alternative and the expression after the lookahead of the second
     // alternative.  If the first alternative succeeds then the
     // NegativeSubmatchSuccess will unwind the stack including everything the
     // choice node set up and backtrack.  If the first alternative fails then
     // the second alternative is tried, which is exactly the desired result
     // for a negative lookahead.  The NegativeLookaheadChoiceNode is a special
     // ChoiceNode that knows to ignore the first exit when calculating quick
     // 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);
   }
 }
 
 
 RegExpNode* RegExpCapture::ToNode(RegExpCompiler* compiler,
                                   RegExpNode* on_success) {
   return ToNode(body(), index(), compiler, on_success);
 }
 
@@ skipping 26 matching lines @@
                      ZoneGrowableArray<CharacterRange>* ranges) {
   elmc--;
   ASSERT(elmv[elmc] == 0x10000);
   for (intptr_t i = 0; i < elmc; i += 2) {
     ASSERT(elmv[i] < elmv[i + 1]);
     ranges->Add(CharacterRange(elmv[i], elmv[i + 1] - 1));
   }
 }
 
 
-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);
     ASSERT(elmv[i] < elmv[i + 1]);
     ranges->Add(CharacterRange(last, elmv[i] - 1));
     last = elmv[i + 1];
   }
   ranges->Add(CharacterRange(last, Utf16::kMaxCodeUnit));
 }
 
@@ skipping 13 matching lines @@
     case 'W':
       AddClassNegated(kWordRanges, kWordRangeCount, ranges);
       break;
     case 'd':
       AddClass(kDigitRanges, kDigitRangeCount, ranges);
       break;
     case 'D':
       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
     // character.
     case '*':
       ranges->Add(CharacterRange::Everything());
       break;
     // 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();
   }
 }
 
 
 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)) {
     if (bottom > Symbols::kMaxOneCharCodeSymbol) return;
     if (top > Symbols::kMaxOneCharCodeSymbol) {
       top = Symbols::kMaxOneCharCodeSymbol;
     }
   }
 
   unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize;
   unibrow::Mapping<unibrow::CanonicalizationRange> jsregexp_canonrange;
   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) {
         ranges->Add(CharacterRange::Singleton(chars[i]));
       }
     }
   } else {
     // If this is a range we expand the characters block by block,
     // expanding contiguous subranges (blocks) one at a time.
     // The approach is as follows.  For a given start character we
@@ skipping 17 matching lines @@
     while (pos <= top) {
       intptr_t length = jsregexp_canonrange.get(pos, '\0', range);
       uint16_t block_end;
       if (length == 0) {
         block_end = pos;
       } else {
         ASSERT(length == 1);
         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);
         uint16_t range_to = c - (block_end - end);
         if (!(bottom <= range_from && range_to <= top)) {
           ranges->Add(CharacterRange(range_from, range_to));
         }
       }
       pos = end + 1;
     }
@@ skipping 37 matching lines @@
     }
   } else {
     for (intptr_t i = 0; i < count; i++) {
       (*list)[to + i] = list->At(from + i);
     }
   }
 }
 
 
 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
   // canonicalized ranges. Inserting a range may collapse existing ranges into
   // fewer ranges, so the return value can be anything in the range 1..count+1.
   uint16_t from = insert.from();
   uint16_t to = insert.to();
   intptr_t start_pos = 0;
   intptr_t end_pos = count;
   for (intptr_t i = count - 1; i >= 0; i--) {
@@ skipping 67 matching lines @@
     i++;
   }
   // Canonical until the i'th range. If that's all of them, we are done.
   if (i == n) return;
 
   // The ranges at index i and forward are not canonicalized. Make them so by
   // doing the equivalent of insertion sort (inserting each into the previous
   // 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);
   character_ranges->TruncateTo(num_canonical);
 
   ASSERT(CharacterRange::IsCanonical(character_ranges));
 }
 
 
 void CharacterRange::Negate(ZoneGrowableArray<CharacterRange>* ranges,
@@ skipping 17 matching lines @@
     negated_ranges->Add(CharacterRange(from + 1, Utf16::kMaxCodeUnit));
   }
 }
 
 
 // -------------------------------------------------------------------
 // Splay tree
 
 
 // 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;
     }
   }
   return false;
 }
 
 
 void OutSet::Set(unsigned value, Zone* zone) {
   if (value < kFirstLimit) {
     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) {
       remaining_->Add(value);
     }
   }
 }
 
 
 bool OutSet::Get(unsigned value) const {
   if (value < kFirstLimit) {
     return (first_ & (1 << value)) != 0;
   } else if (remaining_ == NULL) {
     return false;
   } else {
     return ArrayContains(remaining_, value);
   }
 }
 
 
 // -------------------------------------------------------------------
 // Analysis
 
 
 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;
   that->info()->been_analyzed = true;
 }
 
 
 void Analysis::VisitEnd(EndNode* that) {
   // nothing to do
 }
@@ skipping 127 matching lines @@
       RegExpAtom* atom = text.atom();
       for (intptr_t j = 0; j < atom->length(); j++, offset++) {
         if (offset >= bm->length()) {
           if (initial_offset == 0) set_bm_info(not_at_start, bm);
           return;
         }
         uint16_t character = atom->data()->At(j);
         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]);
           }
         } else {
           if (character <= max_char) bm->Set(offset, character);
         }
       }
     } else {
       ASSERT(text.text_type() == TextElement::CHAR_CLASS);
       RegExpCharacterClass* char_class = text.char_class();
       ZoneGrowableArray<CharacterRange>* ranges = char_class->ranges();
       if (char_class->is_negated()) {
         bm->SetAll(offset);
       } else {
         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));
         }
       }
       offset++;
     }
   }
   if (offset >= bm->length()) {
     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);
 }
 
 
 RegExpEngine::CompilationResult RegExpEngine::CompileIR(
     RegExpCompileData* data,
     const ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array) {
   ASSERT(!FLAG_interpret_irregexp);
@@ skipping 17 matching lines @@
   // TODO(zerny): Frequency sampling is currently disabled because of several
   // issues. We do not want to store subject strings in the regexp object since
   // they might be long and we should not prevent their garbage collection.
   // Passing them to this function explicitly does not help, since we must
   // generate exactly the same IR for both the unoptimizing and optimizing
   // pipelines (otherwise it gets confused when i.e. deopt id's differ).
   // An option would be to store sampling results in the regexp object, but
   // 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();
   bool is_start_anchored = data->tree->IsAnchoredAtStart();
   intptr_t max_length = data->tree->max_match();
   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;
     }
   }
   if (is_one_byte) {
     node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     // Do it again to propagate the new nodes to places where they were not
     // put because they had not been calculated yet.
     if (node != NULL) {
       node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     }
   }
 
-  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);
   if (analysis.has_failed()) {
     const char* error_message = analysis.error_message();
     return CompilationResult(error_message);
   }
 
   // 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);
   }
 
   if (is_global) {
     macro_assembler->set_global_mode(
         (data->tree->min_match() > 0)
             ? RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK
             : RegExpMacroAssembler::GLOBAL);
   }
 
   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();
   }
 
   return result;
 }
 
 
 RegExpEngine::CompilationResult RegExpEngine::CompileBytecode(
@@ skipping 15 matching lines @@
   // TODO(zerny): Frequency sampling is currently disabled because of several
   // issues. We do not want to store subject strings in the regexp object since
   // they might be long and we should not prevent their garbage collection.
   // Passing them to this function explicitly does not help, since we must
   // generate exactly the same IR for both the unoptimizing and optimizing
   // pipelines (otherwise it gets confused when i.e. deopt id's differ).
   // An option would be to store sampling results in the regexp object, but
   // 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();
   bool is_start_anchored = data->tree->IsAnchoredAtStart();
   intptr_t max_length = data->tree->max_match();
   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;
     }
   }
   if (is_one_byte) {
     node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     // Do it again to propagate the new nodes to places where they were not
     // put because they had not been calculated yet.
     if (node != NULL) {
       node = node->FilterOneByte(RegExpCompiler::kMaxRecursion, ignore_case);
     }
   }
 
-  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);
   if (analysis.has_failed()) {
     const char* error_message = analysis.error_message();
     return CompilationResult(error_message);
   }
 
   // Bytecode regexp implementation.
 
   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);
   }
 
   if (is_global) {
     macro_assembler->set_global_mode(
         (data->tree->min_match() > 0)
             ? RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK
             : RegExpMacroAssembler::GLOBAL);
   }
 
   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();
   }
 
   return result;
 }
 
 
-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,
                         Symbols::This());
   fn.SetParameterTypeAt(RegExpMacroAssembler::kParamStringIndex,
                         Object::dynamic_type());
   fn.SetParameterNameAt(RegExpMacroAssembler::kParamStringIndex,
                         Symbols::string_param());
   fn.SetParameterTypeAt(RegExpMacroAssembler::kParamStartOffsetIndex,
                         Object::dynamic_type());
@@ skipping 23 matching lines @@
   if (multi_line) {
     regexp.set_is_multi_line();
   }
   if (ignore_case) {
     regexp.set_is_ignore_case();
   }
 
   // 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();
 }
 
 
 }  // namespace dart