* No failures on our own tests....

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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_JSREGEXP_H_
 #define V8_JSREGEXP_H_
 
 namespace v8 { namespace internal {
 
+
+class RegExpMacroAssembler;
+
+
 class RegExpImpl {
  public:
   // Creates a regular expression literal in the old space.
   // This function calls the garbage collector if necessary.
   static Handle<Object> CreateRegExpLiteral(Handle<JSFunction> constructor,
                                             Handle<String> pattern,
                                             Handle<String> flags,
                                             bool* has_pending_exception);
 
   // Returns a string representation of a regular expression.
@@ skipping 101 matching lines @@
   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,
+                                     Handle<String> subject16,
                                      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,
                               int utf8_position);
@@ skipping 302 matching lines @@
   bool follows_word_interest: 1;
   bool follows_newline_interest: 1;
   bool follows_start_interest: 1;
 };
 
 
 STATIC_CHECK(sizeof(NodeInfo) <= sizeof(int));  // NOLINT
 
 
 class SiblingList {
-public:
+ public:
   SiblingList() : list_(NULL) { }
   int length() {
     return list_ == NULL ? 0 : list_->length();
   }
   void Ensure(RegExpNode* parent) {
     if (list_ == NULL) {
       list_ = new ZoneList<RegExpNode*>(2);
       list_->Add(parent);
     }
   }
   void Add(RegExpNode* node) { list_->Add(node); }
   RegExpNode* Get(int index) { return list_->at(index); }
-private:
+ private:
   ZoneList<RegExpNode*>* list_;
 };
 
 
 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.
   // Until the implementation is complete we will return true for success and
   // false for failure.
-  bool GoTo(RegExpCompiler* compiler);
+  virtual bool GoTo(RegExpCompiler* compiler);
   Label* label();
 
   // Until the implementation is complete we will return true for success and
   // false for failure.
   virtual bool Emit(RegExpCompiler* compiler) = 0;
   virtual RegExpNode* PropagateInterest(NodeInfo* info) = 0;
   NodeInfo* info() { return &info_; }
   virtual bool IsBacktrack() { return false; }
   RegExpNode* GetSibling(NodeInfo* info);
   void EnsureSiblings() { siblings_.Ensure(this); }
   void AddSibling(RegExpNode* node) { siblings_.Add(node); }
+ protected:
+  inline void Bind(RegExpMacroAssembler* macro);
  private:
   Label label_;
   NodeInfo info_;
   SiblingList siblings_;
 };
 
 
 class SeqRegExpNode: public RegExpNode {
  public:
   explicit SeqRegExpNode(RegExpNode* on_success)
@@ skipping 50 matching lines @@
 
 class TextNode: public SeqRegExpNode {
  public:
   TextNode(ZoneList<TextElement>* elms,
            RegExpNode* on_success,
            RegExpNode* on_failure)
     : SeqRegExpNode(on_success),
       on_failure_(on_failure),
       elms_(elms) { }
   virtual void Accept(NodeVisitor* visitor);
-  virtual bool Emit(RegExpCompiler* compiler) { return false; }
   virtual RegExpNode* PropagateInterest(NodeInfo* info);
   RegExpNode* on_failure() { return on_failure_; }
+  virtual bool Emit(RegExpCompiler* compiler);
   ZoneList<TextElement>* elements() { return elms_; }
  private:
   RegExpNode* on_failure_;
   ZoneList<TextElement>* elms_;
 };
 
 
 class BackreferenceNode: public SeqRegExpNode {
  public:
   BackreferenceNode(int start_reg,
@@ skipping 18 matching lines @@
 
 
 class EndNode: public RegExpNode {
  public:
   enum Action { ACCEPT, BACKTRACK };
   explicit EndNode(Action action) : action_(action) { }
   virtual void Accept(NodeVisitor* visitor);
   virtual bool Emit(RegExpCompiler* compiler);
   virtual RegExpNode* PropagateInterest(NodeInfo* info);
   virtual bool IsBacktrack() { return action_ == BACKTRACK; }
+  virtual bool GoTo(RegExpCompiler* compiler);
  private:
   Action action_;
 };
 
 
 class Guard: public ZoneObject {
  public:
   enum Relation { LT, GEQ };
   Guard(int reg, Relation op, int value)
     : reg_(reg),
@@ skipping 34 matching lines @@
   ZoneList<GuardedAlternative>* alternatives() { return alternatives_; }
   DispatchTable* table() { return &table_; }
   RegExpNode* on_failure() { return on_failure_; }
   virtual bool Emit(RegExpCompiler* compiler);
   virtual RegExpNode* PropagateInterest(NodeInfo* info);
   bool table_calculated() { return table_calculated_; }
   void set_table_calculated(bool b) { table_calculated_ = b; }
   bool being_calculated() { return being_calculated_; }
   void set_being_calculated(bool b) { being_calculated_ = b; }
  private:
-  void GenerateGuard(RegExpCompiler* compiler,
+  void GenerateGuard(RegExpMacroAssembler* macro_assembler,
                      Guard *guard,
                      Label* on_failure);
   RegExpNode* on_failure_;
   ZoneList<GuardedAlternative>* alternatives_;
   DispatchTable table_;
   bool table_calculated_;
   bool being_calculated_;
 };
 
 
@@ skipping 61 matching lines @@
   static Handle<FixedArray> Compile(RegExpParseResult* input,
                                     RegExpNode** node_return,
                                     bool ignore_case);
   static void DotPrint(const char* label, RegExpNode* node);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSREGEXP_H_