Simpler regex names:

runtime/vm/regexp_assembler_bytecode.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/regexp_assembler_bytecode.h"
 
 #include "vm/regexp_assembler_bytecode_inl.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/regexp_bytecodes.h"
@@ skipping 434 matching lines @@
   // BOGUS
   buffer_->Add(0);
   buffer_->Add(0);
   buffer_->Add(0);
   buffer_->Add(0);
   intptr_t x = buffer_->length();
   for (intptr_t i = 0; i < x; i++) buffer_->Add(0);
 }
 
 
-static intptr_t Prepare(const JSRegExp& regexp,
+static intptr_t Prepare(const RegExp& regexp,
                         const String& subject,
                         Zone* zone) {
   bool is_one_byte = subject.IsOneByteString() ||
                      subject.IsExternalOneByteString();
 
   if (regexp.bytecode(is_one_byte) == TypedData::null()) {
     const String& pattern = String::Handle(zone, regexp.pattern());
 
     const bool multiline = regexp.is_multi_line();
     RegExpCompileData* compile_data = new(zone) RegExpCompileData();
     if (!RegExpParser::ParseRegExp(pattern, multiline, compile_data)) {
-      // Parsing failures are handled in the JSRegExp factory constructor.
+      // Parsing failures are handled in the RegExp factory constructor.
       UNREACHABLE();
     }
 
     regexp.set_num_bracket_expressions(compile_data->capture_count);
     if (compile_data->simple) {
       regexp.set_is_simple();
     } else {
       regexp.set_is_complex();
     }
 
     RegExpEngine::CompilationResult result =
         RegExpEngine::CompileBytecode(compile_data, regexp, is_one_byte, zone);
     ASSERT(result.bytecode != NULL);
     ASSERT((regexp.num_registers() == -1) ||
            (regexp.num_registers() == result.num_registers));
     regexp.set_num_registers(result.num_registers);
     regexp.set_bytecode(is_one_byte, *(result.bytecode));
   }
 
   ASSERT(regexp.num_registers() != -1);
 
   return regexp.num_registers() +
          (Smi::Value(regexp.num_bracket_expressions()) + 1) * 2;
 }
 
 
-static IrregexpInterpreter::IrregexpResult ExecRaw(const JSRegExp& regexp,
+static IrregexpInterpreter::IrregexpResult ExecRaw(const RegExp& regexp,
                                                    const String& subject,
                                                    intptr_t index,
                                                    int32_t* output,
                                                    intptr_t output_size,
                                                    Zone* zone) {
   bool is_one_byte = subject.IsOneByteString() ||
                      subject.IsExternalOneByteString();
 
   ASSERT(regexp.num_bracket_expressions() != Smi::null());
 
@@ skipping 25 matching lines @@
     Isolate* isolate = thread->isolate();
     const Instance& exception =
         Instance::Handle(isolate->object_store()->stack_overflow());
     Exceptions::Throw(thread, exception);
     UNREACHABLE();
   }
   return result;
 }
 
 
-RawInstance* BytecodeRegExpMacroAssembler::Interpret(const JSRegExp& regexp,
+RawInstance* BytecodeRegExpMacroAssembler::Interpret(const RegExp& regexp,
                                                      const String& subject,
                                                      const Smi& start_index,
                                                      Zone* zone) {
   intptr_t required_registers = Prepare(regexp, subject, zone);
   if (required_registers < 0) {
     // Compiling failed with an exception.
     UNREACHABLE();
   }
 
   // V8 uses a shared copy on the isolate when smaller than some threshold.
@@ skipping 34 matching lines @@
   }
   if (result == IrregexpInterpreter::RE_EXCEPTION) {
     UNREACHABLE();
   }
   ASSERT(result == IrregexpInterpreter::RE_FAILURE);
   return Instance::null();
 }
 
 
 }  // namespace dart