Add executable to Options interface to get the name of the executable used to execute the script.

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 145 matching lines @@
   }
   return false;
 }
 
 
 // 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) {
   const char* kPrefix = "--";
   const intptr_t kPrefixLen = strlen(kPrefix);
 
-  // Skip the binary name.
+  // Get the executable name.
+  *executable_name = argv[0];
+
+  // Start the rest after the executable name.
   int i = 1;
 
   // Parse out the vm options.
   while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
     if (ProcessMainOptions(argv[i])) {
-      i += 1;
+      ++i;

[Ivan Posva, 2012/05/07 17:40:36]

i++ is more conventional, no?

[Mads Ager (google), 2012/05/08 06:39:04]

Yes, it is. Done.

     } else {
       vm_options->AddArgument(argv[i]);
-      i += 1;
+      ++i;
     }
   }
   if (generate_pprof_symbols_filename != NULL) {
     Dart_InitPprofSupport();
   }
 
   // Get the script name.
   if (i < argc) {
     *script_name = argv[i];
-    i += 1;
+    ++i;
   } else {
     return -1;
   }
 
   // Parse out options to be passed to dart main.
   while (i < argc) {
     dart_options->AddArgument(argv[i]);
     i += 1;
   }
 
   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 = Dart_NewString(executable_name);
+  if (Dart_IsError(dart_executable)) {
+    return dart_executable;
+  }
   Dart_Handle dart_script = Dart_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 = Dart_NewString(options->GetArgument(i));
@@ skipping 15 matching lines @@
   }
   Dart_Handle runtime_options_class_name = Dart_NewString("RuntimeOptions");
   if (Dart_IsError(runtime_options_class_name)) {
     return runtime_options_class_name;
   }
   Dart_Handle runtime_options_class = Dart_GetClass(
       core_lib, runtime_options_class_name);
   if (Dart_IsError(runtime_options_class)) {
     return runtime_options_class;
   }
+  Dart_Handle executable_name_name = Dart_NewString("_nativeExecutable");
+  if (Dart_IsError(executable_name_name)) {
+    return executable_name_name;
+  }
+  Dart_Handle set_executable_name =
+      Dart_SetField(runtime_options_class,
+                    executable_name_name,
+                    dart_executable);
+  if (Dart_IsError(set_executable_name)) {
+    return set_executable_name;
+  }
   Dart_Handle script_name_name = Dart_NewString("_nativeScript");
   if (Dart_IsError(script_name_name)) {
     return script_name_name;
   }
   Dart_Handle set_script_name =
       Dart_SetField(runtime_options_class, script_name_name, dart_script);
   if (Dart_IsError(set_script_name)) {
     return set_script_name;
   }
   Dart_Handle native_name = Dart_NewString("_nativeArguments");
@@ skipping 309 matching lines @@
 
   free(const_cast<char*>(original_script_name));
   free(const_cast<char*>(original_working_directory));
   free(const_cast<char*>(original_script_url));
 
   return kErrorExitCode;
 }
 
 
 int main(int argc, char** argv) {
+  char* executable_name;
   char* script_name;
   CommandLineOptions vm_options(argc);
   CommandLineOptions dart_options(argc);
   CommandLineOptions import_map(argc);
   import_map_options = &import_map;
 
   // Perform platform specific initialization.
   if (!Platform::Initialize()) {
     fprintf(stderr, "Initialization failed\n");
   }
 
   // Parse command line arguments.
   if (ParseArguments(argc,
                      argv,
                      &vm_options,
+                     &executable_name,
                      &script_name,
                      &dart_options) < 0) {
     PrintUsage();
     return kErrorExitCode;
   }
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
   Dart_Initialize(CreateIsolateAndSetup, NULL);
@@ skipping 23 matching lines @@
 
   if (has_compile_all) {
     result = Dart_CompileAll();
     if (Dart_IsError(result)) {
       return ErrorExit("%s\n", Dart_GetError(result));
     }
   }
 
   // Create a dart options object that can be accessed from dart code.
   Dart_Handle options_result =
-      SetupRuntimeOptions(&dart_options, original_script_name);
+      SetupRuntimeOptions(&dart_options, executable_name, original_script_name);
   if (Dart_IsError(options_result)) {
     return ErrorExit("%s\n", Dart_GetError(options_result));
   }
   // Lookup the library of the main script.
   Dart_Handle script_url = Dart_NewString(original_script_url);
   Dart_Handle library = Dart_LookupLibrary(script_url);
   if (Dart_IsError(library)) {
     return ErrorExit("%s\n", Dart_GetError(library));
   }
   // Set debug breakpoint if specified on the command line.
@@ skipping 30 matching lines @@
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   free(const_cast<char*>(original_script_name));
   free(const_cast<char*>(original_working_directory));
   free(const_cast<char*>(original_script_url));
 
   return 0;
 }