* No failures on our own tests....

src/interpreter-re2k.cc

 // Copyright 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 21 matching lines @@
 #include "utils.h"
 #include "ast.h"
 #include "bytecodes-re2k.h"
 #include "interpreter-re2k.h"
 
 
 namespace v8 { namespace internal {
 
 
 #ifdef DEBUG
-# define BYTECODE(name) break;                                            \
-                        case BC_##name:                                   \
-                          if (FLAG_trace_regexp_bytecodes) {              \
-                            PrintF("pc = %d, current = %d, bc = "         \
-                                    #name "\n", pc - code_base, current); \
+# define BYTECODE(name) break;                                                 \

[Christian Plesner Hansen, 2008/11/18 14:07:41]

I would prefer if the breaks were written explicitly everywhere.  This is too
subtle for my taste.  But feel free to disagree and not change it.

+                        case BC_##name:                                        \
+                          if (FLAG_trace_regexp_bytecodes) {                   \

[Christian Plesner Hansen, 2008/11/18 14:07:41]

Couldn't this be factored into a function rather than duplicated?

+                            PrintF("pc = %02x, sp = %d, current = %d, bc = "   \
+                                        #name,                                 \
+                                    pc - code_base,                            \
+                                    backtrack_sp - backtrack_stack,            \
+                                    current);                                  \
+                            for (int _i = 1; _i < BC_##name##_LENGTH; _i++) {  \
+                              printf(", %02x", pc[_i]);                        \
+                            }                                                  \
+                            printf("\n");                                      \
                           }
 #else
-# define BYTECODE(name) break;                                            \
+# define BYTECODE(name) break;                                                 \
                         case BC_##name:
 #endif
 
 
 
 static bool RawMatch(const byte* code_base,
                      Vector<const uc16> subject,
                      int* registers,
                      int current) {
   const byte* pc = code_base;
-  int backtrack_stack[1000];
-  int backtrack_stack_space = 1000;
+  int backtrack_stack[10000];
+  int backtrack_stack_space = 10000;
   int* backtrack_sp = backtrack_stack;
   int current_char = -1;
 #ifdef DEBUG
   if (FLAG_trace_regexp_bytecodes) {
     PrintF("\n\nStart bytecode interpreter\n\n");
   }
 #endif
   while (true) {
     switch (*pc) {
       BYTECODE(BREAK)
@@ skipping 67 matching lines @@
         }
       }
       BYTECODE(CHECK_NOT_CHAR) {
         int c = Load16(pc + 1);
         if (c == current_char) {
           pc = code_base + Load32(pc + 3);
         } else {
           pc += 7;
         }
       }
-      BYTECODE(CHECK_RANGE) {
-        int start = Load16(pc + 1);
-        int end = Load16(pc + 3);
-        if (current_char < start || current_char > end) {
-          pc = code_base + Load32(pc + 5);
+      BYTECODE(CHECK_LT) {
+        int limit = Load16(pc + 1);
+        if (current_char < limit) {
+          pc = code_base + Load32(pc + 3);
         } else {
-          pc += 9;
+          pc += 7;
         }
       }
-      BYTECODE(CHECK_NOT_RANGE) {
-        int start = Load16(pc + 1);
-        int end = Load16(pc + 3);
-        if (current_char >= start && current_char <= end) {
-          pc = code_base + Load32(pc + 5);
+      BYTECODE(CHECK_GT) {
+        int limit = Load16(pc + 1);
+        if (current_char > limit) {
+          pc = code_base + Load32(pc + 3);
         } else {
-          pc += 9;
+          pc += 7;

[Christian Plesner Hansen, 2008/11/18 14:07:41]

I would suggest using constants for opcode length so the literal value occurs
exactly one place.  I've previously used the approach of packaging all the
information about a bytecode set into constants on a class so you could do
OpcodeInfo<CHECK_GT>::kLength, OpcodeInfo<CHECH_GT>::kArgCount, etc., so you
would always just use pc += OpcodeInfo<[current opcode]>::kLength.  That may be
too spacy for our use though.

         }
       }
       BYTECODE(CHECK_REGISTER_LT)
         if (registers[pc[1]] < Load16(pc + 2)) {
           pc = code_base + Load32(pc + 4);
         } else {
           pc += 8;
         }
       BYTECODE(CHECK_REGISTER_GE)
         if (registers[pc[1]] >= Load16(pc + 2)) {
@@ skipping 57 matching lines @@
         break;  // Last one doesn't have break in macro.
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
 bool Re2kInterpreter::Match(Handle<ByteArray> code_array,
-                            Handle<String> subject,
+                            Handle<String> subject16,
                             int* registers,
                             int start_position) {
+  ASSERT(StringShape(*subject16).IsTwoByteRepresentation());
+  ASSERT(subject16->IsFlat(StringShape(*subject16)));
+
+
+  AssertNoAllocation a;
   const byte* code_base = code_array->GetDataStartAddress();
-  ASSERT(subject->IsFlat(StringShape(*subject)));
-  Handle<String> flat_two_byte = RegExpImpl::CachedStringToTwoByte(subject);
-  ASSERT(StringShape(*flat_two_byte).IsTwoByteRepresentation());
   return RawMatch(code_base,
-                  flat_two_byte->ToUC16Vector(),
+                  Vector<const uc16>(subject16->GetTwoByteData(),
+                                     subject16->length()),
                   registers,
                   start_position);
 }
 
 } }  // namespace v8::internal