Make the values of Platform.executable and Platform.script available to all isolates

runtime/bin/main.cc

 // Copyright (c) 2012, 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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
@@ skipping 271 matching lines @@
   ShellUtils::FreeUnicodeArgv(unicode_argv);
   return true;
 }
 
 
 // Parse out the command line arguments. Returns -1 if the arguments
 // are incorrect, 0 otherwise.
 static int ParseArguments(int argc,
                           char** argv,
                           CommandLineOptions* vm_options,
-                          char** executable_name,
                           char** script_name,
                           CommandLineOptions* dart_options,
                           bool* print_flags_seen,
                           bool* verbose_debug_seen) {
   const char* kPrefix = "--";
   const intptr_t kPrefixLen = strlen(kPrefix);
 
-  // Get the executable name.
-  *executable_name = argv[0];
+  // Store the executable name.
+  Platform::SetExecutableName(argv[0]);
 
   // Start the rest after the executable name.
   int i = 1;
 
   // Parse out the vm options.
   while (i < argc) {
     if (ProcessMainOptions(argv[i])) {
       i++;
     } else {
       // Check if this flag is a potentially valid VM flag.
@@ skipping 41 matching lines @@
   while (i < argc) {
     dart_options->AddArgument(argv[i]);
     i++;
   }
 
   return 0;
 }
 
 
 static Dart_Handle SetupRuntimeOptions(CommandLineOptions* options,
-                                       const char* executable_name,
                                        const char* script_name) {
   int options_count = options->count();
-  Dart_Handle dart_executable = DartUtils::NewString(executable_name);
-  if (Dart_IsError(dart_executable)) {
-    return dart_executable;
-  }
-  Dart_Handle dart_script = DartUtils::NewString(script_name);
-  if (Dart_IsError(dart_script)) {
-    return dart_script;
-  }
   Dart_Handle dart_arguments = Dart_NewList(options_count);
   if (Dart_IsError(dart_arguments)) {
     return dart_arguments;
   }
   for (int i = 0; i < options_count; i++) {
     Dart_Handle argument_value =
         DartUtils::NewString(options->GetArgument(i));
     if (Dart_IsError(argument_value)) {
       return argument_value;
     }
     Dart_Handle result = Dart_ListSetAt(dart_arguments, i, argument_value);
     if (Dart_IsError(result)) {
       return result;
     }
   }
   Dart_Handle io_lib_url = DartUtils::NewString("dart:io");
   if (Dart_IsError(io_lib_url)) {
     return io_lib_url;
   }
   Dart_Handle io_lib = Dart_LookupLibrary(io_lib_url);
   if (Dart_IsError(io_lib)) {
     return io_lib;
   }
-  Dart_Handle platform_class_name = DartUtils::NewString("Platform");
-  if (Dart_IsError(platform_class_name)) {
-    return platform_class_name;
-  }
-  Dart_Handle platform_type =
-      Dart_GetType(io_lib, platform_class_name, 0, NULL);
-  if (Dart_IsError(platform_type)) {
-    return platform_type;
-  }
-  Dart_Handle executable_name_name = DartUtils::NewString("_nativeExecutable");
-  if (Dart_IsError(executable_name_name)) {
-    return executable_name_name;
-  }
-  Dart_Handle set_executable_name =
-      Dart_SetField(platform_type,
-                    executable_name_name,
-                    dart_executable);
-  if (Dart_IsError(set_executable_name)) {
-    return set_executable_name;
-  }
-  Dart_Handle script_name_name = DartUtils::NewString("_nativeScript");
-  if (Dart_IsError(script_name_name)) {
-    return script_name_name;
-  }
-  Dart_Handle set_script_name =
-      Dart_SetField(platform_type, script_name_name, dart_script);
-  if (Dart_IsError(set_script_name)) {
-    return set_script_name;
-  }
   Dart_Handle runtime_options_class_name = DartUtils::NewString("_OptionsImpl");
   if (Dart_IsError(runtime_options_class_name)) {
     return runtime_options_class_name;
   }
   Dart_Handle runtime_options_type = Dart_GetType(
       io_lib, runtime_options_class_name, 0, NULL);
   if (Dart_IsError(runtime_options_type)) {
     return runtime_options_type;
   }
   Dart_Handle native_name = DartUtils::NewString("_nativeArguments");
@@ skipping 57 matching lines @@
     char errbuf[256];
     snprintf(errbuf, sizeof(errbuf),
              "Expected a library when loading script: %s",
              script_uri);
     *error = strdup(errbuf);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     return NULL;
   }
 
+  Dart_Handle io_lib_url = DartUtils::NewString("dart:io");
+  CHECK_RESULT(io_lib_url);
+  Dart_Handle io_lib = Dart_LookupLibrary(io_lib_url);
+  CHECK_RESULT(io_lib);
+  Dart_Handle platform_class_name = DartUtils::NewString("Platform");
+  CHECK_RESULT(platform_class_name);
+  Dart_Handle platform_type =
+      Dart_GetType(io_lib, platform_class_name, 0, NULL);
+  CHECK_RESULT(platform_type);
+  Dart_Handle script_name_name = DartUtils::NewString("_nativeScript");
+  CHECK_RESULT(script_name_name);
+  Dart_Handle dart_script = DartUtils::NewString(script_uri);
+  CHECK_RESULT(dart_script);
+  Dart_Handle set_script_name =
+      Dart_SetField(platform_type, script_name_name, dart_script);
+  CHECK_RESULT(set_script_name);
+
   VmService::SendIsolateStartupMessage(Dart_GetMainPortId());
 
   // Make the isolate runnable so that it is ready to handle messages.
   Dart_ExitScope();
   Dart_ExitIsolate();
   bool retval = Dart_IsolateMakeRunnable(isolate);
   if (!retval) {
     *error = strdup("Invalid isolate state - Unable to make it runnable");
     Dart_EnterIsolate(isolate);
     Dart_ShutdownIsolate();
@@ skipping 176 matching lines @@
     if (Dart_IsError(result)) {
       return result;
     }
     Log::Print("%s\n", script_source);
   }
   return Dart_True();
 }
 
 
 int main(int argc, char** argv) {
-  char* executable_name;
   char* script_name;
   CommandLineOptions vm_options(argc);
   CommandLineOptions dart_options(argc);
   bool print_flags_seen = false;
   bool verbose_debug_seen = false;
 
   // Perform platform specific initialization.
   if (!Platform::Initialize()) {
     Log::PrintErr("Initialization failed\n");
   }
 
   // On Windows, the argv strings are code page encoded and not
   // utf8. We need to convert them to utf8.
   bool argv_converted = Utf8ConvertArgv(argc, argv);
 
   // Parse command line arguments.
   if (ParseArguments(argc,
                      argv,
                      &vm_options,
-                     &executable_name,
                      &script_name,
                      &dart_options,
                      &print_flags_seen,
                      &verbose_debug_seen) < 0) {
     if (has_help_option) {
       PrintUsage();
       return 0;
     } else if (has_version_option) {
       PrintVersion();
       return 0;
@@ skipping 96 matching lines @@
 
     if (has_check_function_fingerprints) {
       result = Dart_CheckFunctionFingerprints();
       if (Dart_IsError(result)) {
         return DartErrorExit(result);
       }
     }
 
     // Create a dart options object that can be accessed from dart code.
     Dart_Handle options_result =
-        SetupRuntimeOptions(&dart_options, executable_name, script_name);
+        SetupRuntimeOptions(&dart_options, script_name);
     if (Dart_IsError(options_result)) {
       return DartErrorExit(options_result);
     }
     // Lookup the library of the root script.
     Dart_Handle library = Dart_RootLibrary();
     if (Dart_IsNull(library)) {
       return ErrorExit(kErrorExitCode,
                        "Unable to find root library for '%s'\n",
                        script_name);
     }
@@ skipping 41 matching lines @@
 
   return Process::GlobalExitCode();
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }