Capture register clearing on loop iteration

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 646 matching lines @@
   virtual RegExpNode* Clone() = 0;
 
  private:
   Label label_;
   NodeInfo info_;
   SiblingList siblings_;
   int variants_generated_;
 };
 
 
+// A simple closed interval.
+class Interval {
+ public:
+  Interval() : from_(kNone), to_(kNone) { }
+  Interval(short from, short to) : from_(from), to_(to) { }
+  Interval Union(Interval that) {
+    if (that.from_ == kNone) return *this;
+    else if (from_ == kNone) return that;
+    else return Interval(Min(from_, that.from_), Max(to_, that.to_));
+  }
+  bool Contains(int value) {
+    return (from_ <= value) && (value <= to_);
+  }
+  bool is_empty() { return from_ == kNone; }
+  short from() { return from_; }
+  short to() { return to_; }
+  static Interval Empty() { return Interval(); }
+  static const int kNone = -1;
+ private:
+  short from_;
+  short to_;
+};
+
+
 class SeqRegExpNode: public RegExpNode {
  public:
   explicit SeqRegExpNode(RegExpNode* on_success)
       : on_success_(on_success) { }
   RegExpNode* on_success() { return on_success_; }
   void set_on_success(RegExpNode* node) { on_success_ = node; }
  private:
   RegExpNode* on_success_;
 };
 
 
 class ActionNode: public SeqRegExpNode {
  public:
   enum Type {
     SET_REGISTER,
     INCREMENT_REGISTER,
     STORE_POSITION,
     BEGIN_SUBMATCH,
     POSITIVE_SUBMATCH_SUCCESS,
-    EMPTY_MATCH_CHECK
+    EMPTY_MATCH_CHECK,
+    CLEAR_CAPTURES
   };
   static ActionNode* SetRegister(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* BeginSubmatch(
-      int stack_pointer_reg,
-      int position_reg,
-      RegExpNode* on_success);
-  static ActionNode* PositiveSubmatchSuccess(
-      int stack_pointer_reg,
-      int restore_reg,
-      RegExpNode* on_success);
-  static ActionNode* EmptyMatchCheck(
-      int start_register,
-      int repetition_register,
-      int repetition_limit,
-      RegExpNode* on_success);
+  static ActionNode* ClearCaptures(Interval range,
+                                   RegExpNode* on_success);

[Erik Corry, 2009/01/14 09:24:31]

This fits on one line.

[Christian Plesner Hansen, 2009/01/14 11:31:35]

Fixed

+  static ActionNode* BeginSubmatch(int stack_pointer_reg,
+                                   int position_reg,
+                                   RegExpNode* on_success);
+  static ActionNode* PositiveSubmatchSuccess(int stack_pointer_reg,
+                                             int restore_reg,
+                                             RegExpNode* on_success);
+  static ActionNode* EmptyMatchCheck(int start_register,
+                                     int repetition_register,
+                                     int repetition_limit,
+                                     RegExpNode* on_success);
   virtual void Accept(NodeVisitor* visitor);
   virtual bool Emit(RegExpCompiler* compiler, GenerationVariant* variant);
   virtual int EatsAtLeast(int recursion_depth);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     int filled_in) {
     return on_success()->GetQuickCheckDetails(details, compiler, filled_in);
   }
   virtual RegExpNode* PropagateForward(NodeInfo* info);
   Type type() { return type_; }
@@ skipping 15 matching lines @@
     } u_position_register;
     struct {
       int stack_pointer_register;
       int current_position_register;
     } u_submatch;
     struct {
       int start_register;
       int repetition_register;
       int repetition_limit;
     } u_empty_match_check;
+    struct {
+      int range_from;

[Erik Corry, 2009/01/14 09:24:31]

Can't we just have an Interval here?

[Christian Plesner Hansen, 2009/01/14 11:31:35]

I thought so too but it turns out that you can't have union members that have a
constructor.

+      int range_to;
+    } u_clear_captures;
   } data_;
   ActionNode(Type type, RegExpNode* on_success)
       : SeqRegExpNode(on_success),
         type_(type) { }
   Type type_;
   friend class DotPrinter;
 };
 
 
 class TextNode: public SeqRegExpNode {
@@ skipping 224 matching lines @@
 // There are many ways to generate code for a node.  This class encapsulates
 // the current way we should be generating.  In other words it encapsulates
 // the current state of the code generator.
 class GenerationVariant {
  public:
   class DeferredAction {
    public:
     DeferredAction(ActionNode::Type type, int reg)
         : type_(type), reg_(reg), next_(NULL) { }
     DeferredAction* next() { return next_; }
+    bool Mentions(int reg);

[Erik Corry, 2009/01/14 09:24:31]

It's messy that this is not a private method, since it returns an invalid
register for some actions.  How about a public method that returns a (perhaps
trivial) Interval instead?

[Christian Plesner Hansen, 2009/01/14 11:31:35]

I'm not sure -- all other operations than the one I added use just one register
and it would make that code more cluttered to use intervals there.

     int reg() { return reg_; }
     ActionNode::Type type() { return type_; }
    private:
     ActionNode::Type type_;
     int reg_;
     DeferredAction* next_;
     friend class GenerationVariant;
   };
 
   class DeferredCapture: public DeferredAction {
@@ skipping 10 matching lines @@
   class DeferredSetRegister :public DeferredAction {
    public:
     DeferredSetRegister(int reg, int value)
         : DeferredAction(ActionNode::SET_REGISTER, reg),
           value_(value) { }
     int value() { return value_; }
    private:
     int value_;
   };
 
+  class DeferredClearCaptures : public DeferredAction {
+   public:
+    DeferredClearCaptures(Interval range)
+        : DeferredAction(ActionNode::CLEAR_CAPTURES, -1),
+          range_(range) { }
+    Interval range() { return range_; }
+   private:
+    Interval range_;
+  };
+
   class DeferredIncrementRegister: public DeferredAction {
    public:
     explicit DeferredIncrementRegister(int reg)
         : DeferredAction(ActionNode::INCREMENT_REGISTER, reg) { }
   };
 
   GenerationVariant()
       : cp_offset_(0),
         actions_(NULL),
         backtrack_(NULL),
@@ skipping 160 matching lines @@
                                     Handle<String> pattern,
                                     bool is_ascii);
 
   static void DotPrint(const char* label, RegExpNode* node, bool ignore_case);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSREGEXP_H_