removed some unnecessary stuff from d8's initialization

src/d8.cc

 // Copyright 2009 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 470 matching lines @@
 }
 
 
 void Shell::AddHistogramSample(void* histogram, int sample) {
   Counter* counter = reinterpret_cast<Counter*>(histogram);
   counter->AddSample(sample);
 }
 
 void Shell::InstallUtilityScript() {
   Locker lock;
   HandleScope scope;

[Søren Thygesen Gjesse, 2011/06/24 11:36:09]

Maybe add a comment here that when the utility context is created all three
contexts needs access to one another.

+  utility_context_->SetSecurityToken(Undefined());
+  evaluation_context_->SetSecurityToken(Undefined());
   Context::Scope utility_scope(utility_context_);
+
+#ifdef ENABLE_DEBUGGER_SUPPORT
+  // Install the debugger object in the utility scope
+  i::Debug* debug = i::Isolate::Current()->debug();
+  debug->Load();
+  i::Handle<i::JSObject> js_debug
+      = i::Handle<i::JSObject>(debug->debug_context()->global());
+  utility_context_->Global()->Set(String::New("$debug"),
+                                  Utils::ToLocal(js_debug));
+  debug->debug_context()->set_security_token(HEAP->undefined_value());
+#endif
+
   // Run the d8 shell utility script in the utility context
   int source_index = i::NativesCollection<i::D8>::GetIndex("d8");
   i::Vector<const char> shell_source =
       i::NativesCollection<i::D8>::GetRawScriptSource(source_index);
   i::Vector<const char> shell_source_name =
       i::NativesCollection<i::D8>::GetScriptName(source_index);
   Handle<String> source = String::New(shell_source.start(),
       shell_source.length());
   Handle<String> name = String::New(shell_source_name.start(),
       shell_source_name.length());
   Handle<Script> script = Script::Compile(source, name);
   script->Run();
 
   // Mark the d8 shell script as native to avoid it showing up as normal source
   // in the debugger.
   i::Handle<i::Object> compiled_script = Utils::OpenHandle(*script);
   i::Handle<i::Script> script_object = compiled_script->IsJSFunction()
      ? i::Handle<i::Script>(i::Script::cast(
          i::JSFunction::cast(*compiled_script)->shared()->script()))
      : i::Handle<i::Script>(i::Script::cast(
          i::SharedFunctionInfo::cast(*compiled_script)->script()));
   script_object->set_type(i::Smi::FromInt(i::Script::TYPE_NATIVE));
 }
 
