* Better factoring of ARM/IA32 code in irregexp.

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 25 matching lines @@
 #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-irregexp.h"
 #include "regexp-macro-assembler.h"
 #include "regexp-macro-assembler-irregexp.h"
-#if defined __arm__ || defined __thumb__ || defined ARM
-// include regexp-macro-assembler-arm.h when created.
-#else  // ia32
+
+#ifdef ARM
+#include "regexp-macro-assembler-arm.h"
+#else  // IA32
+#include "macro-assembler-ia32.h"
 #include "regexp-macro-assembler-ia32.h"
 #endif
+
 #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"
@@ skipping 448 matching lines @@
       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 = IrregexpCode(regexp);
 
       rc = IrregexpInterpreter::Match(byte_codes,
                                       two_byte_subject,
                                       offsets_vector,
                                       previous_index);
       break;
     }
-    case RegExpMacroAssembler::kARMImplementation:
-    default:
-      UNREACHABLE();
-      rc = false;
-      break;
     }
   }
 
   if (!rc) {
     return Factory::null_value();
   }
 
   Handle<FixedArray> array = Factory::NewFixedArray(2 * (num_captures+1));
   // The captures come in (start, end+1) pairs.
   for (int i = 0; i < 2 * (num_captures+1); i += 2) {
@@ skipping 50 matching lines @@
   for (int i = 0; i < 2 * (num_captures+1); i += 2) {
     array->set(i, Smi::FromInt(offsets_vector[i]));
     array->set(i+1, Smi::FromInt(offsets_vector[i+1]));
   }
   return Factory::NewJSArrayWithElements(array);
 }
 
 
 class OffsetsVector {
  public:
-  inline OffsetsVector(int num_registers)
-      : offsets_vector_length_(num_registers) {
+  inline OffsetsVector(int num_registers) :
+    offsets_vector_length_(num_registers) {
     if (offsets_vector_length_ > kStaticOffsetsVectorSize) {
       vector_ = NewArray<int>(offsets_vector_length_);
     } else {
       vector_ = static_offsets_vector_;
     }
   }
 
 
   inline ~OffsetsVector() {
     if (offsets_vector_length_ > kStaticOffsetsVectorSize) {
@@ skipping 18 matching lines @@
   static const int kStaticOffsetsVectorSize = 50;
   static int static_offsets_vector_[kStaticOffsetsVectorSize];
 };
 
 
 int OffsetsVector::static_offsets_vector_[
     OffsetsVector::kStaticOffsetsVectorSize];
 
 
 Handle<Object> RegExpImpl::IrregexpExec(Handle<JSRegExp> regexp,
-                                        Handle<String> subject,
-                                        Handle<Object> index) {
+                                    Handle<String> subject,
+                                    Handle<Object> index) {
   ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
   ASSERT(!regexp->DataAt(JSRegExp::kIrregexpDataIndex)->IsUndefined());
 
   // Prepare space for the return values.
   int number_of_registers = IrregexpNumberOfRegisters(regexp);
   OffsetsVector offsets(number_of_registers);
 
   int num_captures = IrregexpNumberOfCaptures(regexp);
 
   int previous_index = static_cast<int>(DoubleToInteger(index->Number()));
@@ skipping 142 matching lines @@
   if (matches->IsNull()) {  // Exited loop normally.
     return result;
   } else {  // Exited loop with the exception in matches.
     return matches;
   }
 }
 
 
 int RegExpImpl::JscreNumberOfCaptures(Handle<JSRegExp> re) {
   FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kJscreDataIndex));
-  return Smi::cast(value->get(kJscreNumberOfCapturesIndex))-> value();
+  return Smi::cast(value->get(kJscreNumberOfCapturesIndex))->
+      value();
 }
 
 
 ByteArray* RegExpImpl::JscreInternal(Handle<JSRegExp> re) {
   FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kJscreDataIndex));
   return ByteArray::cast(value->get(kJscreInternalIndex));
 }
 
 
 int RegExpImpl::IrregexpNumberOfCaptures(Handle<JSRegExp> re) {
@@ skipping 1754 matching lines @@
                                               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_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.
+  if (FLAG_irregexp_native) {
+#ifdef ARM
+    UNIMPLEMENTED();
+#else  // IA32
     RegExpMacroAssemblerIA32 macro_assembler(RegExpMacroAssemblerIA32::UC16,
                                              (input->capture_count + 1) * 2);
     return compiler.Assemble(&macro_assembler,
                              node,
                              input->capture_count);
+#endif
   }
-#endif
   byte codes[1024];
   IrregexpAssembler assembler(Vector<byte>(codes, 1024));
   RegExpMacroAssemblerIrregexp macro_assembler(&assembler);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count);
 }
 
 
 }}  // namespace v8::internal