* Postponed irregexp parser forward scan of capturing parentheses until necessary.

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 532 matching lines @@
   FlatStringReader* in() { return in_; }
   void ScanForCaptures();
   bool CaptureAvailable(int index);
   uc32 current_;
   bool has_more_;
   bool multiline_mode_;
   int next_pos_;
   FlatStringReader* in_;
   Handle<String>* error_;
   bool has_character_escapes_;
+  ZoneList<RegExpCapture*>* captures_;
   bool is_scanned_for_captures_;
-  ZoneList<RegExpCapture*>* captures_;
+  // The capture count is only valid after we have scanned for captures.
   int capture_count_;
 };
 
 
 // A temporary scope stores information during parsing, just like
 // a plain scope.  However, temporary scopes are not kept around
 // after parsing or referenced by syntax trees so they can be stack-
 // allocated and hence used by the pre-parser.
 class TemporaryScope BASE_EMBEDDED {
  public:
@@ skipping 2934 matching lines @@
 RegExpParser::RegExpParser(FlatStringReader* in,
                            Handle<String>* error,
                            bool multiline_mode)
   : current_(kEndMarker),
     has_more_(true),
     multiline_mode_(multiline_mode),
     next_pos_(0),
     in_(in),
     error_(error),
     has_character_escapes_(false),
+    captures_(NULL),
     is_scanned_for_captures_(false),
-    captures_(NULL),
     capture_count_(0) {
   Advance(1);
 }
 
 
 uc32 RegExpParser::Next() {
   if (has_next()) {
     return in()->Get(next_pos_);
   } else {
     return kEndMarker;
@@ skipping 337 matching lines @@
 #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
+  int capture_count = captures_started();
+  // Add count of captures after this position.
   int n;
   while ((n = current()) != kEndMarker) {
     Advance();
     switch (n) {
       case '\\':
         Advance();
         break;
       case '[': {
         int c;
         while ((c = current()) != kEndMarker) {
           Advance();
           if (c == '\\') {
             Advance();
           } else {
             if (c == ']') break;
           }
         }
         break;
       }
       case '(':
-        if (current() != '?') capture_count_++;
+        if (current() != '?') capture_count++;
         break;
     }
   }
+  capture_count_ = capture_count;
   is_scanned_for_captures_ = true;
 }
 
 
 bool RegExpParser::ParseBackReferenceIndex(int* index_out) {
   ASSERT_EQ('\\', current());
   ASSERT('1' <= Next() && Next() <= '9');
   // Try to parse a decimal literal that is no greater than the number
   // of previously encountered left capturing parentheses.
   // This is a not according the the ECMAScript specification. According to
   // that, one must accept values up to the total number of left capturing
   // parentheses in the entire input, even if they are meaningless.
-  if (!is_scanned_for_captures_) {
-    int saved_position = position();
-    ScanForCaptures();
-    Reset(saved_position);
-  }
-  if (capture_count_ == 0) return false;
   int start = position();
   int value = Next() - '0';
-  if (value > capture_count_) return false;
   Advance(2);
   while (true) {
     uc32 c = current();
     if (IsDecimalDigit(c)) {
       value = 10 * value + (c - '0');
-      if (value > capture_count_) {
-        Reset(start);
-        return false;
-      }
       Advance();
     } else {
       break;
     }
   }
+  if (value > captures_started()) {
+    if (!is_scanned_for_captures_) {
+      int saved_position = position();
+      ScanForCaptures();
+      Reset(saved_position);
+    }
+    if (value > capture_count_) {
+      Reset(start);
+      return false;
+    }
+  }
   *index_out = value;
   return true;
 }
 
 
 // QuantifierPrefix ::
 //   { DecimalDigits }
 //   { DecimalDigits , }
 //   { DecimalDigits , DecimalDigits }
 bool RegExpParser::ParseIntervalQuantifier(int* min_out, int* max_out) {
@@ skipping 176 matching lines @@
         break;
       default:
         ReportError(CStrVector("Invalid group"), CHECK_OK);
         break;
     }
   } else {
     if (captures_ == NULL) {
       captures_ = new ZoneList<RegExpCapture*>(2);
     }
     captures_->Add(NULL);
-    if (!is_scanned_for_captures_) capture_count_++;
   }
   int capture_index = captures_started();
   RegExpTree* body = ParseDisjunction(CHECK_OK);
   if (current() != ')') {
     ReportError(CStrVector("Unterminated group"), CHECK_OK);
   }
   Advance();
 
   int end_capture_index = captures_started();
   if (type == '!') {
@@ skipping 222 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal