* Have an ASCII and a UC16 interpreter for Irregexp bytecodes -...

src/interpreter-irregexp.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 42 matching lines @@
     canonicalize.get(old_char, '\0', &old_char);
     canonicalize.get(new_char, '\0', &new_char);
     if (old_char != new_char) {
       return false;
     }
   }
   return true;
 }
 
 
+static bool BackRefMatchesNoCase(int from,
+                                 int current,
+                                 int len,
+                                 Vector<const char> subject) {
+  for (int i = 0; i < len; i++) {
+    unsigned int old_char = subject[from++];
+    unsigned int new_char = subject[current++];
+    if (old_char == new_char) continue;
+    if (old_char - 'A' <= 'Z' - 'A') old_char |= 0x20;
+    if (new_char - 'A' <= 'Z' - 'A') new_char |= 0x20;
+    if (old_char != new_char) return false;
+  }
+  return true;
+}
+
+
 #ifdef DEBUG
 static void TraceInterpreter(const byte* code_base,
                              const byte* pc,
                              int stack_depth,
                              int current_position,
                              int bytecode_length,
                              const char* bytecode_name) {
   if (FLAG_trace_regexp_bytecodes) {
     PrintF("pc = %02x, sp = %d, current = %d, bc = %s",
            pc - code_base,
@@ skipping 16 matching lines @@
                      current,                           \
                      BC_##name##_LENGTH,                \
                      #name);
 #else
 #define BYTECODE(name)                                  \
   case BC_##name:
 #endif
 
 
 
+template <typename Char>
 static bool RawMatch(const byte* code_base,
-                     Vector<const uc16> subject,
+                     Vector<const Char> subject,
                      int* registers,
                      int current,
                      int current_char) {
   const byte* pc = code_base;
   static const int kBacktrackStackSize = 10000;
   int backtrack_stack[kBacktrackStackSize];
   int backtrack_stack_space = kBacktrackStackSize;
   int* backtrack_sp = backtrack_stack;
 #ifdef DEBUG
   if (FLAG_trace_regexp_bytecodes) {
@@ skipping 287 matching lines @@
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
 bool IrregexpInterpreter::Match(Handle<ByteArray> code_array,
-                                Handle<String> subject16,
+                                Handle<String> subject,
                                 int* registers,
                                 int start_position) {
-  ASSERT(StringShape(*subject16).IsTwoByteRepresentation());
-  ASSERT(subject16->IsFlat(StringShape(*subject16)));
+  ASSERT(subject->IsFlat(StringShape(*subject)));
 
   AssertNoAllocation a;
   const byte* code_base = code_array->GetDataStartAddress();
+  StringShape subject_shape(*subject);
   uc16 previous_char = '\n';
-  Vector<const uc16> subject_vector =
-      Vector<const uc16>(subject16->GetTwoByteData(), subject16->length());
-  if (start_position != 0) previous_char = subject_vector[start_position - 1];
-  return RawMatch(code_base,
-                  subject_vector,
-                  registers,
-                  start_position,
-                  previous_char);
+  if (subject_shape.IsAsciiRepresentation()) {
+    Vector<const char> subject_vector = subject->ToAsciiVector();
+    if (start_position != 0) previous_char = subject_vector[start_position - 1];
+    return RawMatch(code_base,
+                    subject_vector,
+                    registers,
+                    start_position,
+                    previous_char);
+  } else {
+    Vector<const uc16> subject_vector = subject->ToUC16Vector();
+    if (start_position != 0) previous_char = subject_vector[start_position - 1];
+    return RawMatch(code_base,
+                    subject_vector,
+                    registers,
+                    start_position,
+                    previous_char);
+  }
 }
 
 } }  // namespace v8::internal