Dispatch tables

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 244 matching lines @@
 
   uc32 ParseControlEscape(bool* ok);
   uc32 ParseOctalLiteral(bool* ok);
 
   // Tries to parse the input as a backreference.  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* ok);
+  CharacterRange ParseClassAtom(bool* is_char_class,
+                                ZoneList<CharacterRange>* ranges,
+                                bool* ok);
   RegExpTree* ReportError(Vector<const char> message, bool* ok);
   void Advance();
   void Advance(int dist);
   // Pushes a read character (or potentially some other character) back
   // on the input stream. After pushing it back, it becomes the character
   // returned by current(). There is a limited amount of push-back buffer.
   // A function using PushBack should check that it doesn't push back more
   // than kMaxPushback characters, and it should not push back more characters
   // than it has read, or that it knows had been read prior to calling it.
   void PushBack(uc32 character);
@@ skipping 3174 matching lines @@
     case '^':
       Advance();
       return new RegExpAssertion(
           multiline_mode_ ? RegExpAssertion::START_OF_LINE
                           : RegExpAssertion::START_OF_INPUT);
     case '$':
       Advance();
       return new RegExpAssertion(
           multiline_mode_ ? RegExpAssertion::END_OF_LINE
                           : RegExpAssertion::END_OF_INPUT);
-    case '.':
+    case '.': {
       Advance();
-      atom = new RegExpCharacterClass(CharacterRange::CharacterClass('.'));
+      ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2);
+      CharacterRange::AddClassEscape('.', ranges);
+      atom = new RegExpCharacterClass(ranges, false);
       break;
+    }
     case '(':
       atom = ParseGroup(CHECK_OK);
       break;
     case '[':
       atom = ParseCharacterClass(CHECK_OK);
       break;
     // Atom ::
     //   \ AtomEscape
     case '\\':
       if (has_next()) {
         switch (next()) {
           case 'b':
             Advance(2);
             return new RegExpAssertion(RegExpAssertion::BOUNDARY);
           case 'B':
             Advance(2);
             return new RegExpAssertion(RegExpAssertion::NON_BOUNDARY);
           // AtomEscape ::
           //   CharacterClassEscape
           //
           // CharacterClassEscape :: one of
           //   d D s S w W
           case 'd': case 'D': case 's': case 'S': case 'w': case 'W': {
             uc32 c = next();
+            ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2);
+            CharacterRange::AddClassEscape(c, ranges);
             Advance(2);
-            atom = new RegExpCharacterClass(CharacterRange::CharacterClass(c));
+            atom = new RegExpCharacterClass(ranges, false);
             goto has_read_atom;
           }
           case '1': case '2': case '3': case '4': case '5': case '6':
           case '7': case '8': case '9': {
             int index = 0;
             if (ParseBackreferenceIndex(&index)) {
               atom = new RegExpBackreference(index);
               goto has_read_atom;
             } else {
               // If this is not a backreference we go to the atom parser
@@ skipping 287 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* ok) {
+CharacterRange RegExpParser::ParseClassAtom(bool* is_char_class,
+                                            ZoneList<CharacterRange>* ranges,
+                                            bool* ok) {
+  ASSERT_EQ(false, *is_char_class);
   uc32 first = current();
   if (first == '\\') {
     switch (next()) {
       case 'b':
         Advance(2);
         return CharacterRange::Singleton('\b');
       case 'w': case 'W': case 'd': case 'D': case 's': case 'S': {
+        *is_char_class = true;
         uc32 c = next();
+        CharacterRange::AddClassEscape(c, ranges);
         Advance(2);
-        return CharacterRange::CharacterClass(c);
+        return NULL;
       }
       default:
         uc32 c = ParseCharacterEscape(CHECK_OK);
         return CharacterRange::Singleton(c);
     }
   } else {
     Advance();
     return CharacterRange::Singleton(first);
   }
 }
@@ skipping 10 matching lines @@
   if (current() == '^') {
     is_negated = true;
     Advance();
   }
   ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2);
   while (has_more() && current() != ']') {
     if (current() == '-') {
       Advance();
       ranges->Add(CharacterRange::Singleton('-'));
     } else {
-      CharacterRange first = ParseClassAtom(CHECK_OK);
-      if (!first.is_character_class() && current() == '-') {
-        Advance();
-        CharacterRange next = ParseClassAtom(CHECK_OK);
-        if (next.is_character_class()) {
-          return ReportError(CStrVector(kIllegal), CHECK_OK);
+      bool is_char_class = false;
+      CharacterRange first = ParseClassAtom(&is_char_class, ranges, CHECK_OK);
+      if (!is_char_class) {
+        if (current() == '-') {
+          Advance();
+          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 {
+          ranges->Add(first);
         }
-        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) {
     return RegExpEmpty::GetInstance();
   } else {
@@ skipping 112 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal