Support command line parameters to specify a url to file name mapping. This is used during snapsh...

bin/gen_snapshot.cc

 // Copyright (c) 2011, 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.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 
 #include "bin/builtin.h"
 #include "bin/file.h"
 #include "bin/globals.h"
 #include "bin/process_script.h"
 
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
 static const char* snapshot_filename = NULL;
 
+// Global state that captures the URL mappings specified on the command line.
+static CommandLineOptions* url_mapping = NULL;
+
 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 const char* ProcessOption(const char* option, const char* name) {
   const intptr_t length = strlen(name);
   if (strncmp(option, name, length) == 0) {
     return (option + length);
   }
   return NULL;
 }
 
 
 static bool ProcessSnapshotOption(const char* option) {
   const char* kSnapshotOption = "--snapshot=";
-  snapshot_filename = ProcessOption(option, kSnapshotOption);
-  return snapshot_filename != NULL;
+  const char* name = ProcessOption(option, kSnapshotOption);
+  if (name != NULL) {
+    snapshot_filename = name;
+    return true;
+  }
+  return false;
+}
+
+
+static bool ProcessURLmappingOption(const char* option) {
+  const char* kURLmappingOption = "--url_mapping=";
+  const char* mapping = ProcessOption(option, kURLmappingOption);
+  if (mapping != NULL) {
+    url_mapping->AddArgument(mapping);
+    return true;
+  }
+  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** script_name) {
   const char* kPrefix = "--";
   const intptr_t kPrefixLen = strlen(kPrefix);
 
   // Skip the binary name.
   int i = 1;
 
   // Parse out the vm options.
   while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
-    if (ProcessSnapshotOption(argv[i])) {
+    if (ProcessSnapshotOption(argv[i]) || ProcessURLmappingOption(argv[i])) {
       i += 1;
       continue;
     }
     vm_options->AddArgument(argv[i]);
     i += 1;
   }
 
   // Get the script name.
   if (i < argc) {
     *script_name = argv[i];
@@ skipping 10 matching lines @@
   const bool kWritable = true;
   File* file = File::Open(snapshot_filename, kWritable);
   ASSERT(file != NULL);
   for (intptr_t i = 0; i < size; i++) {
     file->WriteByte(buffer[i]);
   }
   delete file;
 }
 
 
+static Dart_Handle CreateSnapshotLibraryTagHandler(Dart_LibraryTag tag,
+                                                   Dart_Handle library,
+                                                   Dart_Handle url) {
+  const bool kDontImportBuiltinLib = false;  // Do not import builtin lib.
+  Dart_Handle mapped_url = url;
+  if ((tag == kCanonicalizeUrl) && (url_mapping != NULL)) {
+    // We need to check if the passed in url is found in the url_mapping array,
+    // in that case return the mapped entry as the cannonical form.
+    if (!Dart_IsString8(url)) {
+      return Dart_Error("url is not a string");
+    }
+    const char* url_chars = NULL;
+    Dart_Handle result = Dart_StringToCString(url, &url_chars);

[Anton Muhin, 2011/11/14 14:02:13]

nit: maybe TODO to switch to API like Dart_StringGet8 later on.

+    if (!Dart_IsValid(result)) {
+      return Dart_Error("accessing url characters failed");
+    }
+    for (int idx = 0; idx < url_mapping->count(); idx++) {
+      const char* url_name = url_mapping->GetArgument(idx);
+      int len = strlen(url_chars);
+      if (!strncmp(url_chars, url_name, len) && (url_name[len] == ',')) {
+        const char* url_mapped_name = url_name + len + 1;
+        if (strlen(url_mapped_name) != 0) {
+          mapped_url = Dart_NewString(url_mapped_name);
+        }
+        break;
+      }
+    }
+  }
+  return LibraryTagHandler(tag, library, mapped_url, kDontImportBuiltinLib);
+}
+
+
+static Dart_Handle LoadSnapshotCreationScript(const char* script_name) {
+  Dart_Handle source = ReadStringFromFile(script_name);
+  if (!Dart_IsValid(source)) {
+    return source;
+  }
+  Dart_Handle url = Dart_NewString(script_name);
+
+  return Dart_LoadScript(url, source, CreateSnapshotLibraryTagHandler);
+}
+
+
 static void* SnapshotCreateCallback(void* data) {
   const char* script_name = reinterpret_cast<const char*>(data);
   Dart_Handle result;
   Dart_EnterScope();
 
   ASSERT(snapshot_filename != NULL);
 
   // If a file is specified on the command line, load it up before a snapshot
   // is created.
   if (script_name != NULL) {
@@ skipping 41 matching lines @@
   fprintf(stderr,
           "dart [<vm-flags>] "
           "[<dart-script-file>]\n");
 }
 
 
 int main(int argc, char** argv) {
   CommandLineOptions vm_options(argc);
   char* script_name;
 
+  // Initialize the URL mapping array.
+  CommandLineOptions url_mapping_array(argc);
+  url_mapping = &url_mapping_array;
+
   // Parse command line arguments.
   if (ParseArguments(argc,
                      argv,
                      &vm_options,
                      &script_name) < 0) {
     PrintUsage();
     return 255;
   }
 
   if (snapshot_filename == NULL) {
@@ skipping 11 matching lines @@
   // and writes out a snapshot.
   Dart_Isolate isolate = Dart_CreateIsolate(NULL, script_name);
   if (isolate == NULL) {
     return 255;
   }
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   return 0;
 }