Experimental support for RegExp lookbehind.

src/ast.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_AST_H_
 #define V8_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast-value-factory.h"
 #include "src/bailout-reason.h"
@@ skipping 101 matching lines @@
 
 class RegExpAlternative;
 class RegExpAssertion;
 class RegExpAtom;
 class RegExpBackReference;
 class RegExpCapture;
 class RegExpCharacterClass;
 class RegExpCompiler;
 class RegExpDisjunction;
 class RegExpEmpty;
-class RegExpLookahead;
+class RegExpLookaround;
 class RegExpQuantifier;
 class RegExpText;
 
 #define DEF_FORWARD_DECLARATION(type) class type;
 AST_NODE_LIST(DEF_FORWARD_DECLARATION)
 #undef DEF_FORWARD_DECLARATION
 
 
 // Typedef only introduced to avoid unreadable code.
 typedef ZoneList<Handle<String>> ZoneStringList;
@@ skipping 2935 matching lines @@
   int min_;
   int max_;
   int min_match_;
   int max_match_;
   QuantifierType quantifier_type_;
 };
 
 
 class RegExpCapture final : public RegExpTree {
  public:
-  explicit RegExpCapture(RegExpTree* body, int index)
-      : body_(body), index_(index) { }
+  explicit RegExpCapture(int index) : body_(NULL), index_(index) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   static RegExpNode* ToNode(RegExpTree* body,
                             int index,
                             RegExpCompiler* compiler,
                             RegExpNode* on_success);
   RegExpCapture* AsCapture() override;
   bool IsAnchoredAtStart() override;
   bool IsAnchoredAtEnd() override;
   Interval CaptureRegisters() override;
   bool IsCapture() override;
   int min_match() override { return body_->min_match(); }
   int max_match() override { return body_->max_match(); }
   RegExpTree* body() { return body_; }
+  void set_body(RegExpTree* body) { body_ = body; }
   int index() { return index_; }
   static int StartRegister(int index) { return index * 2; }
   static int EndRegister(int index) { return index * 2 + 1; }
 
  private:
   RegExpTree* body_;
   int index_;
 };
 
 
-class RegExpLookahead final : public RegExpTree {
+class RegExpLookaround final : public RegExpTree {
  public:
-  RegExpLookahead(RegExpTree* body,
-                  bool is_positive,
-                  int capture_count,
-                  int capture_from)
+  enum Type { LOOKAHEAD, LOOKBEHIND };
+
+  RegExpLookaround(RegExpTree* body, bool is_positive, int capture_count,
+                   int capture_from, Type type)
       : body_(body),
         is_positive_(is_positive),
         capture_count_(capture_count),
-        capture_from_(capture_from) { }
+        capture_from_(capture_from),
+        type_(type) {}
 
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpLookahead* AsLookahead() override;
+  RegExpLookaround* AsLookaround() override;
   Interval CaptureRegisters() override;
-  bool IsLookahead() override;
+  bool IsLookaround() override;
   bool IsAnchoredAtStart() override;
   int min_match() override { return 0; }
   int max_match() override { return 0; }
   RegExpTree* body() { return body_; }
   bool is_positive() { return is_positive_; }
   int capture_count() { return capture_count_; }
   int capture_from() { return capture_from_; }
+  Type type() { return type_; }
 
  private:
   RegExpTree* body_;
   bool is_positive_;
   int capture_count_;
   int capture_from_;
+  Type type_;
 };
 
 
 class RegExpBackReference final : public RegExpTree {
  public:
   explicit RegExpBackReference(RegExpCapture* capture)
       : capture_(capture) { }
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpBackReference* AsBackReference() override;
   bool IsBackReference() override;
   int min_match() override { return 0; }
-  int max_match() override { return capture_->max_match(); }
+  // The capture may not be completely parsed yet, if the reference occurs
+  // before the capture. In the ordinary case, nothing has been captured yet,
+  // so the back reference must have the length 0. If the back reference is
+  // inside a lookbehind, effectively making it a forward reference, we return
+  // 0 since lookbehinds have a length of 0.
+  int max_match() override {
+    return capture_->body() ? capture_->max_match() : 0;
+  }
   int index() { return capture_->index(); }
   RegExpCapture* capture() { return capture_; }
  private:
   RegExpCapture* capture_;
 };
 
 
 class RegExpEmpty final : public RegExpTree {
  public:
   RegExpEmpty() { }
@@ skipping 504 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_H_