Implement fromEnvironment on bool, int and String

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"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/dbg_connection.h"
 #include "bin/directory.h"
 #include "bin/eventhandler.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
 #include "bin/isolate_data.h"
 #include "bin/log.h"
 #include "bin/platform.h"
 #include "bin/process.h"
 #include "bin/vmservice_impl.h"
 #include "platform/globals.h"
+#include "platform/hashmap.h"
 
 namespace dart {
 namespace bin {
 
 // snapshot_buffer points to a snapshot if we link in a snapshot otherwise
 // it is initialized to NULL.
 extern const uint8_t* snapshot_buffer;
 
 // Global state that stores a pointer to the application script snapshot.
 static bool generate_script_snapshot = false;
@@ skipping 30 matching lines @@
 // Global flag that is used to indicate that we want to print the source code
 // for script that is being run.
 static bool has_print_script = false;
 
 
 // VM Service options.
 static bool start_vm_service = false;
 static int vm_service_server_port = -1;
 static const int DEFAULT_VM_SERVICE_SERVER_PORT = 8181;
 
+// The environment provided through the command line using -D options.
+static dart::HashMap* environment = 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));
 }
 
 
@@ skipping 40 matching lines @@
 static bool ProcessPackageRootOption(const char* arg) {
   ASSERT(arg != NULL);
   if (*arg == '\0' || *arg == '-') {
     return false;
   }
   package_root = arg;
   return true;
 }
 
 
+static void* GetHashmapKeyFromString(char* key) {
+  return reinterpret_cast<void*>(key);
+}
+
+static bool ProcessEnvironmentOption(const char* arg) {
+  ASSERT(arg != NULL);
+  if (*arg == '\0') {
+    // Ignore empty -D option.
+    Log::PrintErr("No arguments given to -D option\n");
+    return true;
+  }
+  if (environment == NULL) {
+    environment = new HashMap(&HashMap::SameStringValue, 4);
+  }
+  // Split the name=value part of the -Dname=value argument.
+  char* name;
+  char* value = NULL;
+  const char* equals_pos = strchr(arg, '=');
+  if (equals_pos == NULL) {
+    // No equal sign (name without value) currently not supported.
+    Log::PrintErr("No value given to -D option\n");
+    return false;
+  } else {
+    int name_len = equals_pos - arg;
+    if (name_len == 0) {
+      Log::PrintErr("No name given to -D option\n");
+      return false;
+    }
+    // Split name=value into name and value.
+    name = reinterpret_cast<char*>(malloc(name_len + 1));
+    strncpy(name, arg, name_len);
+    name[name_len] = '\0';
+    value = strdup(equals_pos + 1);
+  }
+  HashMap::Entry* entry = environment->Lookup(
+      GetHashmapKeyFromString(name), HashMap::StringHash(name), true);
+  ASSERT(entry != NULL);  // Lookup adds an entry if key not found.
+  entry->value = value;
+  return true;
+}
+
+
 static bool ProcessCompileAllOption(const char* arg) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   has_compile_all = true;
   return true;
 }
 
 
@@ skipping 94 matching lines @@
   const char* option_name;
   bool (*process)(const char* option);
 } main_options[] = {
   // Standard options shared with dart2js.
   { "--version", ProcessVersionOption },
   { "--help", ProcessHelpOption },
   { "-h", ProcessHelpOption },
   { "--verbose", ProcessVerboseOption },
   { "-v", ProcessVerboseOption },
   { "--package-root=", ProcessPackageRootOption },
+  { "-D", ProcessEnvironmentOption },
   // VM specific options to the standalone dart program.
   { "--break-at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
   { "--snapshot=", ProcessGenScriptSnapshotOption },
   { "--print-script", ProcessPrintScriptOption },
   { "--check-function-fingerprints", ProcessFingerprintedFunctions },
   { "--enable-vm-service", ProcessEnableVmServiceOption },
   { "--trace-debug-protocol", ProcessTraceDebugProtocolOption },
   { NULL, NULL }
@@ skipping 136 matching lines @@
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     *error = strdup(Dart_GetError(result));                                    \
     *is_compile_error = Dart_IsCompilationError(result);                       \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     return NULL;                                                               \
   }                                                                            \
 
 
+static Dart_Handle EnvironmentCallback(Dart_Handle name) {
+  uint8_t* utf8_array;
+  intptr_t utf8_len;
+  Dart_Handle result = Dart_Null();
+  Dart_Handle handle = Dart_StringToUTF8(name, &utf8_array, &utf8_len);
+  if (Dart_IsError(handle)) {
+    handle = Dart_ThrowException(
+        DartUtils::NewDartArgumentError(Dart_GetError(handle)));
+  } else {
+    char* name_chars = reinterpret_cast<char*>(malloc(utf8_len + 1));
+    memmove(name_chars, utf8_array, utf8_len);
+    name_chars[utf8_len] = '\0';
+    const char* value = NULL;
+    if (environment != NULL) {
+      HashMap::Entry* entry = environment->Lookup(
+          GetHashmapKeyFromString(name_chars),
+          HashMap::StringHash(name_chars),
+          false);
+      if (entry != NULL) {
+        value = reinterpret_cast<char*>(entry->value);
+      }
+    }
+    if (value != NULL) {
+      result = Dart_NewStringFromUTF8(reinterpret_cast<const uint8_t*>(value),
+                                      strlen(value));
+    }
+    free(name_chars);
+  }
+  return result;
+}
+
+
 // Returns true on success, false on failure.
 static Dart_Isolate CreateIsolateAndSetupHelper(const char* script_uri,
                                                 const char* main,
                                                 void* data,
                                                 char** error,
                                                 bool* is_compile_error) {
   Dart_Isolate isolate =
       Dart_CreateIsolate(script_uri, main, snapshot_buffer, data, error);
   if (isolate == NULL) {
     return NULL;
   }
 
   Dart_EnterScope();
 
   if (snapshot_buffer != NULL) {
     // Setup the native resolver as the snapshot does not carry it.
     Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
     Builtin::SetNativeResolver(Builtin::kIOLibrary);
   }
 
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
   CHECK_RESULT(result);
 
+  result = Dart_SetEnvironmentCallback(EnvironmentCallback);
+  CHECK_RESULT(result);
+
   // Load the specified application script into the newly created isolate.
 
   // Prepare builtin and its dependent libraries for use to resolve URIs.
   // The builtin library is part of the core snapshot and would already be
   // available here in the case of script snapshot loading.
   Dart_Handle builtin_lib =
       Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
   CHECK_RESULT(builtin_lib);
 
   // Prepare for script loading by setting up the 'print' and 'timer'
@@ skipping 460 matching lines @@
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   Dart_Cleanup();
 
   // Free copied argument strings if converted.
   if (argv_converted) {
     for (int i = 0; i < argc; i++) free(argv[i]);
   }
 
+  // Free environment if any.
+  if (environment != NULL) {
+    for (HashMap::Entry* p = environment->Start();
+         p != NULL;
+         p = environment->Next(p)) {
+      free(p->key);
+      free(p->value);
+    }
+    free(environment);
+  }
+
   return Process::GlobalExitCode();
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }