added package_root flag to standalone dart vm

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 28 matching lines @@
 // to be generated or not.
 static const char* generate_pprof_symbols_filename = NULL;
 
 
 // Global state that indicates whether there is a debug breakpoint.
 // This pointer points into an argv buffer and does not need to be
 // free'd.
 static const char* breakpoint_at = NULL;
 
 
+// Value of the --package-root flag.
+// (This pointer points into an argv buffer and does not need to be
+// free'd.)
+static const char* package_root = NULL;
+
+
 // Global flag that is used to indicate that we want to compile all the
 // dart functions and not run anything.
 static bool has_compile_all = false;
 
 
 static bool IsValidFlag(const char* name,
                         const char* prefix,
                         intptr_t prefix_length) {
   intptr_t name_length = strlen(name);
   return ((name_length > prefix_length) &&
           (strncmp(name, prefix, prefix_length) == 0));
 }
 
 
 static void ProcessBreakpointOption(const char* funcname) {
   ASSERT(funcname != NULL);
   breakpoint_at = funcname;
 }
 
 
+static void ProcessPackageRootOption(const char* arg) {
+  ASSERT(arg != NULL);
+  package_root = arg;
+}
+
+
 static void ProcessCompileAllOption(const char* compile_all) {
   ASSERT(compile_all != NULL);
   has_compile_all = true;
 }
 
 
 static void ProcessPprofOption(const char* filename) {
   ASSERT(filename != NULL);
   generate_pprof_symbols_filename = filename;
 }
 
 
 static void ProcessImportMapOption(const char* map) {
   ASSERT(map != NULL);
   import_map_options->AddArgument(map);
 }
 
 
 static struct {
   const char* option_name;
   void (*process)(const char* option);
 } main_options[] = {
   { "--break_at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--generate_pprof_symbols=", ProcessPprofOption },
   { "--import_map=", ProcessImportMapOption },
+  { "--package-root=", ProcessPackageRootOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option) {
   int i = 0;
   const char* name = main_options[0].option_name;
   while (name != NULL) {
     int length = strlen(name);
     if (strncmp(option, name, length) == 0) {
@@ skipping 253 matching lines @@
       Dart_ListSetAt(import_map, index, Dart_NewString(name));
       Dart_ListSetAt(import_map, (index + 1), Dart_NewString(map_name));
     } else {
       Dart_ListSetAt(import_map, index, Dart_NewString(name));
       Dart_ListSetAt(import_map, (index + 1), Dart_NewString(""));
     }
     free(name);
   }
   return Dart_LoadScript(script_url, source, LibraryTagHandler, import_map);
 }
 

[siva, 2012/04/27 17:07:46]

Missing blank line (2 blank lines between functions).

[mattsh, 2012/04/27 17:12:06]

Done.

-
+// Returns true on success, false on failure.
 static bool CreateIsolateAndSetup(const char* name_prefix,
                                   void* data, char** error) {
   Dart_Isolate isolate =
       Dart_CreateIsolate(name_prefix, snapshot_buffer, data, error);
   if (isolate == NULL) {
     return false;
   }
 
   Dart_EnterScope();
 
@@ skipping 13 matching lines @@
   if (Dart_IsError(builtin_lib)) {
     *error = strdup(Dart_GetError(builtin_lib));
     return false;
   }
   Dart_Handle library = Dart_LibraryImportLibrary(builtin_lib, uri_lib);
   if (Dart_IsError(library)) {
     *error = strdup(Dart_GetError(library));
     return false;
   }
 
+  if (package_root != NULL) {
+    Dart_Handle dart_args[1];
+
+    Dart_Handle handle = Dart_NewString(package_root);
+    if (Dart_IsError(handle)) {
+      *error = strdup(Dart_GetError(handle));
+      return false;
+    }
+    dart_args[0] = handle;
+
+    Dart_Handle result = Dart_Invoke(builtin_lib,
+        Dart_NewString("_setPackageRoot"), 1, dart_args);
+    if (Dart_IsError(result)) {
+      *error = strdup(Dart_GetError(result));
+      return false;
+    }
+  }
+
   // Load the specified application script into the newly created isolate.
   library = LoadScript(builtin_lib, import_map_options);
   if (Dart_IsError(library)) {
     *error = strdup(Dart_GetError(library));
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     return false;
   }
   if (!Dart_IsLibrary(library)) {
     char errbuf[256];
@@ skipping 186 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;
 }