Experimental: Fixed bug in RegExp Parser. Added feature counting in parser.

regexp2000/src/jsregexp.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 186 matching lines @@
                                    Handle<String> flag_str) {
   JSRegExp::Flags flags = RegExpFlagsFromString(flag_str);
   Handle<FixedArray> cached = CompilationCache::LookupRegExp(pattern, flags);
   bool in_cache = !cached.is_null();
   Handle<Object> result;
   StringShape shape(*pattern);
   if (in_cache) {
     re->set_data(*cached);
     result = re;
   } else {
-    SafeStringInputBuffer buffer(pattern.location());
+     SafeStringInputBuffer buffer(pattern.location());
     Handle<String> error_text;
-    RegExpTree* ast = ParseRegExp(&buffer, &error_text);
+    bool has_escapes;
+    RegExpTree* ast = ParseRegExp(&buffer, &error_text, &has_escapes);
     if (!error_text.is_null()) {
       // Throw an exception if we fail to parse the pattern.
       return CreateRegExpException(re, pattern, error_text, "malformed_regexp");
     }
     RegExpAtom* atom = ast->AsAtom();
     if (atom != NULL && !flags.is_ignore_case()) {
-      Vector<const uc16> atom_pattern = atom->data();
-      // Test if pattern equals atom_pattern and reuse pattern if it does.
-      Handle<String> atom_string = Factory::NewStringFromTwoByte(atom_pattern);
-      result = AtomCompile(re, atom_string, flags);
+      if (has_escapes) {
+        Vector<const uc16> atom_pattern = atom->data();
+        Handle<String> atom_string =
+            Factory::NewStringFromTwoByte(atom_pattern);
+        result = AtomCompile(re, pattern, flags, atom_string);
+      } else {
+        result = AtomCompile(re, pattern, flags, pattern);
+      }
     } else {
       result = JsrePrepare(re, pattern, flags);
     }
     Object* data = re->data();
     if (data->IsFixedArray()) {
       // If compilation succeeded then the data is set on the regexp
       // and we can store it in the cache.
       Handle<FixedArray> data(FixedArray::cast(re->data()));
       CompilationCache::PutRegExp(pattern, flags, data);
     }
@@ skipping 28 matching lines @@
       return AtomExecGlobal(regexp, subject);
     default:
       UNREACHABLE();
       return Handle<Object>();
   }
 }
 
 
 Handle<Object> RegExpImpl::AtomCompile(Handle<JSRegExp> re,
                                        Handle<String> pattern,
-                                       JSRegExp::Flags flags) {
-  Factory::SetRegExpData(re, JSRegExp::ATOM, pattern, flags, pattern);
+                                       JSRegExp::Flags flags,
+                                       Handle<String> match_pattern) {
+  Factory::SetRegExpData(re, JSRegExp::ATOM, pattern, flags, match_pattern);
   return re;
 }
 
 
 Handle<Object> RegExpImpl::AtomExec(Handle<JSRegExp> re,
                                     Handle<String> subject,
                                     Handle<Object> index) {
   Handle<String> needle(String::cast(re->DataAt(JSRegExp::kAtomPatternIndex)));
 
   uint32_t start_index;
@@ skipping 656 matching lines @@
   for (int i = 0; i < elmc; i += 2) {
     ASSERT(last <= elmv[i] - 1);
     ASSERT(elmv[i] <= elmv[i + 1]);
     ranges->Add(CharacterRange(last, elmv[i] - 1));
     last = elmv[i + 1] + 1;
   }
   ranges->Add(CharacterRange(last, 0xFFFF));
 }
 
 
-void CharacterRange::AddClassEscape(uc16 type, ZoneList<CharacterRange>* ranges) {
+void CharacterRange::AddClassEscape(uc16 type,
+                                    ZoneList<CharacterRange>* ranges) {
   switch (type) {
     case 's':
       AddClass(kSpaceRanges, kSpaceRangeCount, ranges);
       break;
     case 'S':
       AddClassNegated(kSpaceRanges, kSpaceRangeCount, ranges);
       break;
     case 'w':
       AddClass(kWordRanges, kWordRangeCount, ranges);
       break;
@@ skipping 339 matching lines @@
 template
 bool RegExpEngine::Execute<const char>(RegExpNode<const char>* start,
                                        Vector<const char> input);
 
 template
 bool RegExpEngine::Execute<const uc16>(RegExpNode<const uc16>* start,
                                        Vector<const uc16> input);
 
 
 }}  // namespace v8::internal