Experimental support for RegExp lookbehind.

test/cctest/test-regexp.cc

 // Copyright 2012 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 142 matching lines @@
 
 #define CHECK_PARSE_ERROR(input) CHECK(!CheckParse(input))
 #define CHECK_SIMPLE(input, simple) CHECK_EQ(simple, CheckSimple(input));
 #define CHECK_MIN_MAX(input, min, max)                                         \
   { MinMaxPair min_max = CheckMinMaxMatch(input);                              \
     CHECK_EQ(min, min_max.min_match);                                          \
     CHECK_EQ(max, min_max.max_match);                                          \
   }
 
 TEST(Parser) {
+  FLAG_harmony_regexp_lookbehind = true;

[erikcorry, 2015/11/11 15:39:04]

Probably better to put this whole test in a static function that takes a bool,
and call it:

TEST(Parser) {
  RegexpParserTest(true);
  RegexpParserTest(false);
}

[Yang, 2015/11/12 08:25:35]

Done.

+
   CHECK_PARSE_ERROR("?");
 
   CheckParseEq("abc", "'abc'");
   CheckParseEq("", "%");
   CheckParseEq("abc|def", "(| 'abc' 'def')");
   CheckParseEq("abc|def|ghi", "(| 'abc' 'def' 'ghi')");
   CheckParseEq("^xxx$", "(: @^i 'xxx' @$i)");
   CheckParseEq("ab\\b\\d\\bcd", "(: 'ab' @b [0-9] @b 'cd')");
   CheckParseEq("\\w|\\d", "(| [0-9 A-Z _ a-z] [0-9])");
   CheckParseEq("a*", "(# 0 - g 'a')");
@@ skipping 11 matching lines @@
   CheckParseEq("xyz{1,}", "(: 'xy' (# 1 - g 'z'))");
   CheckParseEq("xyz{1,}?", "(: 'xy' (# 1 - n 'z'))");
   CheckParseEq("a\\fb\\nc\\rd\\te\\vf", "'a\\x0cb\\x0ac\\x0dd\\x09e\\x0bf'");
   CheckParseEq("a\\nb\\bc", "(: 'a\\x0ab' @b 'c')");
   CheckParseEq("(?:foo)", "'foo'");
   CheckParseEq("(?: foo )", "' foo '");
   CheckParseEq("(foo|bar|baz)", "(^ (| 'foo' 'bar' 'baz'))");
   CheckParseEq("foo|(bar|baz)|quux", "(| 'foo' (^ (| 'bar' 'baz')) 'quux')");
   CheckParseEq("foo(?=bar)baz", "(: 'foo' (-> + 'bar') 'baz')");
   CheckParseEq("foo(?!bar)baz", "(: 'foo' (-> - 'bar') 'baz')");
+  CheckParseEq("foo(?<=bar)baz", "(: 'foo' (<- + 'bar') 'baz')");
+  CheckParseEq("foo(?<!bar)baz", "(: 'foo' (<- - 'bar') 'baz')");
   CheckParseEq("()", "(^ %)");
   CheckParseEq("(?=)", "(-> + %)");
   CheckParseEq("[]", "^[\\x00-\\uffff]");  // Doesn't compile on windows
   CheckParseEq("[^]", "[\\x00-\\uffff]");  // \uffff isn't in codepage 1252
   CheckParseEq("[x]", "[x]");
   CheckParseEq("[xyz]", "[x y z]");
   CheckParseEq("[a-zA-Z0-9]", "[a-z A-Z 0-9]");
   CheckParseEq("[-123]", "[- 1 2 3]");
   CheckParseEq("[^123]", "^[1 2 3]");
   CheckParseEq("]", "']'");
@@ skipping 49 matching lines @@
   CheckParseEq("(x)(x)(x)\\4*",
                "(: (^ 'x') (^ 'x') (^ 'x')"
                " (# 0 - g '\\x04'))");
   CheckParseEq("(x)(x)(x)(x)(x)(x)(x)(x)(x)(x)\\10",
                "(: (^ 'x') (^ 'x') (^ 'x') (^ 'x') (^ 'x') (^ 'x')"
                " (^ 'x') (^ 'x') (^ 'x') (^ 'x') (<- 10))");
   CheckParseEq("(x)(x)(x)(x)(x)(x)(x)(x)(x)(x)\\11",
                "(: (^ 'x') (^ 'x') (^ 'x') (^ 'x') (^ 'x') (^ 'x')"
                " (^ 'x') (^ 'x') (^ 'x') (^ 'x') '\\x09')");
   CheckParseEq("(a)\\1", "(: (^ 'a') (<- 1))");
-  CheckParseEq("(a\\1)", "(^ 'a')");
-  CheckParseEq("(\\1a)", "(^ 'a')");
+  CheckParseEq("(a\\1)", "(^ (: 'a' (<- 1)))");
+  CheckParseEq("(\\1a)", "(^ (: (<- 1) 'a'))");
   CheckParseEq("(?=a)?a", "'a'");
   CheckParseEq("(?=a){0,10}a", "'a'");
   CheckParseEq("(?=a){1,10}a", "(: (-> + 'a') 'a')");
   CheckParseEq("(?=a){9,10}a", "(: (-> + 'a') 'a')");
   CheckParseEq("(?!a)?a", "'a'");
-  CheckParseEq("\\1(a)", "(^ 'a')");
+  CheckParseEq("\\1(a)", "(: (<- 1) (^ 'a'))");
   CheckParseEq("(?!(a))\\1", "(: (-> - (^ 'a')) (<- 1))");
-  CheckParseEq("(?!\\1(a\\1)\\1)\\1", "(: (-> - (: (^ 'a') (<- 1))) (<- 1))");
+  CheckParseEq("(?!\\1(a\\1)\\1)\\1",
+               "(: (-> - (: (<- 1) (^ (: 'a' (<- 1))) (<- 1))) (<- 1))");
   CheckParseEq("[\\0]", "[\\x00]");
   CheckParseEq("[\\11]", "[\\x09]");
   CheckParseEq("[\\11a]", "[\\x09 a]");
   CheckParseEq("[\\011]", "[\\x09]");
   CheckParseEq("[\\00011]", "[\\x00 1 1]");
   CheckParseEq("[\\118]", "[\\x09 8]");
   CheckParseEq("[\\111]", "[I]");
   CheckParseEq("[\\1111]", "[I 1]");
   CheckParseEq("\\x34", "'\x34'");
   CheckParseEq("\\x60", "'\x60'");
@@ skipping 1098 matching lines @@
   // ^f(o)o.
   Label start, fail, backtrack;
 
   m.SetRegister(4, 42);
   m.PushRegister(4, RegExpMacroAssembler::kNoStackLimitCheck);
   m.AdvanceRegister(4, 42);
   m.GoTo(&start);
   m.Fail();
   m.Bind(&start);
   m.PushBacktrack(&fail);
-  m.CheckNotAtStart(NULL);
+  m.CheckNotAtStart(0, NULL);
   m.LoadCurrentCharacter(0, NULL);
   m.CheckNotCharacter('f', NULL);
   m.LoadCurrentCharacter(1, NULL);
   m.CheckNotCharacter('o', NULL);
   m.LoadCurrentCharacter(2, NULL);
   m.CheckNotCharacter('o', NULL);
   m.WriteCurrentPositionToRegister(0, 0);
   m.WriteCurrentPositionToRegister(1, 3);
   m.WriteCurrentPositionToRegister(2, 1);
   m.WriteCurrentPositionToRegister(3, 2);
@@ skipping 410 matching lines @@
 
   ZoneList<CharacterRange> first_only(4, &zone);
   ZoneList<CharacterRange> second_only(4, &zone);
   ZoneList<CharacterRange> both(4, &zone);
 }
 
 
 TEST(Graph) {
   Execute("\\b\\w+\\b", false, true, true);
 }