clang-format runtime/vm

runtime/vm/regexp.h

 // 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.
 
 #ifndef RUNTIME_VM_REGEXP_H_
 #define RUNTIME_VM_REGEXP_H_
 
 #include "vm/assembler.h"
 #include "vm/intermediate_language.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/object.h"
 #include "vm/regexp_assembler.h"
 
 namespace dart {
 
 class NodeVisitor;
 class RegExpCompiler;
 class RegExpMacroAssembler;
 class RegExpNode;
 class RegExpTree;
 class BoyerMooreLookahead;
 
 
 // Represents code units in the range from from_ to to_, both ends are
 // inclusive.
 class CharacterRange {
  public:
-  CharacterRange() : from_(0), to_(0) { }
-  CharacterRange(uint16_t from, uint16_t to) : from_(from), to_(to) { }
+  CharacterRange() : from_(0), to_(0) {}
+  CharacterRange(uint16_t from, uint16_t to) : from_(from), to_(to) {}
 
   static void AddClassEscape(uint16_t type,
                              ZoneGrowableArray<CharacterRange>* ranges);
   static GrowableArray<const intptr_t> GetWordBounds();
   static inline CharacterRange Singleton(uint16_t value) {
     return CharacterRange(value, value);
   }
   static inline CharacterRange Range(uint16_t from, uint16_t to) {
     ASSERT(from <= to);
     return CharacterRange(from, to);
@@ skipping 34 matching lines @@
  private:
   uint16_t from_;
   uint16_t to_;
 
   DISALLOW_ALLOCATION();
 };
 
 
 // A set of unsigned integers that behaves especially well on small
 // integers (< 32).  May do zone-allocation.
-class OutSet: public ZoneAllocated {
+class OutSet : public ZoneAllocated {
  public:
-  OutSet() : first_(0), remaining_(NULL), successors_(NULL) { }
+  OutSet() : first_(0), remaining_(NULL), successors_(NULL) {}
   OutSet* Extend(unsigned value, Zone* zone);
   bool Get(unsigned value) const;
   static const unsigned kFirstLimit = 32;
 
  private:
   // Destructively set a value in this set.  In most cases you want
   // to use Extend instead to ensure that only one instance exists
   // that contains the same values.
   void Set(unsigned value, Zone* zone);
 
   // The successors are a list of sets that contain the same values
   // as this set and the one more value that is not present in this
   // set.
   ZoneGrowableArray<OutSet*>* successors() { return successors_; }
 
   OutSet(uint32_t first, ZoneGrowableArray<unsigned>* remaining)
-      : first_(first), remaining_(remaining), successors_(NULL) { }
+      : first_(first), remaining_(remaining), successors_(NULL) {}
   uint32_t first_;
   ZoneGrowableArray<unsigned>* remaining_;
   ZoneGrowableArray<OutSet*>* successors_;
   friend class Trace;
 };
 
 
-#define FOR_EACH_NODE_TYPE(VISIT)                                    \
-  VISIT(End)                                                         \
-  VISIT(Action)                                                      \
-  VISIT(Choice)                                                      \
-  VISIT(BackReference)                                               \
-  VISIT(Assertion)                                                   \
+#define FOR_EACH_NODE_TYPE(VISIT)                                              \
+  VISIT(End)                                                                   \
+  VISIT(Action)                                                                \
+  VISIT(Choice)                                                                \
+  VISIT(BackReference)                                                         \
+  VISIT(Assertion)                                                             \
   VISIT(Text)
 
 
-#define FOR_EACH_REG_EXP_TREE_TYPE(VISIT)                            \
-  VISIT(Disjunction)                                                 \
-  VISIT(Alternative)                                                 \
-  VISIT(Assertion)                                                   \
-  VISIT(CharacterClass)                                              \
-  VISIT(Atom)                                                        \
-  VISIT(Quantifier)                                                  \
-  VISIT(Capture)                                                     \
-  VISIT(Lookahead)                                                   \
-  VISIT(BackReference)                                               \
-  VISIT(Empty)                                                       \
+#define FOR_EACH_REG_EXP_TREE_TYPE(VISIT)                                      \
+  VISIT(Disjunction)                                                           \
+  VISIT(Alternative)                                                           \
+  VISIT(Assertion)                                                             \
+  VISIT(CharacterClass)                                                        \
+  VISIT(Atom)                                                                  \
+  VISIT(Quantifier)                                                            \
+  VISIT(Capture)                                                               \
+  VISIT(Lookahead)                                                             \
+  VISIT(BackReference)                                                         \
+  VISIT(Empty)                                                                 \
   VISIT(Text)
 
 
 #define FORWARD_DECLARE(Name) class RegExp##Name;
 FOR_EACH_REG_EXP_TREE_TYPE(FORWARD_DECLARE)
 #undef FORWARD_DECLARE
 
 
 class TextElement {
  public:
-  enum TextType {
-    ATOM,
-    CHAR_CLASS
-  };
+  enum TextType { ATOM, CHAR_CLASS };
 
   static TextElement Atom(RegExpAtom* atom);
   static TextElement CharClass(RegExpCharacterClass* char_class);
 
   intptr_t cp_offset() const { return cp_offset_; }
   void set_cp_offset(intptr_t cp_offset) { cp_offset_ = cp_offset; }
   intptr_t length() const;
 
   TextType text_type() const { return text_type_; }
 
@@ skipping 28 matching lines @@
 
 struct NodeInfo {
   NodeInfo()
       : being_analyzed(false),
         been_analyzed(false),
         follows_word_interest(false),
         follows_newline_interest(false),
         follows_start_interest(false),
         at_end(false),
         visited(false),
-        replacement_calculated(false) { }
+        replacement_calculated(false) {}
 
   // Returns true if the interests and assumptions of this node
   // matches the given one.
   bool Matches(NodeInfo* that) {
     return (at_end == that->at_end) &&
            (follows_word_interest == that->follows_word_interest) &&
            (follows_newline_interest == that->follows_newline_interest) &&
            (follows_start_interest == that->follows_start_interest);
   }
 
   // Updates the interests of this node given the interests of the
   // node preceding it.
   void AddFromPreceding(NodeInfo* that) {
     at_end |= that->at_end;
     follows_word_interest |= that->follows_word_interest;
     follows_newline_interest |= that->follows_newline_interest;
     follows_start_interest |= that->follows_start_interest;
   }
 
   bool HasLookbehind() {
-    return follows_word_interest ||
-           follows_newline_interest ||
+    return follows_word_interest || follows_newline_interest ||
            follows_start_interest;
   }
 
   // Sets the interests of this node to include the interests of the
   // following node.
   void AddFromFollowing(NodeInfo* that) {
     follows_word_interest |= that->follows_word_interest;
     follows_newline_interest |= that->follows_newline_interest;
     follows_start_interest |= that->follows_start_interest;
   }
 
   void ResetCompilationState() {
     being_analyzed = false;
     been_analyzed = false;
   }
 
-  bool being_analyzed: 1;
-  bool been_analyzed: 1;
+  bool being_analyzed : 1;
+  bool been_analyzed : 1;
 
   // These bits are set of this node has to know what the preceding
   // character was.
-  bool follows_word_interest: 1;
-  bool follows_newline_interest: 1;
-  bool follows_start_interest: 1;
+  bool follows_word_interest : 1;
+  bool follows_newline_interest : 1;
+  bool follows_start_interest : 1;
 
-  bool at_end: 1;
-  bool visited: 1;
-  bool replacement_calculated: 1;
+  bool at_end : 1;
+  bool visited : 1;
+  bool replacement_calculated : 1;
 };
 
 
 // Details of a quick mask-compare check that can look ahead in the
 // input stream.
 class QuickCheckDetails {
  public:
   QuickCheckDetails()
-      : characters_(0),
-        mask_(0),
-        value_(0),
-        cannot_match_(false) { }
+      : characters_(0), mask_(0), value_(0), cannot_match_(false) {}
   explicit QuickCheckDetails(intptr_t characters)
-      : characters_(characters),
-        mask_(0),
-        value_(0),
-        cannot_match_(false) { }
+      : characters_(characters), mask_(0), value_(0), cannot_match_(false) {}
   bool Rationalize(bool one_byte);
   // Merge in the information from another branch of an alternation.
   void Merge(QuickCheckDetails* other, intptr_t from_index);
   // Advance the current position by some amount.
   void Advance(intptr_t by, bool one_byte);
   void Clear();
   bool cannot_match() { return cannot_match_; }
   void set_cannot_match() { cannot_match_ = true; }
   struct Position {
-    Position() : mask(0), value(0), determines_perfectly(false) { }
+    Position() : mask(0), value(0), determines_perfectly(false) {}
     uint16_t mask;
     uint16_t value;
     bool determines_perfectly;
   };
   intptr_t characters() { return characters_; }
   void set_characters(intptr_t characters) { characters_ = characters; }
   Position* positions(intptr_t index) {
     ASSERT(index >= 0);
     ASSERT(index < characters_);
     return positions_ + index;
@@ skipping 10 matching lines @@
   uint32_t mask_;
   uint32_t value_;
   // If set to true, there is no way this quick check can match at all.
   // E.g., if it requires to be at the start of the input, and isn't.
   bool cannot_match_;
 
   DISALLOW_ALLOCATION();
 };
 
 
-class RegExpNode: public ZoneAllocated {
+class RegExpNode : public ZoneAllocated {
  public:
   explicit RegExpNode(Zone* zone)
-  : replacement_(NULL), trace_count_(0), zone_(zone) {
+      : replacement_(NULL), trace_count_(0), zone_(zone) {
     bm_info_[0] = bm_info_[1] = NULL;
   }
   virtual ~RegExpNode();
   virtual void Accept(NodeVisitor* visitor) = 0;
   // Generates a goto to this node or actually generates the code at this point.
   virtual void Emit(RegExpCompiler* compiler, Trace* trace) = 0;
   // How many characters must this node consume at a minimum in order to
   // succeed.  If we have found at least 'still_to_find' characters that
   // must be consumed there is no need to ask any following nodes whether
   // they are sure to eat any more characters.  The not_at_start argument is
   // used to indicate that we know we are not at the start of the input.  In
   // this case anchored branches will always fail and can be ignored when
   // determining how many characters are consumed on success.
-  virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
+  virtual intptr_t EatsAtLeast(intptr_t still_to_find,
+                               intptr_t budget,
                                bool not_at_start) = 0;
   // Emits some quick code that checks whether the preloaded characters match.
   // Falls through on certain failure, jumps to the label on possible success.
   // If the node cannot make a quick check it does nothing and returns false.
   bool EmitQuickCheck(RegExpCompiler* compiler,
                       Trace* bounds_check_trace,
                       Trace* trace,
                       bool preload_has_checked_bounds,
                       BlockLabel* on_possible_success,
                       QuickCheckDetails* details_return,
@@ skipping 36 matching lines @@
   virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case) {
     return this;
   }
   // Helper for FilterOneByte.
   RegExpNode* replacement() {
     ASSERT(info()->replacement_calculated);
     return replacement_;
   }
   RegExpNode* set_replacement(RegExpNode* replacement) {
     info()->replacement_calculated = true;
-    replacement_ =  replacement;
+    replacement_ = replacement;
     return replacement;  // For convenience.
   }
 
   // We want to avoid recalculating the lookahead info, so we store it on the
   // node.  Only info that is for this node is stored.  We can tell that the
   // info is for this node when offset == 0, so the information is calculated
   // relative to this node.
   void SaveBMInfo(BoyerMooreLookahead* bm, bool not_at_start, intptr_t offset) {
     if (offset == 0) set_bm_info(not_at_start, bm);
   }
@@ skipping 35 matching lines @@
   // deferred operations in the current trace and generating a goto.
   intptr_t trace_count_;
   BoyerMooreLookahead* bm_info_[2];
   Zone* zone_;
 };
 
 
 // A simple closed interval.
 class Interval {
  public:
-  Interval() : from_(kNone), to_(kNone) { }
-  Interval(intptr_t from, intptr_t to) : from_(from), to_(to) { }
+  Interval() : from_(kNone), to_(kNone) {}
+  Interval(intptr_t from, intptr_t to) : from_(from), to_(to) {}
 
   Interval Union(Interval that) {
     if (that.from_ == kNone)
       return *this;
     else if (from_ == kNone)
       return that;
     else
       return Interval(Utils::Minimum(from_, that.from_),
                       Utils::Maximum(to_, that.to_));
   }
   bool Contains(intptr_t value) const {
     return (from_ <= value) && (value <= to_);
   }
   bool is_empty() const { return from_ == kNone; }
   intptr_t from() const { return from_; }
   intptr_t to() const { return to_; }
   static Interval Empty() { return Interval(); }
   static const intptr_t kNone = -1;
 
  private:
   intptr_t from_;
   intptr_t to_;
 
   DISALLOW_ALLOCATION();
 };
 
 
-class SeqRegExpNode: public RegExpNode {
+class SeqRegExpNode : public RegExpNode {
  public:
   explicit SeqRegExpNode(RegExpNode* on_success)
-      : RegExpNode(on_success->zone()), on_success_(on_success) { }
+      : RegExpNode(on_success->zone()), on_success_(on_success) {}
   RegExpNode* on_success() { return on_success_; }
   void set_on_success(RegExpNode* node) { on_success_ = node; }
   virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start) {
     on_success_->FillInBMInfo(offset, budget - 1, bm, not_at_start);
     if (offset == 0) set_bm_info(not_at_start, bm);
   }
 
  protected:
   RegExpNode* FilterSuccessor(intptr_t depth, bool ignore_case);
 
  private:
   RegExpNode* on_success_;
 };
 
 
-class ActionNode: public SeqRegExpNode {
+class ActionNode : public SeqRegExpNode {
  public:
   enum ActionType {
     SET_REGISTER,
     INCREMENT_REGISTER,
     STORE_POSITION,
     BEGIN_SUBMATCH,
     POSITIVE_SUBMATCH_SUCCESS,
     EMPTY_MATCH_CHECK,
     CLEAR_CAPTURES
   };
-  static ActionNode* SetRegister(intptr_t reg, intptr_t val,
+  static ActionNode* SetRegister(intptr_t reg,
+                                 intptr_t val,
                                  RegExpNode* on_success);
   static ActionNode* IncrementRegister(intptr_t reg, RegExpNode* on_success);
   static ActionNode* StorePosition(intptr_t reg,
                                    bool is_capture,
                                    RegExpNode* on_success);
   static ActionNode* ClearCaptures(Interval range, RegExpNode* on_success);
   static ActionNode* BeginSubmatch(intptr_t stack_pointer_reg,
                                    intptr_t position_reg,
                                    RegExpNode* on_success);
   static ActionNode* PositiveSubmatchSuccess(intptr_t stack_pointer_reg,
                                              intptr_t restore_reg,
                                              intptr_t clear_capture_count,
                                              intptr_t clear_capture_from,
                                              RegExpNode* on_success);
   static ActionNode* EmptyMatchCheck(intptr_t start_register,
                                      intptr_t repetition_register,
                                      intptr_t repetition_limit,
                                      RegExpNode* on_success);
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
-  virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
+  virtual intptr_t EatsAtLeast(intptr_t still_to_find,
+                               intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t filled_in,
                                     bool not_at_start) {
-    return on_success()->GetQuickCheckDetails(
-        details, compiler, filled_in, not_at_start);
+    return on_success()->GetQuickCheckDetails(details, compiler, filled_in,
+                                              not_at_start);
   }
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start);
   ActionType action_type() { return action_type_; }
   // TODO(erikcorry): We should allow some action nodes in greedy loops.
   virtual intptr_t GreedyLoopTextLength() {
     return kNodeIsTooComplexForGreedyLoops;
   }
@@ skipping 21 matching lines @@
       intptr_t start_register;
       intptr_t repetition_register;
       intptr_t repetition_limit;
     } u_empty_match_check;
     struct {
       intptr_t range_from;
       intptr_t range_to;
     } u_clear_captures;
   } data_;
   ActionNode(ActionType action_type, RegExpNode* on_success)
-      : SeqRegExpNode(on_success),
-        action_type_(action_type) { }
+      : SeqRegExpNode(on_success), action_type_(action_type) {}
   ActionType action_type_;
   friend class DotPrinter;
 };
 
 
-class TextNode: public SeqRegExpNode {
+class TextNode : public SeqRegExpNode {
  public:
-  TextNode(ZoneGrowableArray<TextElement>* elms,
-           RegExpNode* on_success)
+  TextNode(ZoneGrowableArray<TextElement>* elms, RegExpNode* on_success)
+      : SeqRegExpNode(on_success), elms_(elms) {}
+  TextNode(RegExpCharacterClass* that, RegExpNode* on_success)
       : SeqRegExpNode(on_success),
-        elms_(elms) { }
-  TextNode(RegExpCharacterClass* that,
-           RegExpNode* on_success)
-      : SeqRegExpNode(on_success),
-        elms_(new(zone()) ZoneGrowableArray<TextElement>(1)) {
+        elms_(new (zone()) ZoneGrowableArray<TextElement>(1)) {
     elms_->Add(TextElement::CharClass(that));
   }
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
-  virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
+  virtual intptr_t EatsAtLeast(intptr_t still_to_find,
+                               intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start);
   ZoneGrowableArray<TextElement>* elements() { return elms_; }
   void MakeCaseIndependent(bool is_one_byte);
   virtual intptr_t GreedyLoopTextLength();
   virtual RegExpNode* GetSuccessorOfOmnivorousTextNode(
       RegExpCompiler* compiler);
@@ skipping 19 matching lines @@
                     TextEmitPassType pass,
                     bool preloaded,
                     Trace* trace,
                     bool first_element_checked,
                     intptr_t* checked_up_to);
   intptr_t Length();
   ZoneGrowableArray<TextElement>* elms_;
 };
 
 
-class AssertionNode: public SeqRegExpNode {
+class AssertionNode : public SeqRegExpNode {
  public:
   enum AssertionType {
     AT_END,
     AT_START,
     AT_BOUNDARY,
     AT_NON_BOUNDARY,
     AFTER_NEWLINE
   };
   static AssertionNode* AtEnd(RegExpNode* on_success) {
-    return new(on_success->zone()) AssertionNode(AT_END, on_success);
+    return new (on_success->zone()) AssertionNode(AT_END, on_success);
   }
   static AssertionNode* AtStart(RegExpNode* on_success) {
-    return new(on_success->zone()) AssertionNode(AT_START, on_success);
+    return new (on_success->zone()) AssertionNode(AT_START, on_success);
   }
   static AssertionNode* AtBoundary(RegExpNode* on_success) {
-    return new(on_success->zone()) AssertionNode(AT_BOUNDARY, on_success);
+    return new (on_success->zone()) AssertionNode(AT_BOUNDARY, on_success);
   }
   static AssertionNode* AtNonBoundary(RegExpNode* on_success) {
-    return new(on_success->zone()) AssertionNode(AT_NON_BOUNDARY,
-                                                    on_success);
+    return new (on_success->zone()) AssertionNode(AT_NON_BOUNDARY, on_success);
   }
   static AssertionNode* AfterNewline(RegExpNode* on_success) {
-    return new(on_success->zone()) AssertionNode(AFTER_NEWLINE, on_success);
+    return new (on_success->zone()) AssertionNode(AFTER_NEWLINE, on_success);
   }
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
-  virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
+  virtual intptr_t EatsAtLeast(intptr_t still_to_find,
+                               intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t filled_in,
                                     bool not_at_start);
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start);
   AssertionType assertion_type() { return assertion_type_; }
 
  private:
   void EmitBoundaryCheck(RegExpCompiler* compiler, Trace* trace);
   enum IfPrevious { kIsNonWord, kIsWord };
   void BacktrackIfPrevious(RegExpCompiler* compiler,
                            Trace* trace,
                            IfPrevious backtrack_if_previous);
   AssertionNode(AssertionType t, RegExpNode* on_success)
-      : SeqRegExpNode(on_success), assertion_type_(t) { }
+      : SeqRegExpNode(on_success), assertion_type_(t) {}
   AssertionType assertion_type_;
 };
 
 
-class BackReferenceNode: public SeqRegExpNode {
+class BackReferenceNode : public SeqRegExpNode {
  public:
   BackReferenceNode(intptr_t start_reg,
                     intptr_t end_reg,
                     RegExpNode* on_success)
-      : SeqRegExpNode(on_success),
-        start_reg_(start_reg),
-        end_reg_(end_reg) { }
+      : SeqRegExpNode(on_success), start_reg_(start_reg), end_reg_(end_reg) {}
   virtual void Accept(NodeVisitor* visitor);
   intptr_t start_register() { return start_reg_; }
   intptr_t end_register() { return end_reg_; }
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
   virtual intptr_t EatsAtLeast(intptr_t still_to_find,
                                intptr_t recursion_depth,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start) {
     return;
   }
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start);
 
  private:
   intptr_t start_reg_;
   intptr_t end_reg_;
 };
 
 
-class EndNode: public RegExpNode {
+class EndNode : public RegExpNode {
  public:
   enum Action { ACCEPT, BACKTRACK, NEGATIVE_SUBMATCH_SUCCESS };
   explicit EndNode(Action action, Zone* zone)
-      : RegExpNode(zone), action_(action) { }
+      : RegExpNode(zone), action_(action) {}
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
   virtual intptr_t EatsAtLeast(intptr_t still_to_find,
-                          intptr_t recursion_depth,
-                          bool not_at_start) { return 0; }
+                               intptr_t recursion_depth,
+                               bool not_at_start) {
+    return 0;
+  }
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start) {
     // Returning 0 from EatsAtLeast should ensure we never get here.
     UNREACHABLE();
   }
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start) {
     // Returning 0 from EatsAtLeast should ensure we never get here.
     UNREACHABLE();
   }
 
  private:
   Action action_;
 };
 
 
-class NegativeSubmatchSuccess: public EndNode {
+class NegativeSubmatchSuccess : public EndNode {
  public:
   NegativeSubmatchSuccess(intptr_t stack_pointer_reg,
                           intptr_t position_reg,
                           intptr_t clear_capture_count,
                           intptr_t clear_capture_start,
                           Zone* zone)
       : EndNode(NEGATIVE_SUBMATCH_SUCCESS, zone),
         stack_pointer_register_(stack_pointer_reg),
         current_position_register_(position_reg),
         clear_capture_count_(clear_capture_count),
-        clear_capture_start_(clear_capture_start) { }
+        clear_capture_start_(clear_capture_start) {}
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
 
  private:
   intptr_t stack_pointer_register_;
   intptr_t current_position_register_;
   intptr_t clear_capture_count_;
   intptr_t clear_capture_start_;
 };
 
 
-class Guard: public ZoneAllocated {
+class Guard : public ZoneAllocated {
  public:
   enum Relation { LT, GEQ };
   Guard(intptr_t reg, Relation op, intptr_t value)
-      : reg_(reg),
-        op_(op),
-        value_(value) { }
+      : reg_(reg), op_(op), value_(value) {}
   intptr_t reg() { return reg_; }
   Relation op() { return op_; }
   intptr_t value() { return value_; }
 
  private:
   intptr_t reg_;
   Relation op_;
   intptr_t value_;
 };
 
 
 class GuardedAlternative {
  public:
-  explicit GuardedAlternative(RegExpNode* node) : node_(node), guards_(NULL) { }
+  explicit GuardedAlternative(RegExpNode* node) : node_(node), guards_(NULL) {}
   void AddGuard(Guard* guard, Zone* zone);
   RegExpNode* node() { return node_; }
   void set_node(RegExpNode* node) { node_ = node; }
   ZoneGrowableArray<Guard*>* guards() { return guards_; }
 
  private:
   RegExpNode* node_;
   ZoneGrowableArray<Guard*>* guards_;
 
   DISALLOW_ALLOCATION();
 };
 
 
 struct AlternativeGeneration;
 
 
-class ChoiceNode: public RegExpNode {
+class ChoiceNode : public RegExpNode {
  public:
   explicit ChoiceNode(intptr_t expected_size, Zone* zone)
       : RegExpNode(zone),
-        alternatives_(new(zone)
-                      ZoneGrowableArray<GuardedAlternative>(expected_size)),
+        alternatives_(new (zone)
+                          ZoneGrowableArray<GuardedAlternative>(expected_size)),
         not_at_start_(false),
-        being_calculated_(false) { }
+        being_calculated_(false) {}
   virtual void Accept(NodeVisitor* visitor);
-  void AddAlternative(GuardedAlternative node) {
-    alternatives()->Add(node);
-  }
+  void AddAlternative(GuardedAlternative node) { alternatives()->Add(node); }
   ZoneGrowableArray<GuardedAlternative>* alternatives() {
     return alternatives_;
   }
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
-  virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
+  virtual intptr_t EatsAtLeast(intptr_t still_to_find,
+                               intptr_t budget,
                                bool not_at_start);
   intptr_t EatsAtLeastHelper(intptr_t still_to_find,
                              intptr_t budget,
                              RegExpNode* ignore_this_node,
                              bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start);
   virtual void FillInBMInfo(intptr_t offset,
@@ skipping 44 matching lines @@
                    intptr_t first_choice,
                    Trace* trace,
                    PreloadState* preloads);
   // If true, this node is never checked at the start of the input.
   // Allows a new trace to start with at_start() set to false.
   bool not_at_start_;
   bool being_calculated_;
 };
 
 
-class NegativeLookaheadChoiceNode: public ChoiceNode {
+class NegativeLookaheadChoiceNode : public ChoiceNode {
  public:
   explicit NegativeLookaheadChoiceNode(GuardedAlternative this_must_fail,
                                        GuardedAlternative then_do_this,
                                        Zone* zone)
       : ChoiceNode(2, zone) {
     AddAlternative(this_must_fail);
     AddAlternative(then_do_this);
   }
-  virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
+  virtual intptr_t EatsAtLeast(intptr_t still_to_find,
+                               intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start);
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start) {
-    (*alternatives_)[1].node()->FillInBMInfo(
-        offset, budget - 1, bm, not_at_start);
+    (*alternatives_)[1].node()->FillInBMInfo(offset, budget - 1, bm,
+                                             not_at_start);
     if (offset == 0) set_bm_info(not_at_start, bm);
   }
   // For a negative lookahead we don't emit the quick check for the
   // alternative that is expected to fail.  This is because quick check code
   // starts by loading enough characters for the alternative that takes fewest
   // characters, but on a negative lookahead the negative branch did not take
   // part in that calculation (EatsAtLeast) so the assumptions don't hold.
   virtual bool try_to_emit_quick_check_for_alternative(bool is_first) {
     return !is_first;
   }
   virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
 };
 
 
-class LoopChoiceNode: public ChoiceNode {
+class LoopChoiceNode : public ChoiceNode {
  public:
   explicit LoopChoiceNode(bool body_can_be_zero_length, Zone* zone)
       : ChoiceNode(2, zone),
         loop_node_(NULL),
         continue_node_(NULL),
-        body_can_be_zero_length_(body_can_be_zero_length) { }
+        body_can_be_zero_length_(body_can_be_zero_length) {}
   void AddLoopAlternative(GuardedAlternative alt);
   void AddContinueAlternative(GuardedAlternative alt);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
-  virtual intptr_t EatsAtLeast(intptr_t still_to_find,  intptr_t budget,
+  virtual intptr_t EatsAtLeast(intptr_t still_to_find,
+                               intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start);
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start);
   RegExpNode* loop_node() { return loop_node_; }
@@ skipping 56 matching lines @@
 
 ContainedInLattice AddRange(ContainedInLattice a,
                             const intptr_t* ranges,
                             intptr_t ranges_size,
                             Interval new_range);
 
 
 class BoyerMoorePositionInfo : public ZoneAllocated {
  public:
   explicit BoyerMoorePositionInfo(Zone* zone)
-      : map_(new(zone) ZoneGrowableArray<bool>(kMapSize)),
+      : map_(new (zone) ZoneGrowableArray<bool>(kMapSize)),
         map_count_(0),
         w_(kNotYet),
         s_(kNotYet),
         d_(kNotYet),
         surrogate_(kNotYet) {
-     for (intptr_t i = 0; i < kMapSize; i++) {
-       map_->Add(false);
-     }
+    for (intptr_t i = 0; i < kMapSize; i++) {
+      map_->Add(false);
+    }
   }
 
   bool& at(intptr_t i) { return (*map_)[i]; }
 
   static const intptr_t kMapSize = 128;
   static const intptr_t kMask = kMapSize - 1;
 
   intptr_t map_count() const { return map_count_; }
 
   void Set(intptr_t character);
   void SetInterval(const Interval& interval);
   void SetAll();
   bool is_non_word() { return w_ == kLatticeOut; }
   bool is_word() { return w_ == kLatticeIn; }
 
  private:
   ZoneGrowableArray<bool>* map_;
-  intptr_t map_count_;  // Number of set bits in the map.
-  ContainedInLattice w_;  // The \w character class.
-  ContainedInLattice s_;  // The \s character class.
-  ContainedInLattice d_;  // The \d character class.
+  intptr_t map_count_;            // Number of set bits in the map.
+  ContainedInLattice w_;          // The \w character class.
+  ContainedInLattice s_;          // The \s character class.
+  ContainedInLattice d_;          // The \d character class.
   ContainedInLattice surrogate_;  // Surrogate UTF-16 code units.
 };
 
 
-class BoyerMooreLookahead : public ZoneAllocated{
+class BoyerMooreLookahead : public ZoneAllocated {
  public:
-  BoyerMooreLookahead(intptr_t length, RegExpCompiler* compiler,
-                      Zone* Zone);
+  BoyerMooreLookahead(intptr_t length, RegExpCompiler* compiler, Zone* Zone);
 
   intptr_t length() { return length_; }
   intptr_t max_char() { return max_char_; }
   RegExpCompiler* compiler() { return compiler_; }
 
   intptr_t Count(intptr_t map_number) {
     return bitmaps_->At(map_number)->map_count();
   }
 
   BoyerMoorePositionInfo* at(intptr_t i) { return bitmaps_->At(i); }
 
   void Set(intptr_t map_number, intptr_t character) {
     if (character > max_char_) return;
     BoyerMoorePositionInfo* info = bitmaps_->At(map_number);
     info->Set(character);
   }
 
   void SetInterval(intptr_t map_number, const Interval& interval) {
     if (interval.from() > max_char_) return;
     BoyerMoorePositionInfo* info = bitmaps_->At(map_number);
     if (interval.to() > max_char_) {
       info->SetInterval(Interval(interval.from(), max_char_));
     } else {
       info->SetInterval(interval);
     }
   }
 
-  void SetAll(intptr_t map_number) {
-    bitmaps_->At(map_number)->SetAll();
-  }
+  void SetAll(intptr_t map_number) { bitmaps_->At(map_number)->SetAll(); }
 
   void SetRest(intptr_t from_map) {
-    for (intptr_t i = from_map; i < length_; i++) SetAll(i);
+    for (intptr_t i = from_map; i < length_; i++)
+      SetAll(i);
   }
   void EmitSkipInstructions(RegExpMacroAssembler* masm);
 
  private:
   // This is the value obtained by EatsAtLeast.  If we do not have at least this
   // many characters left in the sample string then the match is bound to fail.
   // Therefore it is OK to read a character this far ahead of the current match
   // point.
   intptr_t length_;
   RegExpCompiler* compiler_;
   // 0xff for Latin1, 0xffff for UTF-16.
   intptr_t max_char_;
   ZoneGrowableArray<BoyerMoorePositionInfo*>* bitmaps_;
 
   intptr_t GetSkipTable(intptr_t min_lookahead,
                         intptr_t max_lookahead,
                         const TypedData& boolean_skip_table);
   bool FindWorthwhileInterval(intptr_t* from, intptr_t* to);
-  intptr_t FindBestInterval(
-      intptr_t max_number_of_chars,
-      intptr_t old_biggest_points,
-      intptr_t* from, intptr_t* to);
+  intptr_t FindBestInterval(intptr_t max_number_of_chars,
+                            intptr_t old_biggest_points,
+                            intptr_t* from,
+                            intptr_t* to);
 };
 
 
 // There are many ways to generate code for a node.  This class encapsulates
 // the current way we should be generating.  In other words it encapsulates
 // the current state of the code generator.  The effect of this is that we
 // generate code for paths that the matcher can take through the regular
 // expression.  A given node in the regexp can be code-generated several times
 // as it can be part of several traces.  For example for the regexp:
 // /foo(bar|ip)baz/ the code to match baz will be generated twice, once as part
 // of the foo-bar-baz trace and once as part of the foo-ip-baz trace.  The code
 // to match foo is generated only once (the traces have a common prefix).  The
 // code to store the capture is deferred and generated (twice) after the places
 // where baz has been matched.
 class Trace {
  public:
   // A value for a property that is either known to be true, know to be false,
   // or not known.
-  enum TriBool {
-    UNKNOWN = -1, FALSE_VALUE = 0, TRUE_VALUE = 1
-  };
+  enum TriBool { UNKNOWN = -1, FALSE_VALUE = 0, TRUE_VALUE = 1 };
 
   class DeferredAction {
    public:
     DeferredAction(ActionNode::ActionType action_type, intptr_t reg)
-        : action_type_(action_type), reg_(reg), next_(NULL) { }
+        : action_type_(action_type), reg_(reg), next_(NULL) {}
     DeferredAction* next() { return next_; }
     bool Mentions(intptr_t reg);
     intptr_t reg() { return reg_; }
     ActionNode::ActionType action_type() { return action_type_; }
+
    private:
     ActionNode::ActionType action_type_;
     intptr_t reg_;
     DeferredAction* next_;
     friend class Trace;
 
     DISALLOW_ALLOCATION();
   };
 
   class DeferredCapture : public DeferredAction {
    public:
     DeferredCapture(intptr_t reg, bool is_capture, Trace* trace)
         : DeferredAction(ActionNode::STORE_POSITION, reg),
           cp_offset_(trace->cp_offset()),
-          is_capture_(is_capture) { }
+          is_capture_(is_capture) {}
     intptr_t cp_offset() { return cp_offset_; }
     bool is_capture() { return is_capture_; }
+
    private:
     intptr_t cp_offset_;
     bool is_capture_;
     void set_cp_offset(intptr_t cp_offset) { cp_offset_ = cp_offset; }
   };
 
   class DeferredSetRegister : public DeferredAction {
    public:
     DeferredSetRegister(intptr_t reg, intptr_t value)
-        : DeferredAction(ActionNode::SET_REGISTER, reg),
-          value_(value) { }
+        : DeferredAction(ActionNode::SET_REGISTER, reg), value_(value) {}
     intptr_t value() { return value_; }
+
    private:
     intptr_t value_;
   };
 
   class DeferredClearCaptures : public DeferredAction {
    public:
     explicit DeferredClearCaptures(Interval range)
-        : DeferredAction(ActionNode::CLEAR_CAPTURES, -1),
-          range_(range) { }
+        : DeferredAction(ActionNode::CLEAR_CAPTURES, -1), range_(range) {}
     Interval range() { return range_; }
+
    private:
     Interval range_;
   };
 
   class DeferredIncrementRegister : public DeferredAction {
    public:
     explicit DeferredIncrementRegister(intptr_t reg)
-        : DeferredAction(ActionNode::INCREMENT_REGISTER, reg) { }
+        : DeferredAction(ActionNode::INCREMENT_REGISTER, reg) {}
   };
 
   Trace()
       : cp_offset_(0),
         actions_(NULL),
         backtrack_(NULL),
         stop_node_(NULL),
         loop_label_(NULL),
         characters_preloaded_(0),
         bound_checked_up_to_(0),
         flush_budget_(100),
-        at_start_(UNKNOWN) { }
+        at_start_(UNKNOWN) {}
 
   // End the trace.  This involves flushing the deferred actions in the trace
   // and pushing a backtrack location onto the backtrack stack.  Once this is
   // done we can start a new trace or go to one that has already been
   // generated.
   void Flush(RegExpCompiler* compiler, RegExpNode* successor);
   intptr_t cp_offset() { return cp_offset_; }
   DeferredAction* actions() { return actions_; }
   // A trivial trace is one that has no deferred actions or other state that
   // affects the assumptions used when generating code.  There is no recorded
   // backtrack location in a trivial trace, so with a trivial trace we will
   // generate code that, on a failure to match, gets the backtrack location
   // from the backtrack stack rather than using a direct jump instruction.  We
   // always start code generation with a trivial trace and non-trivial traces
   // are created as we emit code for nodes or add to the list of deferred
   // actions in the trace.  The location of the code generated for a node using
   // a trivial trace is recorded in a label in the node so that gotos can be
   // generated to that code.
   bool is_trivial() {
-    return backtrack_ == NULL &&
-           actions_ == NULL &&
-           cp_offset_ == 0 &&
-           characters_preloaded_ == 0 &&
-           bound_checked_up_to_ == 0 &&
-           quick_check_performed_.characters() == 0 &&
-           at_start_ == UNKNOWN;
+    return backtrack_ == NULL && actions_ == NULL && cp_offset_ == 0 &&
+           characters_preloaded_ == 0 && bound_checked_up_to_ == 0 &&
+           quick_check_performed_.characters() == 0 && at_start_ == UNKNOWN;
   }
   TriBool at_start() { return at_start_; }
   void set_at_start(bool at_start) {
     at_start_ = at_start ? TRUE_VALUE : FALSE_VALUE;
   }
   BlockLabel* backtrack() { return backtrack_; }
   BlockLabel* loop_label() { return loop_label_; }
   RegExpNode* stop_node() { return stop_node_; }
   intptr_t characters_preloaded() { return characters_preloaded_; }
   intptr_t bound_checked_up_to() { return bound_checked_up_to_; }
@@ skipping 64 matching lines @@
   Trace counter_backtrack_trace_;
 };
 
 
 struct PreloadState {
   static const intptr_t kEatsAtLeastNotYetInitialized = -1;
   bool preload_is_current_;
   bool preload_has_checked_bounds_;
   intptr_t preload_characters_;
   intptr_t eats_at_least_;
-  void init() {
-    eats_at_least_ = kEatsAtLeastNotYetInitialized;
-  }
+  void init() { eats_at_least_ = kEatsAtLeastNotYetInitialized; }
 
   DISALLOW_ALLOCATION();
 };
 
 
 class NodeVisitor : public ValueObject {
  public:
-  virtual ~NodeVisitor() { }
-#define DECLARE_VISIT(Type)                                          \
-  virtual void Visit##Type(Type##Node* that) = 0;
-FOR_EACH_NODE_TYPE(DECLARE_VISIT)
+  virtual ~NodeVisitor() {}
+#define DECLARE_VISIT(Type) virtual void Visit##Type(Type##Node* that) = 0;
+  FOR_EACH_NODE_TYPE(DECLARE_VISIT)
 #undef DECLARE_VISIT
   virtual void VisitLoopChoice(LoopChoiceNode* that) { VisitChoice(that); }
 };
 
 
 // Assertion propagation moves information about assertions such as
 // \b to the affected nodes.  For instance, in /.\b./ information must
 // be propagated to the first '.' that whatever follows needs to know
 // if it matched a word or a non-word, and to the second '.' that it
 // has to check if it succeeds a word or non-word.  In this case the
 // result will be something like:
 //
 //   +-------+        +------------+
 //   |   .   |        |      .     |
 //   +-------+  --->  +------------+
 //   | word? |        | check word |
 //   +-------+        +------------+
-class Analysis: public NodeVisitor {
+class Analysis : public NodeVisitor {
  public:
   Analysis(bool ignore_case, bool is_one_byte)
       : ignore_case_(ignore_case),
         is_one_byte_(is_one_byte),
-        error_message_(NULL) { }
+        error_message_(NULL) {}
   void EnsureAnalyzed(RegExpNode* node);
 
-#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
   virtual void VisitLoopChoice(LoopChoiceNode* that);
 
   bool has_failed() { return error_message_ != NULL; }
   const char* error_message() {
     ASSERT(error_message_ != NULL);
     return error_message_;
   }
-  void fail(const char* error_message) {
-    error_message_ = error_message;
-  }
+  void fail(const char* error_message) { error_message_ = error_message; }
 
  private:
   bool ignore_case_;
   bool is_one_byte_;
   const char* error_message_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Analysis);
 };
 
 
 struct RegExpCompileData : public ZoneAllocated {
   RegExpCompileData()
-    : tree(NULL),
-      node(NULL),
-      simple(true),
-      contains_anchor(false),
-      error(String::Handle(String::null())),
-      capture_count(0) { }
+      : tree(NULL),
+        node(NULL),
+        simple(true),
+        contains_anchor(false),
+        error(String::Handle(String::null())),
+        capture_count(0) {}
   RegExpTree* tree;
   RegExpNode* node;
   bool simple;
   bool contains_anchor;
   String& error;
   intptr_t capture_count;
 };
 
 
-class RegExpEngine: public AllStatic {
+class RegExpEngine : public AllStatic {
  public:
   struct CompilationResult {
     explicit CompilationResult(const char* error_message)
         : backtrack_goto(NULL),
           graph_entry(NULL),
           num_blocks(-1),
           num_stack_locals(-1),
           error_message(error_message),
           bytecode(NULL),
           num_registers(-1) {}
 
     CompilationResult(TypedData* bytecode, intptr_t num_registers)
         : backtrack_goto(NULL),
           graph_entry(NULL),
           num_blocks(-1),
           num_stack_locals(-1),
           error_message(NULL),
           bytecode(bytecode),
           num_registers(num_registers) {}
 
     CompilationResult(IndirectGotoInstr* backtrack_goto,
                       GraphEntryInstr* graph_entry,
                       intptr_t num_blocks,
                       intptr_t num_stack_locals,
                       intptr_t num_registers)
-      : backtrack_goto(backtrack_goto),
-        graph_entry(graph_entry),
-        num_blocks(num_blocks),
-        num_stack_locals(num_stack_locals),
-        error_message(NULL),
-        bytecode(NULL) {}
+        : backtrack_goto(backtrack_goto),
+          graph_entry(graph_entry),
+          num_blocks(num_blocks),
+          num_stack_locals(num_stack_locals),
+          error_message(NULL),
+          bytecode(NULL) {}
 
     IndirectGotoInstr* backtrack_goto;
     GraphEntryInstr* graph_entry;
     const intptr_t num_blocks;
     const intptr_t num_stack_locals;
 
     const char* error_message;
 
     TypedData* bytecode;
     intptr_t num_registers;
   };
 
   static CompilationResult CompileIR(
       RegExpCompileData* input,
       const ParsedFunction* parsed_function,
       const ZoneGrowableArray<const ICData*>& ic_data_array);
 
-  static CompilationResult CompileBytecode(
-      RegExpCompileData* data,
-      const RegExp& regexp,
-      bool is_one_byte,
-      Zone* zone);
+  static CompilationResult CompileBytecode(RegExpCompileData* data,
+                                           const RegExp& regexp,
+                                           bool is_one_byte,
+                                           Zone* zone);
 
-  static RawRegExp* CreateRegExp(
-      Thread* thread,
-      const String& pattern,
-      bool multi_line,
-      bool ignore_case);
+  static RawRegExp* CreateRegExp(Thread* thread,
+                                 const String& pattern,
+                                 bool multi_line,
+                                 bool ignore_case);
 
   static void DotPrint(const char* label, RegExpNode* node, bool ignore_case);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_REGEXP_H_