Bugfixes

src/parser.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 302 matching lines @@
   // following quantifier
   void AddEmpty();
   void AddAtom(RegExpTree* tree);
   void AddAssertion(RegExpTree* tree);
   void NewAlternative();  // '|'
   void AddQuantifierToAtom(int min, int max, bool is_greedy);
   RegExpTree* ToRegExp();
  private:
   void FlushCharacters();
   void FlushText();
-  bool FlushTerms();
+  void FlushTerms();
   bool pending_empty_;
   ZoneList<uc16>* characters_;
   BufferedZoneList<RegExpTree, 2> terms_;
   BufferedZoneList<RegExpTree, 2> text_;
   BufferedZoneList<RegExpTree, 2> alternatives_;
 #ifdef DEBUG
   enum {ADD_NONE, ADD_CHAR, ADD_TERM, ADD_ASSERT, ADD_ATOM} last_added_;
 #define LAST(x) last_added_ = x;
 #else
 #define LAST(x)
@@ skipping 69 matching lines @@
 
 
 void RegExpBuilder::AddAssertion(RegExpTree* assert) {
   FlushText();
   terms_.Add(assert);
   LAST(ADD_ASSERT);
 }
 
 
 void RegExpBuilder::NewAlternative() {
-  if (!FlushTerms()) {
-    alternatives_.Add(RegExpEmpty::GetInstance());
-  }
+  FlushTerms();
 }
 
 
-bool RegExpBuilder::FlushTerms() {
+void RegExpBuilder::FlushTerms() {
   FlushText();
   int num_terms = terms_.length();
+  RegExpTree* alternative;
   if (num_terms == 0) {
-    return false;
-  }
-  RegExpTree* alternative;
-  if (num_terms == 1) {
+    alternative = RegExpEmpty::GetInstance();
+  } else if (num_terms == 1) {
     alternative = terms_.last();
   } else {
     alternative = new RegExpAlternative(terms_.GetList());
   }
   alternatives_.Add(alternative);
   terms_.Clear();
   LAST(ADD_NONE);
-  return true;
 }
 
 
 RegExpTree* RegExpBuilder::ToRegExp() {
   FlushTerms();
   int num_alternatives = alternatives_.length();
   if (num_alternatives == 0) {
     return RegExpEmpty::GetInstance();
   }
   if (num_alternatives == 1) {
@@ skipping 54 matching lines @@
   RegExpParser(FlatStringReader* in,
                Handle<String>* error,
                bool multiline_mode);
   RegExpTree* ParsePattern(bool* ok);
   RegExpTree* ParseDisjunction(bool* ok);
   RegExpTree* ParseGroup(bool* ok);
   RegExpTree* ParseCharacterClass(bool* ok);
 
   // Parses a {...,...} quantifier and stores the range in the given
   // out parameters.
-  void* ParseIntervalQuantifier(int* min_out, int* max_out, bool* ok);
+  bool ParseIntervalQuantifier(int* min_out, int* max_out);
 
   // Parses and returns a single escaped character.  The character
   // must not be 'b' or 'B' since they are usually handle specially.
   uc32 ParseClassCharacterEscape(bool* ok);
 
   // Checks whether the following is a length-digit hexadecimal number,
   // and sets the value if it is.
   bool ParseHexEscape(int length, uc32* value);
 
   uc32 ParseControlLetterEscape(bool* ok);
@@ skipping 11 matching lines @@
   RegExpTree* ReportError(Vector<const char> message, bool* ok);
   void Advance();
   void Advance(int dist);
   void Reset(int pos);
 
   bool HasCharacterEscapes();
 
   int captures_started() { return captures_ == NULL ? 0 : captures_->length(); }
   int position() { return next_pos_ - 1; }
 
-  static const uc32 kEndMarker = unibrow::Utf8::kBadChar;
+  static const uc32 kEndMarker = (1 << 21);
  private:
   uc32 current() { return current_; }
   bool has_more() { return has_more_; }
   bool has_next() { return next_pos_ < in()->length(); }
   uc32 Next();
   FlatStringReader* in() { return in_; }
   uc32 current_;
   bool has_more_;
   bool multiline_mode_;
   int next_pos_;
@@ skipping 3043 matching lines @@
         if (capture->available() == CAPTURE_AVAILABLE) {
           capture->set_available(CAPTURE_UNREACHABLE);
         }
       }
       capture_start_index = capture_new_alt_start_index;
       continue;
     }
     case '*':
     case '+':
     case '?':
-    case '{':
-      ReportError(CStrVector("Nothing to repeat."), CHECK_OK);
+      ReportError(CStrVector("Nothing to repeat"), CHECK_OK);
     case '^': {
       Advance();
       RegExpAssertion::Type type =
           multiline_mode_ ? RegExpAssertion::START_OF_LINE :
                             RegExpAssertion::START_OF_INPUT;
       builder.AddAssertion(new RegExpAssertion(type));
       continue;
     }
     case '$': {
       Advance();
@@ skipping 130 matching lines @@
         break;
       }
       default:
         // Identity escape.
         builder.AddCharacter(Next());
         Advance(2);
         break;
       }
       has_character_escapes_ = true;
       break;
+    case '{': {
+      int dummy;
+      if (ParseIntervalQuantifier(&dummy, &dummy)) {
+        ReportError(CStrVector("Nothing to repeat"), CHECK_OK);
+      }
+      // fallthrough
+    }
     default:
       builder.AddCharacter(current());
       Advance();
       break;
     }  // end switch(current())
 
-    has_read_atom:
+   has_read_atom:
     int min;
     int max;
     switch (current()) {
     // QuantifierPrefix ::
     //   *
     //   +
     //   ?
     //   {
     case '*':
       min = 0;
       max = RegExpQuantifier::kInfinity;
       Advance();
       break;
     case '+':
       min = 1;
       max = RegExpQuantifier::kInfinity;
       Advance();
       break;
     case '?':
       min = 0;
       max = 1;
       Advance();
       break;
     case '{':
-      ParseIntervalQuantifier(&min, &max, CHECK_OK);
-      break;
+      if (ParseIntervalQuantifier(&min, &max)) {
+        break;
+      } else {
+        continue;
+      }
     default:
       continue;
     }
     bool is_greedy = true;
     if (current() == '?') {
       is_greedy = false;
       Advance();
     }
     builder.AddQuantifierToAtom(min, max, is_greedy);
   }
@@ skipping 69 matching lines @@
   }
   *index_out = value;
   return true;
 }
 
 
 // QuantifierPrefix ::
 //   { DecimalDigits }
 //   { DecimalDigits , }
 //   { DecimalDigits , DecimalDigits }
-void* RegExpParser::ParseIntervalQuantifier(int* min_out,
-                                            int* max_out,
-                                            bool* ok) {
+bool RegExpParser::ParseIntervalQuantifier(int* min_out, int* max_out) {
   ASSERT_EQ(current(), '{');
-  static const char* kInvalidQuantifier = "Invalid quantifier";
+  int start = position();
   Advance();
   int min = 0;
   if (!IsDecimalDigit(current())) {
-    // JSC allows {} and {,} as quantifiers (and { and } and all
-    // sorts of crazy stuff) but my puny human brain has been unable
-    // to figure out what they mean exactly, if anything.  For now
-    // we follow the spec and report a syntax error.
-    ReportError(CStrVector(kInvalidQuantifier), CHECK_OK);
+    Reset(start);
+    return false;
   }
   while (IsDecimalDigit(current())) {
     min = 10 * min + (current() - '0');
     Advance();
   }
   int max = 0;
   if (current() == '}') {
     max = min;
     Advance();
   } else if (current() == ',') {
     Advance();
     if (current() == '}') {
       max = RegExpQuantifier::kInfinity;
       Advance();
     } else {
       while (IsDecimalDigit(current())) {
         max = 10 * max + (current() - '0');
         Advance();
       }
       if (current() != '}') {
-        ReportError(CStrVector(kInvalidQuantifier), CHECK_OK);
+        Reset(start);
+        return false;
       }
       Advance();
     }
   } else {
-    ReportError(CStrVector(kInvalidQuantifier), CHECK_OK);
+    Reset(start);
+    return false;
   }
   *min_out = min;
   *max_out = max;
-  return NULL;
+  return true;
 }
 
 
 // Upper and lower case letters differ by one bit.
 STATIC_CHECK(('a' ^ 'A') == 0x20);
 
 uc32 RegExpParser::ParseControlLetterEscape(bool* ok) {
   if (!has_more()) {
     ReportError(CStrVector("\\c at end of pattern"), ok);
     return '\0';
@@ skipping 213 matching lines @@
     is_negated = true;
     Advance();
   }
   ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2);
   while (has_more() && current() != ']') {
     bool is_char_class = false;
     CharacterRange first = ParseClassAtom(&is_char_class, ranges, CHECK_OK);
     if (!is_char_class) {
       if (current() == '-') {
         Advance();
-        if (current() == ']') {
+        if (current() == kEndMarker) {
+          // If we reach the end we break out of the loop and let the
+          // following code report an error.
+          break;
+        } else if (current() == ']') {
           ranges->Add(first);
           ranges->Add(CharacterRange::Singleton('-'));
           break;
         }
         CharacterRange next =
             ParseClassAtom(&is_char_class, ranges, CHECK_OK);
         if (is_char_class) {
           return ReportError(CStrVector(kIllegal), CHECK_OK);
         }
         if (first.from() > next.to()) {
@@ skipping 131 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal