VM: Re-format to use at most one newline between functions

runtime/vm/regexp_parser.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_parser.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
-#include "vm/regexp_parser.h"
 
 namespace dart {
 
 #define Z zone()
 
 // Enables possessive quantifier syntax for testing.
 static const bool FLAG_regexp_possessive_quantifier = false;
 
 RegExpBuilder::RegExpBuilder()
     : zone_(Thread::Current()->zone()),
       pending_empty_(false),
       characters_(NULL),
       terms_(),
       text_(),
       alternatives_()
 #ifdef DEBUG
       ,
       last_added_(ADD_NONE)
 #endif
 {
 }
 
-
 void RegExpBuilder::FlushCharacters() {
   pending_empty_ = false;
   if (characters_ != NULL) {
     RegExpTree* atom = new (Z) RegExpAtom(characters_);
     characters_ = NULL;
     text_.Add(atom);
     LAST(ADD_ATOM);
   }
 }
 
-
 void RegExpBuilder::FlushText() {
   FlushCharacters();
   intptr_t num_text = text_.length();
   if (num_text == 0) {
     return;
   } else if (num_text == 1) {
     terms_.Add(text_.Last());
   } else {
     RegExpText* text = new (Z) RegExpText();
     for (intptr_t i = 0; i < num_text; i++)
       text_[i]->AppendToText(text);
     terms_.Add(text);
   }
   text_.Clear();
 }
 
-
 void RegExpBuilder::AddCharacter(uint16_t c) {
   pending_empty_ = false;
   if (characters_ == NULL) {
     characters_ = new (Z) ZoneGrowableArray<uint16_t>(4);
   }
   characters_->Add(c);
   LAST(ADD_CHAR);
 }
 
-
 void RegExpBuilder::AddEmpty() {
   pending_empty_ = true;
 }
 
-
 void RegExpBuilder::AddAtom(RegExpTree* term) {
   if (term->IsEmpty()) {
     AddEmpty();
     return;
   }
   if (term->IsTextElement()) {
     FlushCharacters();
     text_.Add(term);
   } else {
     FlushText();
     terms_.Add(term);
   }
   LAST(ADD_ATOM);
 }
 
-
 void RegExpBuilder::AddAssertion(RegExpTree* assert) {
   FlushText();
   terms_.Add(assert);
   LAST(ADD_ASSERT);
 }
 
-
 void RegExpBuilder::NewAlternative() {
   FlushTerms();
 }
 
-
 void RegExpBuilder::FlushTerms() {
   FlushText();
   intptr_t num_terms = terms_.length();
   RegExpTree* alternative;
   if (num_terms == 0) {
     alternative = RegExpEmpty::GetInstance();
   } else if (num_terms == 1) {
     alternative = terms_.Last();
   } else {
     ZoneGrowableArray<RegExpTree*>* terms =
         new (Z) ZoneGrowableArray<RegExpTree*>();
     for (intptr_t i = 0; i < terms_.length(); i++) {
       terms->Add(terms_[i]);
     }
     alternative = new (Z) RegExpAlternative(terms);
   }
   alternatives_.Add(alternative);
   terms_.Clear();
   LAST(ADD_NONE);
 }
 
-
 RegExpTree* RegExpBuilder::ToRegExp() {
   FlushTerms();
   intptr_t num_alternatives = alternatives_.length();
   if (num_alternatives == 0) {
     return RegExpEmpty::GetInstance();
   }
   if (num_alternatives == 1) {
     return alternatives_.Last();
   }
   ZoneGrowableArray<RegExpTree*>* alternatives =
       new (Z) ZoneGrowableArray<RegExpTree*>();
   for (intptr_t i = 0; i < alternatives_.length(); i++) {
     alternatives->Add(alternatives_[i]);
   }
   return new (Z) RegExpDisjunction(alternatives);
 }
 
-
 void RegExpBuilder::AddQuantifierToAtom(
     intptr_t min,
     intptr_t max,
     RegExpQuantifier::QuantifierType quantifier_type) {
   if (pending_empty_) {
     pending_empty_ = false;
     return;
   }
   RegExpTree* atom;
   if (characters_ != NULL) {
@@ skipping 56 matching lines @@
       capture_count_(0),
       has_more_(true),
       multiline_(multiline),
       simple_(false),
       contains_anchor_(false),
       is_scanned_for_captures_(false),
       failed_(false) {
   Advance();
 }
 
-
 uint32_t RegExpParser::Next() {
   if (has_next()) {
     return in().CharAt(next_pos_);
   } else {
     return kEndMarker;
   }
 }
 
-
 void RegExpParser::Advance() {
   if (next_pos_ < in().Length()) {
     current_ = in().CharAt(next_pos_);
     next_pos_++;
   } else {
     current_ = kEndMarker;
     has_more_ = false;
   }
 }
 
-
 void RegExpParser::Reset(intptr_t pos) {
   next_pos_ = pos;
   has_more_ = (pos < in().Length());
   Advance();
 }
 
-
 void RegExpParser::Advance(intptr_t dist) {
   next_pos_ += dist - 1;
   Advance();
 }
 
-
 bool RegExpParser::simple() {
   return simple_;
 }
 
-
 void RegExpParser::ReportError(const char* message) {
   failed_ = true;
   *error_ = String::New(message);
   // Zip to the end to make sure the no more input is read.
   current_ = kEndMarker;
   next_pos_ = in().Length();
 
   const Error& error = Error::Handle(LanguageError::New(*error_));
   Report::LongJump(error);
   UNREACHABLE();
 }
 
-
 // Pattern ::
 //   Disjunction
 RegExpTree* RegExpParser::ParsePattern() {
   RegExpTree* result = ParseDisjunction();
   ASSERT(!has_more());
   // If the result of parsing is a literal string atom, and it has the
   // same length as the input, then the atom is identical to the input.
   if (result->IsAtom() && result->AsAtom()->length() == in().Length()) {
     simple_ = true;
   }
   return result;
 }
 
-
 // Disjunction ::
 //   Alternative
 //   Alternative | Disjunction
 // Alternative ::
 //   [empty]
 //   Term Alternative
 // Term ::
 //   Assertion
 //   Atom
 //   Atom Quantifier
@@ skipping 331 matching lines @@
       Advance();
     } else if (FLAG_regexp_possessive_quantifier && current() == '+') {
       // FLAG_regexp_possessive_quantifier is a debug-only flag.
       quantifier_type = RegExpQuantifier::POSSESSIVE;
       Advance();
     }
     builder->AddQuantifierToAtom(min, max, quantifier_type);
   }
 }
 
-
 #ifdef DEBUG
 // Currently only used in an ASSERT.
 static bool IsSpecialClassEscape(uint32_t c) {
   switch (c) {
     case 'd':
     case 'D':
     case 's':
     case 'S':
     case 'w':
     case 'W':
       return true;
     default:
       return false;
   }
 }
 #endif
 
-
 // In order to know whether an escape is a backreference or not we have to scan
 // the entire regexp and find the number of capturing parentheses.  However we
 // don't want to scan the regexp twice unless it is necessary.  This mini-parser
 // is called when needed.  It can see the difference between capturing and
 // noncapturing parentheses and can skip character classes and backslash-escaped
 // characters.
 void RegExpParser::ScanForCaptures() {
   // Start with captures started previous to current position
   intptr_t capture_count = captures_started();
   // Add count of captures after this position.
@@ skipping 18 matching lines @@
       }
       case '(':
         if (current() != '?') capture_count++;
         break;
     }
   }
   capture_count_ = capture_count;
   is_scanned_for_captures_ = true;
 }
 
-
 static inline bool IsDecimalDigit(int32_t c) {
   return '0' <= c && c <= '9';
 }
 
-
 bool RegExpParser::ParseBackReferenceIndex(intptr_t* index_out) {
   ASSERT('\\' == current());
   ASSERT('1' <= Next() && Next() <= '9');
   // Try to parse a decimal literal that is no greater than the total number
   // of left capturing parentheses in the input.
   intptr_t start = position();
   intptr_t value = Next() - '0';
   Advance(2);
   while (true) {
     uint32_t c = current();
@@ skipping 16 matching lines @@
     }
     if (value > capture_count_) {
       Reset(start);
       return false;
     }
   }
   *index_out = value;
   return true;
 }
 
-
 // QuantifierPrefix ::
 //   { DecimalDigits }
 //   { DecimalDigits , }
 //   { DecimalDigits , DecimalDigits }
 //
 // Returns true if parsing succeeds, and set the min_out and max_out
 // values. Values are truncated to RegExpTree::kInfinity if they overflow.
 bool RegExpParser::ParseIntervalQuantifier(intptr_t* min_out,
                                            intptr_t* max_out) {
   ASSERT(current() == '{');
@@ skipping 47 matching lines @@
     }
   } else {
     Reset(start);
     return false;
   }
   *min_out = min;
   *max_out = max;
   return true;
 }
 
