* Rename to Irregexp throughout....

src/jsregexp.cc

 // Copyright 2006-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 22 matching lines @@
 #include "ast.h"
 #include "execution.h"
 #include "factory.h"
 #include "jsregexp-inl.h"
 #include "platform.h"
 #include "runtime.h"
 #include "top.h"
 #include "compilation-cache.h"
 #include "string-stream.h"
 #include "parser.h"
-#include "assembler-re2k.h"
+#include "assembler-irregexp.h"
 #include "regexp-macro-assembler.h"
-#include "regexp-macro-assembler-re2k.h"
+#include "regexp-macro-assembler-irregexp.h"
 #if defined __arm__ || defined __thumb__ || defined ARM
 // include regexp-macro-assembler-arm.h when created.
 #else  // ia32
 #include "regexp-macro-assembler-ia32.h"
 #endif
-#include "interpreter-re2k.h"
+#include "interpreter-irregexp.h"
 
 // Including pcre.h undefines DEBUG to avoid getting debug output from
 // the JSCRE implementation. Make sure to redefine it in debug mode
 // after having included the header file.
 #ifdef DEBUG
 #include "third_party/jscre/pcre.h"
 #define DEBUG
 #else
 #include "third_party/jscre/pcre.h"
 #endif
@@ skipping 166 matching lines @@
       if (parse_result.has_character_escapes) {
         Vector<const uc16> atom_pattern = atom->data();
         Handle<String> atom_string =
             Factory::NewStringFromTwoByte(atom_pattern);
         result = AtomCompile(re, pattern, flags, atom_string);
       } else {
         result = AtomCompile(re, pattern, flags, pattern);
       }
     } else {
       RegExpNode* node = NULL;
-      Handle<FixedArray> re2k_data =
+      Handle<FixedArray> irregexp_data =
           RegExpEngine::Compile(&parse_result,
                                 &node,
                                 flags.is_ignore_case());
-      if (re2k_data.is_null()) {
+      if (irregexp_data.is_null()) {
         result = JscrePrepare(re, pattern, flags);
       } else {
-        result = Re2kPrepare(re, pattern, flags, re2k_data);
+        result = IrregexpPrepare(re, pattern, flags, irregexp_data);
       }
     }
     Object* data = re->data();
     if (data->IsFixedArray()) {
       // If compilation succeeded then the data is set on the regexp
       // and we can store it in the cache.
       Handle<FixedArray> data(FixedArray::cast(re->data()));
       CompilationCache::PutRegExp(pattern, flags, data);
     }
   }
 
   LOG(RegExpCompileEvent(re, in_cache));
   return result;
 }
 
 
 Handle<Object> RegExpImpl::Exec(Handle<JSRegExp> regexp,
                                 Handle<String> subject,
                                 Handle<Object> index) {
   switch (regexp->TypeTag()) {
     case JSRegExp::JSCRE:
       return JscreExec(regexp, subject, index);
     case JSRegExp::ATOM:
       return AtomExec(regexp, subject, index);
-    case JSRegExp::RE2K:
-      return Re2kExec(regexp, subject, index);
+    case JSRegExp::IRREGEXP:
+      return IrregexpExec(regexp, subject, index);
     default:
       UNREACHABLE();
       return Handle<Object>();
   }
 }
 
 
 Handle<Object> RegExpImpl::ExecGlobal(Handle<JSRegExp> regexp,
                                 Handle<String> subject) {
   switch (regexp->TypeTag()) {
     case JSRegExp::JSCRE:
       return JscreExecGlobal(regexp, subject);
     case JSRegExp::ATOM:
       return AtomExecGlobal(regexp, subject);
-    case JSRegExp::RE2K:
-      return Re2kExecGlobal(regexp, subject);
+    case JSRegExp::IRREGEXP:
+      return IrregexpExecGlobal(regexp, subject);
     default:
       UNREACHABLE();
       return Handle<Object>();
   }
 }
 
 
 Handle<Object> RegExpImpl::AtomCompile(Handle<JSRegExp> re,
                                        Handle<String> pattern,
                                        JSRegExp::Flags flags,
@@ skipping 57 matching lines @@
 
 Handle<Object>RegExpImpl::JscrePrepare(Handle<JSRegExp> re,
                                        Handle<String> pattern,
                                        JSRegExp::Flags flags) {
   Handle<Object> value(Heap::undefined_value());
   Factory::SetRegExpData(re, JSRegExp::JSCRE, pattern, flags, value);
   return re;
 }
 
 
-Handle<Object>RegExpImpl::Re2kPrepare(Handle<JSRegExp> re,
-                                      Handle<String> pattern,
-                                      JSRegExp::Flags flags,
-                                      Handle<FixedArray> re2k_data) {
-  Factory::SetRegExpData(re, JSRegExp::RE2K, pattern, flags, re2k_data);
+Handle<Object>RegExpImpl::IrregexpPrepare(Handle<JSRegExp> re,
+                                          Handle<String> pattern,
+                                          JSRegExp::Flags flags,
+                                          Handle<FixedArray> irregexp_data) {
+  Factory::SetRegExpData(re, JSRegExp::IRREGEXP, pattern, flags, irregexp_data);
   return re;
 }
 
 
 static inline Object* DoCompile(String* pattern,
                                 JSRegExp::Flags flags,
                                 unsigned* number_of_captures,
                                 const char** error_message,
                                 JscreRegExp** code) {
   JSRegExpIgnoreCaseOption case_option = flags.is_ignore_case()
@@ skipping 76 matching lines @@
 
   Handle<FixedArray> value = Factory::NewFixedArray(kJscreDataLength);
   value->set(kJscreNumberOfCapturesIndex, Smi::FromInt(number_of_captures));
   value->set(kJscreInternalIndex, *internal);
   Factory::SetRegExpData(re, JSRegExp::JSCRE, pattern, flags, value);
 
   return re;
 }
 
 
-Handle<Object> RegExpImpl::Re2kExecOnce(Handle<JSRegExp> regexp,
-                                        int num_captures,
-                                        Handle<String> two_byte_subject,
-                                        int previous_index,
-                                        int* offsets_vector,
-                                        int offsets_vector_length) {
+Handle<Object> RegExpImpl::IrregexpExecOnce(Handle<JSRegExp> regexp,
+                                            int num_captures,
+                                            Handle<String> two_byte_subject,
+                                            int previous_index,
+                                            int* offsets_vector,
+                                            int offsets_vector_length) {
 #ifdef DEBUG
   if (FLAG_trace_regexp_bytecodes) {
     String* pattern = regexp->Pattern();
     PrintF("\n\nRegexp match:   /%s/\n\n", *(pattern->ToCString()));
     PrintF("\n\nSubject string: '%s'\n\n", *(two_byte_subject->ToCString()));
   }
 #endif
   ASSERT(StringShape(*two_byte_subject).IsTwoByteRepresentation());
   ASSERT(two_byte_subject->IsFlat(StringShape(*two_byte_subject)));
   bool rc;
   {
     for (int i = (num_captures + 1) * 2 - 1; i >= 0; i--) {
       offsets_vector[i] = -1;
     }
 
     LOG(RegExpExecEvent(regexp, previous_index, two_byte_subject));
 
-    FixedArray* re2k =
-        FixedArray::cast(regexp->DataAt(JSRegExp::kRe2kDataIndex));
-    int tag = Smi::cast(re2k->get(kRe2kImplementationIndex))->value();
+    FixedArray* irregexp =
+        FixedArray::cast(regexp->DataAt(JSRegExp::kIrregexpDataIndex));
+    int tag = Smi::cast(irregexp->get(kIrregexpImplementationIndex))->value();
 
     switch (tag) {
     case RegExpMacroAssembler::kIA32Implementation: {
-      Code* code = Code::cast(re2k->get(kRe2kCodeIndex));
+      Code* code = Code::cast(irregexp->get(kIrregexpCodeIndex));
       SmartPointer<int> captures(NewArray<int>((num_captures + 1) * 2));
       Address start_addr =
           Handle<SeqTwoByteString>::cast(two_byte_subject)->GetCharsAddress();
       int start_offset =
           start_addr - reinterpret_cast<Address>(*two_byte_subject);
       int end_offset =
           start_offset + (two_byte_subject->length() - previous_index) * 2;
       typedef bool testfunc(String**, int, int, int*);
       testfunc* test = FUNCTION_CAST<testfunc*>(code->entry());
       rc = test(two_byte_subject.location(),
                 start_offset,
                 end_offset,
                 *captures);
       if (rc) {
         // Capture values are relative to start_offset only.
         for (int i = 0; i < offsets_vector_length; i++) {
           if (offsets_vector[i] >= 0) {
             offsets_vector[i] += previous_index;
           }
         }
       }
       break;
     }
     default:
     case RegExpMacroAssembler::kARMImplementation:
       UNREACHABLE();
       rc = false;
       break;
     case RegExpMacroAssembler::kBytecodeImplementation: {
-      Handle<ByteArray> byte_codes = Re2kCode(regexp);
+      Handle<ByteArray> byte_codes = IrregexpCode(regexp);
 
-      rc = Re2kInterpreter::Match(byte_codes,
-                                  two_byte_subject,
-                                  offsets_vector,
-                                  previous_index);
+      rc = IrregexpInterpreter::Match(byte_codes,
+                                      two_byte_subject,
+                                      offsets_vector,
+                                      previous_index);
       break;
     }
     }
   }
 
   if (!rc) {
     return Factory::null_value();
   }
 
   Handle<FixedArray> array = Factory::NewFixedArray(2 * (num_captures+1));
@@ skipping 91 matching lines @@
   int offsets_vector_length_;
   static const int kStaticOffsetsVectorSize = 50;
   static int static_offsets_vector_[kStaticOffsetsVectorSize];
 };
 
 
 int OffsetsVector::static_offsets_vector_[
     OffsetsVector::kStaticOffsetsVectorSize];
 
 
-Handle<Object> RegExpImpl::Re2kExec(Handle<JSRegExp> regexp,
+Handle<Object> RegExpImpl::IrregexpExec(Handle<JSRegExp> regexp,
                                     Handle<String> subject,
                                     Handle<Object> index) {
-  ASSERT_EQ(regexp->TypeTag(), JSRegExp::RE2K);
-  ASSERT(!regexp->DataAt(JSRegExp::kRe2kDataIndex)->IsUndefined());
+  ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
+  ASSERT(!regexp->DataAt(JSRegExp::kIrregexpDataIndex)->IsUndefined());
 
   // Prepare space for the return values.
-  int number_of_registers = Re2kNumberOfRegisters(regexp);
+  int number_of_registers = IrregexpNumberOfRegisters(regexp);
   OffsetsVector offsets(number_of_registers);
 
-  int num_captures = Re2kNumberOfCaptures(regexp);
+  int num_captures = IrregexpNumberOfCaptures(regexp);
 
   int previous_index = static_cast<int>(DoubleToInteger(index->Number()));
 
   Handle<String> subject16 = CachedStringToTwoByte(subject);
 
   Handle<Object> result(
-      Re2kExecOnce(regexp,
-                   num_captures,
-                   subject16,
-                   previous_index,
-                   offsets.vector(),
-                   offsets.length()));
+      IrregexpExecOnce(regexp,
+                       num_captures,
+                       subject16,
+                       previous_index,
+                       offsets.vector(),
+                       offsets.length()));
   return result;
 }
 
 
 Handle<Object> RegExpImpl::JscreExec(Handle<JSRegExp> regexp,
                                      Handle<String> subject,
                                      Handle<Object> index) {
   ASSERT_EQ(regexp->TypeTag(), JSRegExp::JSCRE);
   if (regexp->DataAt(JSRegExp::kJscreDataIndex)->IsUndefined()) {
     Handle<Object> compile_result = JscreCompile(regexp);
-    if (compile_result->IsException()) return compile_result;
+    if (compile_result.is_null()) return compile_result;
   }
   ASSERT(regexp->DataAt(JSRegExp::kJscreDataIndex)->IsFixedArray());
 
   int num_captures = JscreNumberOfCaptures(regexp);
 
   OffsetsVector offsets((num_captures + 1) * 3);
 
   int previous_index = static_cast<int>(DoubleToInteger(index->Number()));
 
   Handle<String> subject16 = CachedStringToTwoByte(subject);
 
   Handle<Object> result(JscreExecOnce(regexp,
                                       num_captures,
                                       subject,
                                       previous_index,
                                       subject16->GetTwoByteData(),
                                       offsets.vector(),
                                       offsets.length()));
 
   return result;
 }
 
 
-Handle<Object> RegExpImpl::Re2kExecGlobal(Handle<JSRegExp> regexp,
-                                          Handle<String> subject) {
-  ASSERT_EQ(regexp->TypeTag(), JSRegExp::RE2K);
-  ASSERT(!regexp->DataAt(JSRegExp::kRe2kDataIndex)->IsUndefined());
+Handle<Object> RegExpImpl::IrregexpExecGlobal(Handle<JSRegExp> regexp,
+                                              Handle<String> subject) {
+  ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
+  ASSERT(!regexp->DataAt(JSRegExp::kIrregexpDataIndex)->IsUndefined());
 
   // Prepare space for the return values.
-  int number_of_registers = Re2kNumberOfRegisters(regexp);
+  int number_of_registers = IrregexpNumberOfRegisters(regexp);
   OffsetsVector offsets(number_of_registers);
 
   int previous_index = 0;
 
   Handle<JSArray> result = Factory::NewJSArray(0);
   int i = 0;
   Handle<Object> matches;
 
   Handle<String> subject16 = CachedStringToTwoByte(subject);
 
   do {
     if (previous_index > subject->length() || previous_index < 0) {
       // Per ECMA-262 15.10.6.2, if the previous index is greater than the
       // string length, there is no match.
       matches = Factory::null_value();
     } else {
-      matches = Re2kExecOnce(regexp,
-                             Re2kNumberOfCaptures(regexp),
-                             subject16,
-                             previous_index,
-                             offsets.vector(),
-                             offsets.length());
+      matches = IrregexpExecOnce(regexp,
+                                 IrregexpNumberOfCaptures(regexp),
+                                 subject16,
+                                 previous_index,
+                                 offsets.vector(),
+                                 offsets.length());
 
       if (matches->IsJSArray()) {
         SetElement(result, i, matches);
         i++;
         previous_index = offsets.vector()[1];
         if (offsets.vector()[0] == offsets.vector()[1]) {
           previous_index++;
         }
       }
     }
@@ skipping 70 matching lines @@
       value();
 }
 
 
 ByteArray* RegExpImpl::JscreInternal(Handle<JSRegExp> re) {
   FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kJscreDataIndex));
   return ByteArray::cast(value->get(kJscreInternalIndex));
 }
 
 
-int RegExpImpl::Re2kNumberOfCaptures(Handle<JSRegExp> re) {
-  FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kRe2kDataIndex));
-  return Smi::cast(value->get(kRe2kNumberOfCapturesIndex))->value();
+int RegExpImpl::IrregexpNumberOfCaptures(Handle<JSRegExp> re) {
+  FixedArray* value =
+      FixedArray::cast(re->DataAt(JSRegExp::kIrregexpDataIndex));
+  return Smi::cast(value->get(kIrregexpNumberOfCapturesIndex))->value();
 }
 
 
-int RegExpImpl::Re2kNumberOfRegisters(Handle<JSRegExp> re) {
-  FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kRe2kDataIndex));
-  return Smi::cast(value->get(kRe2kNumberOfRegistersIndex))->value();
+int RegExpImpl::IrregexpNumberOfRegisters(Handle<JSRegExp> re) {
+  FixedArray* value =
+      FixedArray::cast(re->DataAt(JSRegExp::kIrregexpDataIndex));
+  return Smi::cast(value->get(kIrregexpNumberOfRegistersIndex))->value();
 }
 
 
-Handle<ByteArray> RegExpImpl::Re2kCode(Handle<JSRegExp> re) {
-  FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kRe2kDataIndex));
-  return Handle<ByteArray>(ByteArray::cast(value->get(kRe2kCodeIndex)));
+Handle<ByteArray> RegExpImpl::IrregexpCode(Handle<JSRegExp> re) {
+  FixedArray* value =
+      FixedArray::cast(re->DataAt(JSRegExp::kIrregexpDataIndex));
+  return Handle<ByteArray>(ByteArray::cast(value->get(kIrregexpCodeIndex)));
 }
 
 
 // -------------------------------------------------------------------
 // New regular expression engine
 
 
 void RegExpTree::AppendToText(RegExpText* text) {
   UNREACHABLE();
 }
