- Add the ability to pass the command line options as an argument to main.

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 342 matching lines @@
   // Parse out options to be passed to dart main.
   while (i < argc) {
     dart_options->AddArgument(argv[i]);
     i++;
   }
 
   return 0;
 }
 
 
-static Dart_Handle SetupRuntimeOptions(CommandLineOptions* options,
-                                       const char* script_name) {
+static Dart_Handle CreateRuntimeOptions(CommandLineOptions* options) {
   int options_count = options->count();
   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;
     }
   }
+  return dart_arguments;
+}
+
+
+static Dart_Handle SetupRuntimeOptions(CommandLineOptions* options) {
+  Dart_Handle dart_arguments = CreateRuntimeOptions(options);
+  if (Dart_IsError(dart_arguments)) {
+    return dart_arguments;
+  }
   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 runtime_options_class_name = DartUtils::NewString("_OptionsImpl");
   if (Dart_IsError(runtime_options_class_name)) {
@@ skipping 429 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, script_name);
+    Dart_Handle options_result = SetupRuntimeOptions(&dart_options);
     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);
     }
     // Set debug breakpoint if specified on the command line.
     if (breakpoint_at != NULL) {
       result = SetBreakpoint(breakpoint_at, library);
       if (Dart_IsError(result)) {
         return ErrorExit(kErrorExitCode,
                          "Error setting breakpoint at '%s': %s\n",
                          breakpoint_at,
                          Dart_GetError(result));
       }
     }
     if (has_print_script) {
       result = GenerateScriptSource();
       if (Dart_IsError(result)) {
         return DartErrorExit(result);
       }
     } else {
       // Lookup and invoke the top level main function.
-      result = Dart_Invoke(library, DartUtils::NewString("main"), 0, NULL);
+      Dart_Handle main_args[1];
+      main_args[0] = CreateRuntimeOptions(&dart_options);
+      result = Dart_Invoke(library, DartUtils::NewString("main"), 1, main_args);
+      // TODO(iposva): Return a special error type for mismatched argument
+      // counts from Dart_Invoke to avoid the string comparison.
+      const char* expected_error = "Dart_Invoke: wrong argument count for "
+          "function 'main': 1 passed, 0 expected.";
+      if (Dart_IsError(result) &&
+          strcmp(expected_error, Dart_GetError(result)) == 0) {
+        result = Dart_Invoke(library, DartUtils::NewString("main"), 0, NULL);
+      }
       if (Dart_IsError(result)) {
         return DartErrorExit(result);
       }
 
       // Keep handling messages until the last active receive port is closed.
       result = Dart_RunLoop();
       if (Dart_IsError(result)) {
         return DartErrorExit(result);
       }
     }
@@ skipping 14 matching lines @@
 
   return Process::GlobalExitCode();
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }