Wire Regexp2000 up to the normal JS RegExp object.

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 45 matching lines @@
                              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,
+  static Handle<Object> JscrePrepare(Handle<JSRegExp> re,
+                                     Handle<String> pattern,
+                                     JSRegExp::Flags flags);
+
+  // Stores a compiled RegExp pattern in the JSRegExp object.
+  // The pattern is compiled by Regexp2000.
+  static Handle<Object> Re2kPrepare(Handle<JSRegExp> re,
                                     Handle<String> pattern,
-                                    JSRegExp::Flags flags);
+                                    JSRegExp::Flags flags,
+                                    Handle<FixedArray> re2k_data);
+
 
   // Compile the pattern using JSCRE and store the result in the
   // JSRegExp object.
-  static Handle<Object> JsreCompile(Handle<JSRegExp> re);
+  static Handle<Object> JscreCompile(Handle<JSRegExp> re);
 
   static Handle<Object> AtomCompile(Handle<JSRegExp> re,
                                     Handle<String> pattern,
                                     JSRegExp::Flags flags,
                                     Handle<String> match_pattern);
   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);
+  static Handle<Object> JscreCompile(Handle<JSRegExp> re,
+                                     Handle<String> pattern,
+                                     JSRegExp::Flags flags);
 
   // Execute a compiled JSCRE pattern.
-  static Handle<Object> JsreExec(Handle<JSRegExp> regexp,
+  static Handle<Object> JscreExec(Handle<JSRegExp> regexp,
+                                  Handle<String> subject,
+                                  Handle<Object> index);
+
+  // Execute a Regexp2000 bytecode pattern.
+  static Handle<Object> Re2kExec(Handle<JSRegExp> regexp,
                                  Handle<String> subject,
                                  Handle<Object> index);
 
-  static Handle<Object> JsreExecGlobal(Handle<JSRegExp> regexp,
+  static Handle<Object> JscreExecGlobal(Handle<JSRegExp> regexp,
+                                        Handle<String> subject);
+
+  static Handle<Object> Re2kExecGlobal(Handle<JSRegExp> regexp,
                                        Handle<String> subject);
 
   static void NewSpaceCollectionPrologue();
   static void OldSpaceCollectionPrologue();
 
   // Converts a source string to a 16 bit flat string.  The string
   // will be either sequential or it will be a SlicedString backed
   // by a flat string.
   static Handle<String> StringToTwoByte(Handle<String> pattern);
   static Handle<String> CachedStringToTwoByte(Handle<String> pattern);
 
+  static const int kRe2kImplementationIndex = 0;
+  static const int kRe2kNumberOfCapturesIndex = 1;
+  static const int kRe2kNumberOfRegistersIndex = 2;
+  static const int kRe2kCodeIndex = 3;
+  static const int kRe2kDataLength = 4;
+
+  static const int kJscreNumberOfCapturesIndex = 0;
+  static const int kJscreInternalIndex = 1;
+  static const int kJscreDataLength = 2;
+
  private:
   static String* last_ascii_string_;
   static String* two_byte_cached_string_;
 
-  // Returns the caputure from the re.
-  static int JsreCapture(Handle<JSRegExp> re);
-  static ByteArray* JsreInternal(Handle<JSRegExp> re);
+  static int JscreNumberOfCaptures(Handle<JSRegExp> re);
+  static ByteArray* JscreInternal(Handle<JSRegExp> re);
+
+  static int Re2kNumberOfCaptures(Handle<JSRegExp> re);
+  static int Re2kNumberOfRegisters(Handle<JSRegExp> re);
+  static Handle<ByteArray> Re2kCode(Handle<JSRegExp> re);
 
   // Call jsRegExpExecute once
-  static Handle<Object> JsreExecOnce(Handle<JSRegExp> regexp,
+  static Handle<Object> JscreExecOnce(Handle<JSRegExp> regexp,
+                                      int num_captures,
+                                      Handle<String> subject,
+                                      int previous_index,
+                                      const uc16* utf8_subject,
+                                      int* ovector,
+                                      int ovector_length);
+
+  static Handle<Object> Re2kExecOnce(Handle<JSRegExp> regexp,
                                      int num_captures,
                                      Handle<String> subject,
                                      int previous_index,
                                      const uc16* utf8_subject,
                                      int* ovector,
                                      int ovector_length);
 
   // Set the subject cache.  The previous string buffer is not deleted, so the
   // caller should ensure that it doesn't leak.
-  static void SetSubjectCache(String* subject, char* utf8_subject,
-                              int uft8_length, int character_position,
+  static void SetSubjectCache(String* subject,
+                              char* utf8_subject,
+                              int uft8_length,
+                              int character_position,
                               int utf8_position);
 
   // A one element cache of the last utf8_subject string and its length.  The
   // subject JS String object is cached in the heap.  We also cache a
   // translation between position and utf8 position.
   static char* utf8_subject_cache_;
   static int utf8_length_cache_;
   static int utf8_position_;
   static int character_position_;
 };
@@ skipping 218 matching lines @@
   VISIT(Choice)                                                      \
   VISIT(Backreference)                                               \
   VISIT(CharacterClass)
 
 
 class RegExpNode: public ZoneObject {
  public:
   virtual ~RegExpNode() { }
   virtual void Accept(NodeVisitor* visitor) = 0;
   // Generates a goto to this node or actually generates the code at this point.
-  void GoTo(RegExpCompiler* compiler);
+  // Until the implementation is complete we will return true for success and
+  // false for failure.
+  bool GoTo(RegExpCompiler* compiler);
   void EmitAddress(RegExpCompiler* compiler);
-  virtual void Emit(RegExpCompiler* compiler) = 0;
+  // Until the implementation is complete we will return true for success and
+  // false for failure.
+  virtual bool Emit(RegExpCompiler* compiler) = 0;
  private:
   Label label;
 };
 
 
 class SeqRegExpNode: public RegExpNode {
  public:
   explicit SeqRegExpNode(RegExpNode* on_success)
     : on_success_(on_success) { }
   RegExpNode* on_success() { return on_success_; }
-  virtual void Emit(RegExpCompiler* compiler) { UNREACHABLE(); }
+  virtual bool Emit(RegExpCompiler* compiler) { return false; }
  private:
   RegExpNode* on_success_;
 };
 
 
 class ActionNode: public SeqRegExpNode {
  public:
   enum Type {
     STORE_REGISTER,
     INCREMENT_REGISTER,
     STORE_POSITION,
     RESTORE_POSITION,
     BEGIN_SUBMATCH,
     ESCAPE_SUBMATCH,
     END_SUBMATCH
   };
   static ActionNode* StoreRegister(int reg, int val, RegExpNode* on_success);
   static ActionNode* IncrementRegister(int reg, RegExpNode* on_success);
   static ActionNode* StorePosition(int reg, RegExpNode* on_success);
   static ActionNode* RestorePosition(int reg, RegExpNode* on_success);
   static ActionNode* BeginSubmatch(RegExpNode* on_success);
   static ActionNode* EscapeSubmatch(RegExpNode* on_success);
   static ActionNode* EndSubmatch(RegExpNode* on_success);
   virtual void Accept(NodeVisitor* visitor);
-  virtual void Emit(RegExpCompiler* compiler);
+  virtual bool Emit(RegExpCompiler* compiler);
  private:
   union {
     struct {
       int reg;
       int value;
     } u_store_register;
     struct {
       int reg;
     } u_increment_register;
     struct {
@@ skipping 12 matching lines @@
  public:
   AtomNode(Vector<const uc16> data,
            RegExpNode* on_success,
            RegExpNode* on_failure)
     : SeqRegExpNode(on_success),
       on_failure_(on_failure),
       data_(data) { }
   virtual void Accept(NodeVisitor* visitor);
   Vector<const uc16> data() { return data_; }
   RegExpNode* on_failure() { return on_failure_; }
-  virtual void Emit(RegExpCompiler* compiler) { UNREACHABLE(); }
+  virtual bool Emit(RegExpCompiler* compiler) { return false; }
  private:
   RegExpNode* on_failure_;
   Vector<const uc16> data_;
 };
 
 
 class BackreferenceNode: public SeqRegExpNode {
  public:
   BackreferenceNode(int start_reg,
                     int end_reg,
                     RegExpNode* on_success,
                     RegExpNode* on_failure)
     : SeqRegExpNode(on_success),
       on_failure_(on_failure),
       start_reg_(start_reg),
       end_reg_(end_reg) { }
   virtual void Accept(NodeVisitor* visitor);
   RegExpNode* on_failure() { return on_failure_; }
   int start_register() { return start_reg_; }
   int end_register() { return end_reg_; }
-  virtual void Emit(RegExpCompiler* compiler) { UNREACHABLE(); }
+  virtual bool Emit(RegExpCompiler* compiler) { return false; }
  private:
   RegExpNode* on_failure_;
   int start_reg_;
   int end_reg_;
 };
 
 
 class CharacterClassNode: public SeqRegExpNode {
  public:
   CharacterClassNode(ZoneList<CharacterRange>* ranges,
                      bool is_negated,
                      RegExpNode* on_success,
                      RegExpNode* on_failure)
     : SeqRegExpNode(on_success),
       on_failure_(on_failure),
       ranges_(ranges),
       is_negated_(is_negated ) { }
   virtual void Accept(NodeVisitor* visitor);
   ZoneList<CharacterRange>* ranges() { return ranges_; }
   bool is_negated() { return is_negated_; }
   RegExpNode* on_failure() { return on_failure_; }
-  virtual void Emit(RegExpCompiler* compiler) { UNREACHABLE(); }
+  virtual bool Emit(RegExpCompiler* compiler) { return false; }
   static void AddInverseToTable(ZoneList<CharacterRange>* ranges,
                                 DispatchTable* table,
                                 int index);
  private:
   RegExpNode* on_failure_;
   ZoneList<CharacterRange>* ranges_;
   bool is_negated_;
 };
 
 
 class EndNode: public RegExpNode {
  public:
   enum Action { ACCEPT, BACKTRACK };
   virtual void Accept(NodeVisitor* visitor);
   static EndNode* GetAccept() { return &kAccept; }
   static EndNode* GetBacktrack() { return &kBacktrack; }
-  virtual void Emit(RegExpCompiler* compiler) { UNREACHABLE(); }
+  virtual bool Emit(RegExpCompiler* compiler);
  private:
   explicit EndNode(Action action) : action_(action) { }
   Action action_;
   static EndNode kAccept;
   static EndNode kBacktrack;
 };
 
 
 class Guard: public ZoneObject {
  public:
@@ skipping 28 matching lines @@
  public:
   explicit ChoiceNode(int expected_size, RegExpNode* on_failure)
     : on_failure_(on_failure),
       choices_(new ZoneList<GuardedAlternative>(expected_size)),
       visited_(false) { }
   virtual void Accept(NodeVisitor* visitor);
   void AddChild(GuardedAlternative node) { choices()->Add(node); }
   ZoneList<GuardedAlternative>* choices() { return choices_; }
   DispatchTable* table() { return &table_; }
   RegExpNode* on_failure() { return on_failure_; }
-  virtual void Emit(RegExpCompiler* compiler);
+  virtual bool Emit(RegExpCompiler* compiler);
   bool visited() { return visited_; }
   void set_visited(bool value) { visited_ = value; }
  private:
   RegExpNode* on_failure_;
   ZoneList<GuardedAlternative>* choices_;
   DispatchTable table_;
   bool visited_;
 };
 
 
 struct RegExpParseResult {
   RegExpTree* tree;
   bool has_character_escapes;
   Handle<String> error;
   int capture_count;
 };
 
 
 class RegExpEngine: public AllStatic {
  public:
-  static RegExpNode* Compile(RegExpParseResult* input);
+  static Handle<FixedArray> Compile(RegExpParseResult* input,
+                                    RegExpNode** node_return);
   static void DotPrint(const char* label, RegExpNode* node);
 };
 
 
 class RegExpCompiler;
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSREGEXP_H_