@@ skipping 61 matching lines @@
   EndNode* accept_;
   EndNode* backtrack_;
   int next_register_;
   List<RegExpNode*>* work_list_;
   int recursion_depth_;
   RegExpMacroAssembler* macro_assembler_;
   bool is_case_independent_;
 };
 
 
-// Attempts to compile the regexp using a Regexp2000 code generator.  Returns
+// Attempts to compile the regexp using an Irregexp code generator.  Returns
 // a fixed array or a null handle depending on whether it succeeded.
 RegExpCompiler::RegExpCompiler(int capture_count, bool ignore_case)
   : next_register_(2 * (capture_count + 1)),
     work_list_(NULL),
     recursion_depth_(0),
     is_case_independent_(ignore_case) {
   accept_ = new EndNode(EndNode::ACCEPT);
   backtrack_ = new EndNode(EndNode::BACKTRACK);
 }
 
@@ skipping 16 matching lines @@
   }
   while (!work_list.is_empty()) {
     if (!work_list.RemoveLast()->GoTo(this)) {
       fail.Unuse();
       return Handle<FixedArray>::null();
     }
   }
   macro_assembler->Bind(&fail);
   macro_assembler->Fail();
   Handle<FixedArray> array =
-      Factory::NewFixedArray(RegExpImpl::kRe2kDataLength);
-  array->set(RegExpImpl::kRe2kImplementationIndex,
+      Factory::NewFixedArray(RegExpImpl::kIrregexpDataLength);
+  array->set(RegExpImpl::kIrregexpImplementationIndex,
              Smi::FromInt(macro_assembler->Implementation()));
-  array->set(RegExpImpl::kRe2kNumberOfRegistersIndex,
+  array->set(RegExpImpl::kIrregexpNumberOfRegistersIndex,
              Smi::FromInt(next_register_));
-  array->set(RegExpImpl::kRe2kNumberOfCapturesIndex,
+  array->set(RegExpImpl::kIrregexpNumberOfCapturesIndex,
              Smi::FromInt(capture_count));
   Handle<Object> code = macro_assembler->GetCode();
-  array->set(RegExpImpl::kRe2kCodeIndex, *code);
+  array->set(RegExpImpl::kIrregexpCodeIndex, *code);
   work_list_ = NULL;
   return array;
 }
 
 
 bool RegExpNode::GoTo(RegExpCompiler* compiler) {
   // TODO(erikcorry): Implement support.
   if (info_.follows_word_interest ||
       info_.follows_newline_interest ||
       info_.follows_start_interest) {
@@ skipping 327 matching lines @@
   // First, handle straight character matches.
   for (int i = 0; i < element_count; i++) {
     TextElement elm = elms_->at(i);
     if (elm.type == TextElement::ATOM) {
       Vector<const uc16> quarks = elm.data.u_atom->data();
       if (!compiler->is_case_independent()) {
         macro_assembler->CheckCharacters(quarks,
                                          cp_offset,
                                          on_failure_->label());
       } else {
-        EmitAtomNonLetters(macro_assembler, elm, quarks, on_failure_->label(), cp_offset);
+        EmitAtomNonLetters(macro_assembler,
+                           elm,
+                           quarks,
+                           on_failure_->label(),
+                           cp_offset);
       }
       cp_offset += quarks.length();
     } else {
       ASSERT_EQ(elm.type, TextElement::CHAR_CLASS);
       cp_offset++;
     }
   }
   // Second, handle case independent letter matches if any.
   if (compiler->is_case_independent()) {
     cp_offset = 0;
     for (int i = 0; i < element_count; i++) {
       TextElement elm = elms_->at(i);
       if (elm.type == TextElement::ATOM) {
         Vector<const uc16> quarks = elm.data.u_atom->data();
-        EmitAtomLetters(macro_assembler, elm, quarks, on_failure_->label(), cp_offset);
+        EmitAtomLetters(macro_assembler,
+                        elm,
+                        quarks,
+                        on_failure_->label(),
+                        cp_offset);
         cp_offset += quarks.length();
       } else {
         cp_offset++;
       }
     }
   }
   // If the fast character matches passed then do the character classes.
   cp_offset = 0;
   for (int i = 0; i < element_count; i++) {
     TextElement elm = elms_->at(i);
@@ skipping 1219 matching lines @@
                                               RegExpQuantifier::kInfinity,
                                               false,
                                               new RegExpCharacterClass('*'),
                                               &compiler,
                                               captured_body,
                                               compiler.backtrack());
   if (node_return != NULL) *node_return = node;
   Analysis analysis;
   analysis.EnsureAnalyzed(node);
 
+  if (!FLAG_irregexp) {
+    return Handle<FixedArray>::null();
+  }
+
 #if !(defined ARM || defined __arm__ || defined __thumb__)
-  if (FLAG_re2k_native) {  // Flag only checked in IA32 mode.
+  if (FLAG_irregexp_native) {  // Flag only checked in IA32 mode.
     // TODO(lrn) Move compilation to a later point in the life-cycle
     // of the RegExp. We don't know the type of input string yet.
     // For now, always assume two-byte strings.
     RegExpMacroAssemblerIA32 macro_assembler(RegExpMacroAssemblerIA32::UC16,
                                              (input->capture_count + 1) * 2,
                                              ignore_case);
     return compiler.Assemble(&macro_assembler,
                              node,
                              input->capture_count);
   }
 #endif
   byte codes[1024];
-  Re2kAssembler assembler(Vector<byte>(codes, 1024));
-  RegExpMacroAssemblerRe2k macro_assembler(&assembler);
+  IrregexpAssembler assembler(Vector<byte>(codes, 1024));
+  RegExpMacroAssemblerIrregexp macro_assembler(&assembler);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count);
 }
 
 
 }}  // namespace v8::internal