-
 uint32_t RegExpParser::ParseOctalLiteral() {
   ASSERT(('0' <= current() && current() <= '7') || current() == kEndMarker);
   // For compatibility with some other browsers (not all), we parse
   // up to three octal digits with a value below 256.
   uint32_t value = current() - '0';
   Advance();
   if ('0' <= current() && current() <= '7') {
     value = value * 8 + current() - '0';
     Advance();
     if (value < 32 && '0' <= current() && current() <= '7') {
       value = value * 8 + current() - '0';
       Advance();
     }
   }
   return value;
 }
 
-
 // Returns the value (0 .. 15) of a hexadecimal character c.
 // If c is not a legal hexadecimal character, returns a value < 0.
 static inline intptr_t HexValue(uint32_t c) {
   c -= '0';
   if (static_cast<unsigned>(c) <= 9) return c;
   c = (c | 0x20) - ('a' - '0');  // detect 0x11..0x16 and 0x31..0x36.
   if (static_cast<unsigned>(c) <= 5) return c + 10;
   return -1;
 }
 
-
 bool RegExpParser::ParseHexEscape(intptr_t length, uint32_t* value) {
   intptr_t start = position();
   uint32_t val = 0;
   bool done = false;
   for (intptr_t i = 0; !done; i++) {
     uint32_t c = current();
     intptr_t d = HexValue(c);
     if (d < 0) {
       Reset(start);
       return false;
     }
     val = val * 16 + d;
     Advance();
     if (i == length - 1) {
       done = true;
     }
   }
   *value = val;
   return true;
 }
 
-
 uint32_t RegExpParser::ParseClassCharacterEscape() {
   ASSERT(current() == '\\');
   DEBUG_ASSERT(has_next() && !IsSpecialClassEscape(Next()));
   Advance();
   switch (current()) {
     case 'b':
       Advance();
       return '\b';
     // ControlEscape :: one of
     //   f n r t v
@@ skipping 65 matching lines @@
       // been matched by a more specific case, not just the subset required
       // by the ECMAScript specification.
       uint32_t result = current();
       Advance();
       return result;
     }
   }
   return 0;
 }
 
-
 CharacterRange RegExpParser::ParseClassAtom(uint16_t* char_class) {
   ASSERT(0 == *char_class);
   uint32_t first = current();
   if (first == '\\') {
     switch (Next()) {
       case 'w':
       case 'W':
       case 'd':
       case 'D':
       case 's':
       case 'S': {
         *char_class = Next();
         Advance(2);
         return CharacterRange::Singleton(0);  // Return dummy value.
       }
       case kEndMarker:
         ReportError("\\ at end of pattern");
         UNREACHABLE();
       default:
         uint32_t c = ParseClassCharacterEscape();
         return CharacterRange::Singleton(c);
     }
   } else {
     Advance();
     return CharacterRange::Singleton(first);
   }
 }
 
-
 static const uint16_t kNoCharClass = 0;
 
 // Adds range or pre-defined character class to character ranges.
 // If char_class is not kInvalidClass, it's interpreted as a class
 // escape (i.e., 's' means whitespace, from '\s').
 static inline void AddRangeOrEscape(ZoneGrowableArray<CharacterRange>* ranges,
                                     uint16_t char_class,
                                     CharacterRange range) {
   if (char_class != kNoCharClass) {
     CharacterRange::AddClassEscape(char_class, ranges);
   } else {
     ranges->Add(range);
   }
 }
 
-
 RegExpTree* RegExpParser::ParseCharacterClass() {
   static const char* kUnterminated = "Unterminated character class";
   static const char* kRangeOutOfOrder = "Range out of order in character class";
 
   ASSERT(current() == '[');
   Advance();
   bool is_negated = false;
   if (current() == '^') {
     is_negated = true;
     Advance();
@@ skipping 37 matching lines @@
     UNREACHABLE();
   }
   Advance();
   if (ranges->length() == 0) {
     ranges->Add(CharacterRange::Everything());
     is_negated = !is_negated;
   }
   return new (Z) RegExpCharacterClass(ranges, is_negated);
 }
 
-
 // ----------------------------------------------------------------------------
 // The Parser interface.
 
 bool RegExpParser::ParseRegExp(const String& input,
                                bool multiline,
                                RegExpCompileData* result) {
   ASSERT(result != NULL);
   LongJumpScope jump;
   RegExpParser parser(input, &result->error, multiline);
   if (setjmp(*jump.Set()) == 0) {
@@ skipping 14 matching lines @@
         String::Handle(String::Concat(result->error, input));
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, message);
 
     Exceptions::ThrowByType(Exceptions::kFormat, args);
   }
   return !parser.failed();
 }
 
 }  // namespace dart