Separate native and interpreted regexp by compile time flag, not runtime.

test/cctest/test-debug.cc

 // Copyright 2007-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 4874 matching lines @@
   // Call f then g. The debugger statement in f will casue a break which will
   // cause another break.
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, message_handler_break_hit_count);
   // Calling g will not cause any additional breaks.
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, message_handler_break_hit_count);
 }
 
 
+#ifdef V8_NATIVE_REGEXP
 // Debug event handler which gets the function on the top frame and schedules a
 // break a number of times.
 static void DebugEventDebugBreak(
     v8::DebugEvent event,
     v8::Handle<v8::Object> exec_state,
     v8::Handle<v8::Object> event_data,
     v8::Handle<v8::Value> data) {
 
   if (event == v8::Break) {
     break_point_hit_count++;
@@ skipping 16 matching lines @@
 
     // Keep forcing breaks.
     if (break_point_hit_count < 20) {
       v8::Debug::DebugBreak();
     }
   }
 }
 
 
 TEST(RegExpDebugBreak) {
+  // This test only applies to native regexps.
   v8::HandleScope scope;
   DebugLocalContext env;
 
-  i::FLAG_regexp_native = true;
-
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
   // Test RegExp which matches white spaces and comments at the begining of a
   // source line.
   const char* script =
     "var sourceLineBeginningSkip = /^(?:[ \\v\\h]*(?:\\/\\*.*?\\*\\/)*)*/;\n"
     "function f(s) { return s.match(sourceLineBeginningSkip)[0].length; }";
 
   v8::Local<v8::Function> f = CompileFunction(script, "f");
   const int argc = 1;
   v8::Handle<v8::Value> argv[argc] = { v8::String::New("  /* xxx */ a=0;") };
   v8::Local<v8::Value> result = f->Call(env->Global(), argc, argv);
   CHECK_EQ(12, result->Int32Value());
 
   v8::Debug::SetDebugEventListener(DebugEventDebugBreak);
   v8::Debug::DebugBreak();
   result = f->Call(env->Global(), argc, argv);
 
   CHECK_EQ(20, break_point_hit_count);
   CHECK_EQ("exec", last_function_hit);
 }
+#endif  // V8_NATIVE_REGEXP
 
 
 // Common part of EvalContextData and NestedBreakEventContextData tests.
 static void ExecuteScriptForContextCheck() {
   // Create a context.
   v8::Persistent<v8::Context> context_1;
   v8::Handle<v8::ObjectTemplate> global_template =
       v8::Handle<v8::ObjectTemplate>();
   v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>();
   context_1 = v8::Context::New(NULL, global_template, global_object);
@@ skipping 317 matching lines @@
 
   // If the script is compiled successfully there is exactly one after compile
   // event. In case of an exception in debugger code after compile event is not
   // sent.
   CHECK_EQ(1, after_compile_message_count);
 
   ClearBreakPointFromJS(sbp1);
   ClearBreakPointFromJS(sbp2);
   v8::Debug::SetMessageHandler2(NULL);
 }