clang-format runtime/vm

runtime/vm/regexp_parser.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_PARSER_H_
 #define RUNTIME_VM_REGEXP_PARSER_H_
 
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
 #include "vm/regexp_ast.h"
 
 namespace dart {
 
 // Accumulates RegExp atoms and assertions into lists of terms and alternatives.
-class RegExpBuilder: public ZoneAllocated {
+class RegExpBuilder : public ZoneAllocated {
  public:
   RegExpBuilder();
 
   void AddCharacter(uint16_t character);
   // "Adds" an empty expression. Does nothing except consume a
   // following quantifier
   void AddEmpty();
   void AddAtom(RegExpTree* tree);
   void AddAssertion(RegExpTree* tree);
   void NewAlternative();  // '|'
-  void AddQuantifierToAtom(
-      intptr_t min, intptr_t max, RegExpQuantifier::QuantifierType type);
+  void AddQuantifierToAtom(intptr_t min,
+                           intptr_t max,
+                           RegExpQuantifier::QuantifierType type);
   RegExpTree* ToRegExp();
 
  private:
   void FlushCharacters();
   void FlushText();
   void FlushTerms();
 
   Zone* zone() const { return zone_; }
 
   Zone* zone_;
   bool pending_empty_;
   ZoneGrowableArray<uint16_t>* characters_;
   GrowableArray<RegExpTree*> terms_;
   GrowableArray<RegExpTree*> text_;
   GrowableArray<RegExpTree*> alternatives_;
 #ifdef DEBUG
-  enum {ADD_NONE, ADD_CHAR, ADD_TERM, ADD_ASSERT, ADD_ATOM} last_added_;
+  enum { ADD_NONE, ADD_CHAR, ADD_TERM, ADD_ASSERT, ADD_ATOM } last_added_;
 #define LAST(x) last_added_ = x;
 #else
 #define LAST(x)
 #endif
 };
 
 class RegExpParser : public ValueObject {
  public:
-  RegExpParser(const String& in,
-               String* error,
-               bool multiline_mode);
+  RegExpParser(const String& in, String* error, bool multiline_mode);
 
   static bool ParseFunction(ParsedFunction* parsed_function);
 
   static bool ParseRegExp(const String& input,
                           bool multiline,
                           RegExpCompileData* result);
 
   RegExpTree* ParsePattern();
   RegExpTree* ParseDisjunction();
   RegExpTree* ParseGroup();
@@ skipping 23 matching lines @@
   void ReportError(const char* message);
   void Advance();
   void Advance(intptr_t dist);
   void Reset(intptr_t pos);
 
   // Reports whether the pattern might be used as a literal search string.
   // Only use if the result of the parse is a single atom node.
   bool simple();
   bool contains_anchor() { return contains_anchor_; }
   void set_contains_anchor() { contains_anchor_ = true; }
-  intptr_t captures_started() { return captures_ == NULL ?
-          0 : captures_->length(); }
+  intptr_t captures_started() {
+    return captures_ == NULL ? 0 : captures_->length();
+  }
   intptr_t position() { return next_pos_ - 1; }
   bool failed() { return failed_; }
 
   static const intptr_t kMaxCaptures = 1 << 16;
   static const uint32_t kEndMarker = (1 << 21);
 
  private:
   enum SubexpressionType {
     INITIAL,
     CAPTURE,  // All positive values represent captures.
     POSITIVE_LOOKAHEAD,
     NEGATIVE_LOOKAHEAD,
     GROUPING
   };
 
   class RegExpParserState : public ZoneAllocated {
    public:
     RegExpParserState(RegExpParserState* previous_state,
                       SubexpressionType group_type,
                       intptr_t disjunction_capture_index,
-                      Zone *zone)
+                      Zone* zone)
         : previous_state_(previous_state),
-          builder_(new(zone) RegExpBuilder()),
+          builder_(new (zone) RegExpBuilder()),
           group_type_(group_type),
           disjunction_capture_index_(disjunction_capture_index) {}
     // Parser state of containing expression, if any.
     RegExpParserState* previous_state() { return previous_state_; }
     bool IsSubexpression() { return previous_state_ != NULL; }
     // RegExpBuilder building this regexp's AST.
     RegExpBuilder* builder() { return builder_; }
     // Type of regexp being parsed (parenthesized group or entire regexp).
     SubexpressionType group_type() { return group_type_; }
     // Index in captures array of first capture in this sub-expression, if any.
@@ skipping 33 matching lines @@
   bool multiline_;
   bool simple_;
   bool contains_anchor_;
   bool is_scanned_for_captures_;
   bool failed_;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_REGEXP_PARSER_H_