Support passing an environment variable map to child processes.

runtime/bin/process_win.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 <process.h>
 
 #include "bin/builtin.h"
 #include "bin/process.h"
 #include "bin/eventhandler.h"
 #include "bin/thread.h"
@@ skipping 451 matching lines @@
   }
   os_error_message[os_error_message_len - 1] = '\0';
   return error_code;
 }
 
 
 int Process::Start(const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
+                   char* environment[],
+                   intptr_t environment_length,
                    intptr_t* in,
                    intptr_t* out,
                    intptr_t* err,
                    intptr_t* id,
                    intptr_t* exit_handler,
                    char* os_error_message,
                    int os_error_message_len) {
   // Ensure that the process exit handler thread has been started.
   bool initialized = ExitCodeHandler::EnsureInitialized();
   if (!initialized) {
@@ skipping 96 matching lines @@
   len += written;
   remaining -= written;
   ASSERT(remaining >= 0);
   for (int i = 0; i < arguments_length; i++) {
     written = snprintf(command_line + len, remaining, " %s", arguments[i]);
     len += written;
     remaining -= written;
     ASSERT(remaining >= 0);
   }
 
+  // Create environment block if an environment is supplied.
+  char* environment_block = NULL;
+  if (environment != NULL) {
+    // An environment block is a sequence of zero-terminated strings
+    // followed by a block-terminating zero char.
+    intptr_t block_size = 1;
+    for (intptr_t i = 0; i < environment_length; i++) {
+      block_size += strlen(environment[i]) + 1;
+    }
+    environment_block = new char[block_size];
+    intptr_t block_index = 0;
+    for (intptr_t i = 0; i < environment_length; i++) {
+      printf("%s\n", environment[i]);

[Søren Gjesse, 2012/04/19 12:45:55]

Debugging print

[Mads Ager (google), 2012/04/20 12:24:51]

Removed.

+      intptr_t len = strlen(environment[i]);
+      intptr_t result = snprintf(environment_block + block_index,
+                                 len,
+                                 "%s",
+                                 environment[i]);
+      ASSERT(result == len);
+      block_index += len;
+      environment_block[block_index++] = '\0';
+    }
+    // Block-terminating zero char.
+    environment_block[block_index++] = '\0';
+    ASSERT(block_index == block_size);
+  }
+
   // Create process.
   BOOL result = CreateProcess(NULL,   // ApplicationName
                               command_line,
                               NULL,   // ProcessAttributes
                               NULL,   // ThreadAttributes
                               TRUE,   // InheritHandles
                               0,      // CreationFlags
-                              NULL,   // Environment
+                              environment_block,
                               working_directory,
                               &startup_info,
                               &process_info);
 
-  // Deallocate command-line string.
+  // Deallocate command-line and environment block strings.
   delete[] command_line;
+  delete[] environment_block;
 
   if (result == 0) {
     int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
 
   ProcessInfoList::AddProcess(process_info.dwProcessId,
                               process_info.hProcess,
@@ skipping 30 matching lines @@
   if (!result) {
     return false;
   }
   return true;
 }
 
 
 void Process::TerminateExitCodeHandler() {
   ExitCodeHandler::TerminateExitCodeThread();
 }