* Use new RegExp parser.

regexp2000/src/jsregexp.h

 // 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 43 matching lines @@
   static Handle<Object> Exec(Handle<JSRegExp> regexp,
                              Handle<String> subject,
                              Handle<Object> index);
 
   // Call RegExp.prototyp.exec(string) in a loop.
   // Used by String.prototype.match and String.prototype.replace.
   // This function calls the garbage collector if necessary.
   static Handle<Object> ExecGlobal(Handle<JSRegExp> regexp,
                                    Handle<String> subject);
 
+  // Stores an uncompiled RegExp pattern in the JSRegExp object.
+  // It will be compiled by JSCRE when first executed.
+  static Handle<Object> JsrePrepare(Handle<JSRegExp> re,
+                                    Handle<String> pattern,
+                                    JSRegExp::Flags flags);
+
+  // Compile the pattern using JSCRE and store the result in the
+  // JSRegExp object.
+  static Handle<Object> JsreCompile(Handle<JSRegExp> re);
+
   static Handle<Object> AtomCompile(Handle<JSRegExp> re,
                                     Handle<String> pattern,
                                     JSRegExp::Flags flags);
-
   static Handle<Object> AtomExec(Handle<JSRegExp> regexp,
                                  Handle<String> subject,
                                  Handle<Object> index);
 
   static Handle<Object> AtomExecGlobal(Handle<JSRegExp> regexp,
                                        Handle<String> subject);
 
   static Handle<Object> JsreCompile(Handle<JSRegExp> re,
                                     Handle<String> pattern,
                                     JSRegExp::Flags flags);
 
+  // Execute a compiled JSCRE pattern.
   static Handle<Object> JsreExec(Handle<JSRegExp> regexp,
                                  Handle<String> subject,
                                  Handle<Object> index);
 
   static Handle<Object> JsreExecGlobal(Handle<JSRegExp> regexp,
                                        Handle<String> subject);
 
   static void NewSpaceCollectionPrologue();
   static void OldSpaceCollectionPrologue();
 
@@ skipping 98 matching lines @@
   static inline unsigned segment_of(uc16 value);
   static inline uc16 segment_start(unsigned segment);
 
  private:
   static const int kCharSize = 16;
   static const int kFieldSegmentIndexWidth = 10;
   static const int kFieldWidth = kCharSize - kFieldSegmentIndexWidth;
   static const int kFieldMax = (1 << kFieldWidth);
   static const int kSegmentMask = (1 << kFieldWidth) - 1;
   static const int kNibbleCount = kFieldMax / 4;
-  STATIC_ASSERT(kFieldMax == 8 * sizeof(uint64_t));
+  STATIC_CHECK(kFieldMax == 8 * sizeof(uint64_t));
 
   Type type() { return type_; }
 
   static inline uint64_t long_bit(int index) {
     return static_cast<uint64_t>(1) << index;
   }
 
   Type type_: 2;
   unsigned segment_ : 10;
   unsigned count_ : 4;
   union {
     // These have the same type to make it easier to change one without
     // touching the other.
     uint64_t u_field;
     uint64_t u_ranges;
     struct {
       CharacterClass* left;
       CharacterClass* right;
     } u_union;
   } data_;
 };
 
 
-STATIC_ASSERT(sizeof(CharacterClass) == 3 * kIntSize);
+STATIC_CHECK(sizeof(CharacterClass) == 3 * kIntSize);
 
 
 class CharacterClassAllocator {
  public:
   virtual CharacterClass* Allocate() = 0;
   virtual ~CharacterClassAllocator() { }
 };
 
 
 template <int kCount>
@@ skipping 13 matching lines @@
   static RegExpNode<Char>* Compile(RegExpTree* regexp);
 
   template <typename Char>
   static bool Execute(RegExpNode<Char>* start, Vector<Char> input);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSREGEXP_H_