Allow [a-\d] in RegExp parser.

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 503 matching lines @@
 
   uc32 ParseControlLetterEscape(bool* ok);
   uc32 ParseOctalLiteral();
 
   // Tries to parse the input as a back reference.  If successful it
   // stores the result in the output parameter and returns true.  If
   // it fails it will push back the characters read so the same characters
   // can be reparsed.
   bool ParseBackReferenceIndex(int* index_out);
 
-  CharacterRange ParseClassAtom(bool* is_char_class,
-                                ZoneList<CharacterRange>* ranges,
+  CharacterRange ParseClassAtom(uc16* is_char_class,
                                 bool* ok);
   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; }
@@ skipping 3615 matching lines @@
   } else if (type == ':') {
     return body;
   } else {
     ASSERT(type == '=' || type == '!');
     bool is_positive = (type == '=');
     return new RegExpLookahead(body, is_positive);
   }
 }
 
 
-CharacterRange RegExpParser::ParseClassAtom(bool* is_char_class,
-                                            ZoneList<CharacterRange>* ranges,
-                                            bool* ok) {
-  ASSERT_EQ(false, *is_char_class);
+CharacterRange RegExpParser::ParseClassAtom(uc16* char_class, bool* ok) {
+  ASSERT_EQ(0, *char_class);
   uc32 first = current();
   if (first == '\\') {
     switch (Next()) {
       case 'w': case 'W': case 'd': case 'D': case 's': case 'S': {
-        *is_char_class = true;
-        uc32 c = Next();
-        CharacterRange::AddClassEscape(c, ranges);
+        *char_class = Next();
         Advance(2);
-        return NULL;
+        return CharacterRange::Singleton(0);
       }
       default:
         uc32 c = ParseClassCharacterEscape(CHECK_OK);
         return CharacterRange::Singleton(c);
     }
   } else {
     Advance();
     return CharacterRange::Singleton(first);
   }
 }
 
 
 RegExpTree* RegExpParser::ParseCharacterClass(bool* ok) {
   static const char* kUnterminated = "Unterminated character class";
-  static const char* kIllegal = "Illegal character class";
   static const char* kRangeOutOfOrder = "Range out of order in character class";
 
   ASSERT_EQ(current(), '[');
   Advance();
   bool is_negated = false;
   if (current() == '^') {
     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() == 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()) {
-          return ReportError(CStrVector(kRangeOutOfOrder), CHECK_OK);
-        }
-        ranges->Add(CharacterRange::Range(first.from(), next.to()));
-      } else {
+    uc16 char_class = 0;
+    CharacterRange first = ParseClassAtom(&char_class, CHECK_OK);
+    if (char_class) {
+      CharacterRange::AddClassEscape(char_class, ranges);
+      continue;
+    }
+    if (current() == '-') {
+      Advance();
+      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(&char_class, CHECK_OK);
+      if (char_class) {
+        ranges->Add(first);
+        ranges->Add(CharacterRange::Singleton('-'));
+        CharacterRange::AddClassEscape(char_class, ranges);
+        continue;
+      }
+      if (first.from() > next.to()) {
+        return ReportError(CStrVector(kRangeOutOfOrder), CHECK_OK);
+      }
+      ranges->Add(CharacterRange::Range(first.from(), next.to()));
+    } else {
+      ranges->Add(first);
     }
   }
   if (!has_more()) {
     return ReportError(CStrVector(kUnterminated), CHECK_OK);
   }
   Advance();
   if (ranges->length() == 0) {
     ranges->Add(CharacterRange::Range(0, 0xffff));
     is_negated = !is_negated;
   }
@@ skipping 116 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal