Experimental regexp: Use new RegExp parser to test syntax.

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 21 matching lines @@
 #include "ast.h"
 #include "execution.h"
 #include "factory.h"
 #include "jsregexp.h"
 #include "third_party/jscre/pcre.h"
 #include "platform.h"
 #include "runtime.h"
 #include "top.h"
 #include "compilation-cache.h"
 #include "string-stream.h"
-
+#include "parser.h"
 
 namespace v8 { namespace internal {
 
 
 #define CAPTURE_INDEX 0
 #define INTERNAL_INDEX 1
 
 static Failure* malloc_failure;
 
 static void* JSREMalloc(size_t size) {
@@ skipping 108 matching lines @@
         break;
       case 'm':
         flags |= JSRegExp::MULTILINE;
         break;
     }
   }
   return JSRegExp::Flags(flags);
 }
 
 
+static inline Handle<Object> CreateRegExpException(Handle<JSRegExp> re,
+                                                   Handle<String> pattern,
+                                                   Handle<String> error_text,
+                                                   const char* message) {
+  Handle<JSArray> array = Factory::NewJSArray(2);
+  SetElement(array, 0, pattern);
+  SetElement(array, 1, error_text);
+  Handle<Object> regexp_err = Factory::NewSyntaxError(message, array);
+  return Handle<Object>(Top::Throw(*regexp_err));
+}
+
+
 unibrow::Predicate<unibrow::RegExpSpecialChar, 128> is_reg_exp_special_char;
 
-
 Handle<Object> RegExpImpl::Compile(Handle<JSRegExp> re,
                                    Handle<String> pattern,
                                    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;
   if (in_cache) {
     re->set_data(*cached);
     result = re;
   } else {
-    bool is_atom = !flags.is_ignore_case();
-    for (int i = 0; is_atom && i < pattern->length(); i++) {
-      if (is_reg_exp_special_char.get(pattern->Get(i)))
-        is_atom = false;
+    SafeStringInputBuffer buffer(pattern.location());
+    Handle<String> error_text;
+    RegExpTree* ast = ParseRegExp(&buffer, &error_text);
+    if (!error_text.is_null()) {
+      // Throw an exception if we fail to parse the pattern.
+      return CreateRegExpException(re, pattern, error_text, "malformed_regexp");
     }
-    if (is_atom) {
-      result = AtomCompile(re, pattern, flags);
+
+    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);
     } else {
       result = JsreCompile(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 29 matching lines @@
     default:
       UNREACHABLE();
       return Handle<Object>();
   }
 }
 
 
 Handle<Object> RegExpImpl::AtomCompile(Handle<JSRegExp> re,
                                        Handle<String> pattern,
                                        JSRegExp::Flags flags) {
+  ASSERT(!flags.is_ignore_case());
   Factory::SetRegExpData(re, JSRegExp::ATOM, pattern, flags, 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)));
 
@@ skipping 48 matching lines @@
     index = end;
     if (needle_length == 0) index++;
   }
   return result;
 }
 
 
 Handle<Object> RegExpImpl::JsreCompile(Handle<JSRegExp> re,
                                        Handle<String> pattern,
                                        JSRegExp::Flags flags) {
+  // Change this to not compile immediately, but defer the compilation
+  // until the first execution.
   JSRegExpIgnoreCaseOption case_option = flags.is_ignore_case()
     ? JSRegExpIgnoreCase
     : JSRegExpDoNotIgnoreCase;
   JSRegExpMultilineOption multiline_option = flags.is_multiline()
     ? JSRegExpMultiline
     : JSRegExpSingleLine;
 
   Handle<String> two_byte_pattern = StringToTwoByte(pattern);
 
   unsigned number_of_captures;
@@ skipping 702 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