Revert of Experimental support for RegExp lookbehind.

src/regexp/interpreter-irregexp.cc

 // Copyright 2011 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.
 
 // A simple interpreter for the Irregexp byte code.
 
 #include "src/regexp/interpreter-irregexp.h"
 
 #include "src/ast.h"
 #include "src/regexp/bytecodes-irregexp.h"
@@ skipping 252 matching lines @@
         if (current == backtrack_sp[-1]) {
           backtrack_sp--;
           backtrack_stack_space++;
           pc = code_base + Load32Aligned(pc + 4);
         } else {
           pc += BC_CHECK_GREEDY_LENGTH;
         }
         break;
       BYTECODE(LOAD_CURRENT_CHAR) {
         int pos = current + (insn >> BYTECODE_SHIFT);
-        if (pos >= subject.length() || pos < 0) {
+        if (pos >= subject.length()) {
           pc = code_base + Load32Aligned(pc + 4);
         } else {
           current_char = subject[pos];
           pc += BC_LOAD_CURRENT_CHAR_LENGTH;
         }
         break;
       }
       BYTECODE(LOAD_CURRENT_CHAR_UNCHECKED) {
         int pos = current + (insn >> BYTECODE_SHIFT);
         current_char = subject[pos];
         pc += BC_LOAD_CURRENT_CHAR_UNCHECKED_LENGTH;
         break;
       }
       BYTECODE(LOAD_2_CURRENT_CHARS) {
         int pos = current + (insn >> BYTECODE_SHIFT);
-        if (pos + 2 > subject.length() || pos < 0) {
+        if (pos + 2 > subject.length()) {
           pc = code_base + Load32Aligned(pc + 4);
         } else {
           Char next = subject[pos + 1];
           current_char =
               (subject[pos] | (next << (kBitsPerByte * sizeof(Char))));
           pc += BC_LOAD_2_CURRENT_CHARS_LENGTH;
         }
         break;
       }
       BYTECODE(LOAD_2_CURRENT_CHARS_UNCHECKED) {
         int pos = current + (insn >> BYTECODE_SHIFT);
         Char next = subject[pos + 1];
         current_char = (subject[pos] | (next << (kBitsPerByte * sizeof(Char))));
         pc += BC_LOAD_2_CURRENT_CHARS_UNCHECKED_LENGTH;
         break;
       }
       BYTECODE(LOAD_4_CURRENT_CHARS) {
         DCHECK(sizeof(Char) == 1);
         int pos = current + (insn >> BYTECODE_SHIFT);
-        if (pos + 4 > subject.length() || pos < 0) {
+        if (pos + 4 > subject.length()) {
           pc = code_base + Load32Aligned(pc + 4);
         } else {
           Char next1 = subject[pos + 1];
           Char next2 = subject[pos + 2];
           Char next3 = subject[pos + 3];
           current_char = (subject[pos] |
                           (next1 << 8) |
                           (next2 << 16) |
                           (next3 << 24));
           pc += BC_LOAD_4_CURRENT_CHARS_LENGTH;
@@ skipping 170 matching lines @@
         if (registers[insn >> BYTECODE_SHIFT] ==
             registers[Load32Aligned(pc + 4)]) {
           pc += BC_CHECK_NOT_REGS_EQUAL_LENGTH;
         } else {
           pc = code_base + Load32Aligned(pc + 8);
         }
         break;
       BYTECODE(CHECK_NOT_BACK_REF) {
         int from = registers[insn >> BYTECODE_SHIFT];
         int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
-        if (from >= 0 && len > 0) {
-          if (current + len > subject.length() ||
-              CompareChars(&subject[from], &subject[current], len) != 0) {
-            pc = code_base + Load32Aligned(pc + 4);
-            break;
+        if (from < 0 || len <= 0) {
+          pc += BC_CHECK_NOT_BACK_REF_LENGTH;
+          break;
+        }
+        if (current + len > subject.length()) {
+          pc = code_base + Load32Aligned(pc + 4);
+          break;
+        } else {
+          int i;
+          for (i = 0; i < len; i++) {
+            if (subject[from + i] != subject[current + i]) {
+              pc = code_base + Load32Aligned(pc + 4);
+              break;
+            }
           }
+          if (i < len) break;
           current += len;
         }
         pc += BC_CHECK_NOT_BACK_REF_LENGTH;
         break;
       }
-      BYTECODE(CHECK_NOT_BACK_REF_BACKWARD) {
-        int from = registers[insn >> BYTECODE_SHIFT];
-        int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
-        if (from >= 0 && len > 0) {
-          if (current - len < 0 ||
-              CompareChars(&subject[from], &subject[current - len], len) != 0) {
-            pc = code_base + Load32Aligned(pc + 4);
-            break;
-          }
-          current -= len;
-        }
-        pc += BC_CHECK_NOT_BACK_REF_BACKWARD_LENGTH;
-        break;
-      }
       BYTECODE(CHECK_NOT_BACK_REF_NO_CASE) {
         int from = registers[insn >> BYTECODE_SHIFT];
         int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
-        if (from >= 0 && len > 0) {
-          if (current + len > subject.length() ||
-              !BackRefMatchesNoCase(isolate->interp_canonicalize_mapping(),
-                                    from, current, len, subject)) {
+        if (from < 0 || len <= 0) {
+          pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
+          break;
+        }
+        if (current + len > subject.length()) {
+          pc = code_base + Load32Aligned(pc + 4);
+          break;
+        } else {
+          if (BackRefMatchesNoCase(isolate->interp_canonicalize_mapping(),
+                                   from, current, len, subject)) {
+            current += len;
+            pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
+          } else {
             pc = code_base + Load32Aligned(pc + 4);
-            break;
           }
-          current += len;
         }
-        pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
-        break;
-      }
-      BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_BACKWARD) {
-        int from = registers[insn >> BYTECODE_SHIFT];
-        int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
-        if (from >= 0 && len > 0) {
-          if (current - len < 0 ||
-              !BackRefMatchesNoCase(isolate->interp_canonicalize_mapping(),
-                                    from, current - len, len, subject)) {
-            pc = code_base + Load32Aligned(pc + 4);
-            break;
-          }
-          current -= len;
-        }
-        pc += BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD_LENGTH;
         break;
       }
       BYTECODE(CHECK_AT_START)
         if (current == 0) {
           pc = code_base + Load32Aligned(pc + 4);
         } else {
           pc += BC_CHECK_AT_START_LENGTH;
         }
         break;
       BYTECODE(CHECK_NOT_AT_START)
-        if (current + (insn >> BYTECODE_SHIFT) == 0) {
+        if (current == 0) {
           pc += BC_CHECK_NOT_AT_START_LENGTH;
         } else {
           pc = code_base + Load32Aligned(pc + 4);
         }
         break;
       BYTECODE(SET_CURRENT_POSITION_FROM_END) {
         int by = static_cast<uint32_t>(insn) >> BYTECODE_SHIFT;
         if (subject.length() - current > by) {
           current = subject.length() - by;
           current_char = subject[current - 1];
@@ skipping 38 matching lines @@
                     code_base,
                     subject_vector,
                     registers,
                     start_position,
                     previous_char);
   }
 }
 
 }  // namespace internal
 }  // namespace v8