+
 #ifdef COMPRESS_STARTUP_DATA_BZ2
 class BZip2Decompressor : public v8::StartupDataDecompressor {
  public:
   virtual ~BZip2Decompressor() { }
 
  protected:
   virtual int DecompressData(char* raw_data,
                              int* raw_data_size,
                              const char* compressed_data,
                              int compressed_data_size) {
@@ skipping 51 matching lines @@
   global_template->Set(String::New("lol_is_enabled"), Boolean::New(false));
 #endif
 
   Handle<ObjectTemplate> os_templ = ObjectTemplate::New();
   AddOSMethods(os_templ);
   global_template->Set(String::New("os"), os_templ);
 
   return global_template;
 }
 
-void Shell::Initialize() {
+
+void Shell::Initialize(bool test_shell) {
 #ifdef COMPRESS_STARTUP_DATA_BZ2
   BZip2Decompressor startup_data_decompressor;
   int bz2_result = startup_data_decompressor.Decompress();
   if (bz2_result != BZ_OK) {
     fprintf(stderr, "bzip error code: %d\n", bz2_result);
     exit(1);
   }
 #endif
 
   Shell::counter_map_ = new CounterMap();
   // Set up counters
   if (i::StrLength(i::FLAG_map_counters) != 0)
     MapCounters(i::FLAG_map_counters);
   if (i::FLAG_dump_counters) {
     V8::SetCounterFunction(LookupCounter);
     V8::SetCreateHistogramFunction(CreateHistogram);
     V8::SetAddHistogramSampleFunction(AddHistogramSample);
   }
 
-  // Initialize the global objects
+  if (test_shell && !i::FLAG_remote_debugger) return;
+
+  Locker lock;
   HandleScope scope;
   Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
-
   utility_context_ = Context::New(NULL, global_template);
-  utility_context_->SetSecurityToken(Undefined());
-  Context::Scope utility_scope(utility_context_);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
-  // Install the debugger object in the utility scope
-  i::Debug* debug = i::Isolate::Current()->debug();
-  debug->Load();
-  i::Handle<i::JSObject> js_debug
-      = i::Handle<i::JSObject>(debug->debug_context()->global());
-  utility_context_->Global()->Set(String::New("$debug"),
-                                  Utils::ToLocal(js_debug));
+  // Start the debugger agent if requested.
+  if (i::FLAG_debugger_agent) {
+    v8::Debug::EnableAgent("d8 shell", i::FLAG_debugger_port, true);
+  }
+
+  // Start the in-process debugger if requested.
+  if (i::FLAG_debugger && !i::FLAG_debugger_agent) {
+    v8::Debug::SetDebugEventListener(HandleDebugEvent);
+  }
 #endif
 }
 
 
 void Shell::RenewEvaluationContext() {
   // Initialize the global objects
   HandleScope scope;
   Handle<ObjectTemplate> global_template = CreateGlobalTemplate();
 
   // (Re-)create the evaluation context
   if (!evaluation_context_.IsEmpty()) {
     evaluation_context_.Dispose();
   }
   evaluation_context_ = Context::New(NULL, global_template);
-  evaluation_context_->SetSecurityToken(Undefined());
+  Context::Scope utility_scope(evaluation_context_);
 
-  Context::Scope utility_scope(utility_context_);
   i::JSArguments js_args = i::FLAG_js_arguments;
   i::Handle<i::FixedArray> arguments_array =
       FACTORY->NewFixedArray(js_args.argc());
   for (int j = 0; j < js_args.argc(); j++) {
     i::Handle<i::String> arg =
         FACTORY->NewStringFromUtf8(i::CStrVector(js_args[j]));
     arguments_array->set(j, *arg);
   }
   i::Handle<i::JSArray> arguments_jsarray =
       FACTORY->NewJSArrayWithElements(arguments_array);
   evaluation_context_->Global()->Set(String::New("arguments"),
                                      Utils::ToLocal(arguments_jsarray));
-
-#ifdef ENABLE_DEBUGGER_SUPPORT
-  i::Debug* debug = i::Isolate::Current()->debug();
-  debug->Load();
-
-  // Set the security token of the debug context to allow access.
-  debug->debug_context()->set_security_token(HEAP->undefined_value());
-
-  // Start the debugger agent if requested.
-  if (i::FLAG_debugger_agent) {
-    v8::Debug::EnableAgent("d8 shell", i::FLAG_debugger_port, true);
-  }
-
-  // Start the in-process debugger if requested.
-  if (i::FLAG_debugger && !i::FLAG_debugger_agent) {
-    v8::Debug::SetDebugEventListener(HandleDebugEvent);
-  }
-#endif
 }
 
 
 void Shell::OnExit() {
   if (i::FLAG_dump_counters) {
     ::printf("+----------------------------------------+-------------+\n");
     ::printf("| Name                                   | Value       |\n");
     ::printf("+----------------------------------------+-------------+\n");
     for (CounterMap::Iterator i(counter_map_); i.More(); i.Next()) {
       Counter* counter = i.CurrentValue();
@@ skipping 65 matching lines @@
   return result;
 }
 
 
 void Shell::RunShell() {
   LineEditor* editor = LineEditor::Get();
   printf("V8 version %s [console: %s]\n", V8::GetVersion(), editor->name());
   if (i::FLAG_debugger) {
     printf("JavaScript debugger enabled\n");
   }
+
   editor->Open();
   while (true) {
     Locker locker;
     HandleScope handle_scope;
     Context::Scope context_scope(evaluation_context_);
     i::SmartPointer<char> input = editor->Prompt(Shell::kPrompt);
     if (input.is_empty())
       break;
     editor->AddHistory(*input);
     Handle<String> name = String::New("(d8)");
@@ skipping 27 matching lines @@
     // For each newline-separated line.
     char* next_line = ReadLine(ptr);
 
     if (*ptr == '#') {
       // Skip comment lines.
       ptr = next_line;
       continue;
     }
 
     Persistent<Context> thread_context = Context::New(NULL, global_template);
-    thread_context->SetSecurityToken(Undefined());
     Context::Scope context_scope(thread_context);
 
     while ((ptr != NULL) && (*ptr != '\0')) {
       char* filename = ptr;
       ptr = ReadWord(ptr);
 
       // Skip empty strings.
       if (strlen(filename) == 0) {
         break;
       }
 
       Handle<String> str = Shell::ReadFile(filename);
       if (str.IsEmpty()) {
         printf("WARNING: %s not found\n", filename);
         break;
       }
 
       Shell::ExecuteString(str, String::New(filename), false, false);
     }
 
     thread_context.Dispose();
     ptr = next_line;
   }
 }
 
-int Shell::RunMain(int argc, char* argv[]) {
+int Shell::RunMain(int argc, char* argv[], bool* executed) {

[Yang, 2011/06/23 21:45:53]

Pass this flag by reference to track whether something is being executed. If so,
do not launch shell unless explicitly requested (by --shell).

   // Default use preemption if threads are created.
   bool use_preemption = true;
 
   // Default to use lowest possible thread preemption interval to test as many
   // edgecases as possible.
   int preemption_interval = 1;
 
   i::List<i::Thread*> threads(1);
 
   {
@@ skipping 24 matching lines @@
         // Ignore any -f flags for compatibility with other stand-alone
         // JavaScript engines.
         continue;
       } else if (strncmp(str, "--", 2) == 0) {
         printf("Warning: unknown flag %s.\nTry --help for options\n", str);
       } else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
         // Execute argument given to -e option directly.
         v8::HandleScope handle_scope;
         v8::Handle<v8::String> file_name = v8::String::New("unnamed");
         v8::Handle<v8::String> source = v8::String::New(argv[++i]);
+        (*executed) = true;
         if (!ExecuteString(source, file_name, false, true)) {
           OnExit();
           return 1;
         }
       } else if (strcmp(str, "-p") == 0 && i + 1 < argc) {
         int size = 0;
         const char* files = ReadChars(argv[++i], &size);
         if (files == NULL) return 1;
         ShellThread* thread =
             new ShellThread(threads.length(),
                             i::Vector<const char>(files, size));
         thread->Start();
         threads.Add(thread);
+        (*executed) = true;
       } else {
         // Use all other arguments as names of files to load and run.
         HandleScope handle_scope;
         Handle<String> file_name = v8::String::New(str);
         Handle<String> source = ReadFile(str);
+        (*executed) = true;
         if (source.IsEmpty()) {
           printf("Error reading '%s'\n", str);
           return 1;
         }
         if (!ExecuteString(source, file_name, false, true)) {
           OnExit();
           return 1;
         }
       }
     }
@@ skipping 13 matching lines @@
   return 0;
 }
 
 
 int Shell::Main(int argc, char* argv[]) {
   // Figure out if we're requested to stress the optimization
   // infrastructure by running tests multiple times and forcing
   // optimization in the last run.
   bool FLAG_stress_opt = false;
   bool FLAG_stress_deopt = false;
-  bool run_shell = (argc == 1);
+  bool FLAG_interactive_shell = false;
+  bool FLAG_test_shell = false;
+  bool FLAG_executed = false;

[Søren Thygesen Gjesse, 2011/06/24 11:36:09]

FLAG_executed -> executed or script_executed. It is not a command line flag.

 
   for (int i = 0; i < argc; i++) {
     if (strcmp(argv[i], "--stress-opt") == 0) {
       FLAG_stress_opt = true;
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--stress-deopt") == 0) {
       FLAG_stress_deopt = true;
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--noalways-opt") == 0) {
       // No support for stressing if we can't use --always-opt.
       FLAG_stress_opt = false;
       FLAG_stress_deopt = false;
     } else if (strcmp(argv[i], "--shell") == 0) {
-      run_shell = true;
+      FLAG_interactive_shell = true;
+      argv[i] = NULL;
+    } else if (strcmp(argv[i], "--test") == 0) {
+      FLAG_test_shell = true;
       argv[i] = NULL;
     }
   }
 
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
 
-  Initialize();
+  Initialize(FLAG_test_shell);
 
   int result = 0;
   if (FLAG_stress_opt || FLAG_stress_deopt) {
     v8::Testing::SetStressRunType(
         FLAG_stress_opt ? v8::Testing::kStressTypeOpt
             : v8::Testing::kStressTypeDeopt);
     int stress_runs = v8::Testing::GetStressRuns();
     for (int i = 0; i < stress_runs && result == 0; i++) {
       printf("============ Stress %d/%d ============\n", i + 1, stress_runs);
       v8::Testing::PrepareStressRun(i);
-      result = RunMain(argc, argv);
+      result = RunMain(argc, argv, &FLAG_executed);
     }
     printf("======== Full Deoptimization =======\n");
     v8::Testing::DeoptimizeAll();
   } else {
-    result = RunMain(argc, argv);
+    result = RunMain(argc, argv, &FLAG_executed);
   }
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   if (i::FLAG_remote_debugger) {
+    InstallUtilityScript();
     RunRemoteDebugger(i::FLAG_debugger_port);
     return 0;
   }
 #endif
 
-  if (run_shell) {
+  // Run interactive shell if explicitly requested or if no script has been
+  // executed, but never on --test
+  if ((FLAG_interactive_shell || !FLAG_executed) && !FLAG_test_shell) {
     InstallUtilityScript();
     RunShell();
   }
 
   v8::V8::Dispose();
 
   return result;
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif