Use FormatMessageW for Windows error messages to handle internationalized messages correctly.

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/log.h"
@@ skipping 276 matching lines @@
 static void CloseProcessPipes(HANDLE handles1[2],
                               HANDLE handles2[2],
                               HANDLE handles3[2],
                               HANDLE handles4[2]) {
   CloseProcessPipe(handles1);
   CloseProcessPipe(handles2);
   CloseProcessPipe(handles3);
   CloseProcessPipe(handles4);
 }
 
-static int SetOsErrorMessage(char* os_error_message,
-                             int os_error_message_len) {
+
+static int SetOsErrorMessage(char** os_error_message) {
   int error_code = GetLastError();
+  static const int kMaxMessageLength = 256;
+  wchar_t message[kMaxMessageLength];
   DWORD message_size =
-      FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-                    NULL,
-                    error_code,
-                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                    os_error_message,
-                    os_error_message_len,
-                    NULL);
+      FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                     NULL,
+                     error_code,
+                     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                     message,
+                     kMaxMessageLength,
+                     NULL);
   if (message_size == 0) {
     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
       Log::PrintErr("FormatMessage failed %d\n", GetLastError());
     }
-    snprintf(os_error_message, os_error_message_len, "OS Error %d", error_code);
+    _snwprintf(message, kMaxMessageLength, L"OS Error %d", error_code);
   }
-  os_error_message[os_error_message_len - 1] = '\0';
+  message[kMaxMessageLength - 1] = '\0';
+  *os_error_message = StringUtils::WideToUtf8(message);
   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) {
+                   char** os_error_message) {
   HANDLE stdin_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE stdout_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE stderr_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE exit_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
 
   // Generate unique pipe names for the four named pipes needed.
   char pipe_names[4][80];
   UUID uuid;
   RPC_STATUS status = UuidCreateSequential(&uuid);
   if (status != RPC_S_OK && status != RPC_S_UUID_LOCAL_ONLY) {
+    SetOsErrorMessage(os_error_message);
     Log::PrintErr("UuidCreateSequential failed %d\n", status);
-    SetOsErrorMessage(os_error_message, os_error_message_len);
     return status;
   }
   RPC_CSTR uuid_string;
   status = UuidToString(&uuid, &uuid_string);
   if (status != RPC_S_OK) {
+    SetOsErrorMessage(os_error_message);
     Log::PrintErr("UuidToString failed %d\n", status);
-    SetOsErrorMessage(os_error_message, os_error_message_len);
     return status;
   }
   for (int i = 0; i < 4; i++) {
     static const char* prefix = "\\\\.\\Pipe\\dart";
     snprintf(pipe_names[i],
              sizeof(pipe_names[i]),
              "%s_%s_%d", prefix, uuid_string, i + 1);
   }
   status = RpcStringFree(&uuid_string);
   if (status != RPC_S_OK) {
+    SetOsErrorMessage(os_error_message);
     Log::PrintErr("RpcStringFree failed %d\n", status);
-    SetOsErrorMessage(os_error_message, os_error_message_len);
     return status;
   }
 
   if (!CreateProcessPipe(stdin_handles, pipe_names[0], kInheritRead)) {
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
   if (!CreateProcessPipe(stdout_handles, pipe_names[1], kInheritWrite)) {
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
   if (!CreateProcessPipe(stderr_handles, pipe_names[2], kInheritWrite)) {
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
   if (!CreateProcessPipe(exit_handles, pipe_names[3], kInheritNone)) {
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
 
   // Setup info structures.
   STARTUPINFOEX startup_info;
   ZeroMemory(&startup_info, sizeof(startup_info));
   startup_info.StartupInfo.cb = sizeof(startup_info);
   startup_info.StartupInfo.hStdInput = stdin_handles[kReadHandle];
   startup_info.StartupInfo.hStdOutput = stdout_handles[kWriteHandle];
   startup_info.StartupInfo.hStdError = stderr_handles[kWriteHandle];
   startup_info.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
 
   // Setup the handles to inherit. We only want to inherit the three handles
   // for stdin, stdout and stderr.
   SIZE_T size = 0;
   // The call to determine the size of an attribute list always fails with
   // ERROR_INSUFFICIENT_BUFFER and that error should be ignored.
   if (!InitializeProcThreadAttributeList(NULL, 1, 0, &size) &&
       GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
   LPPROC_THREAD_ATTRIBUTE_LIST attribute_list =
       reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(malloc(size));
   ZeroMemory(attribute_list, size);
   if (!InitializeProcThreadAttributeList(attribute_list, 1, 0, &size)) {
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     free(attribute_list);
     return error_code;
   }
   static const int kNumInheritedHandles = 3;
   HANDLE inherited_handles[kNumInheritedHandles] =
       { stdin_handles[kReadHandle],
         stdout_handles[kWriteHandle],
         stderr_handles[kWriteHandle] };
   if (!UpdateProcThreadAttribute(attribute_list,
                                  0,
                                  PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
                                  inherited_handles,
                                  kNumInheritedHandles * sizeof(HANDLE),
                                  NULL,
                                  NULL)) {
     DeleteProcThreadAttributeList(attribute_list);
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     free(attribute_list);
     return error_code;
   }
   startup_info.lpAttributeList = attribute_list;
 
   PROCESS_INFORMATION process_info;
   ZeroMemory(&process_info, sizeof(process_info));
 
   // Transform input strings to system format.
-  path = StringUtils::Utf8ToSystemString(path);
+  path = StringUtils::Utf8ToConsoleString(path);
   for (int i = 0; i < arguments_length; i++) {
-     arguments[i] = StringUtils::Utf8ToSystemString(arguments[i]);
+     arguments[i] = StringUtils::Utf8ToConsoleString(arguments[i]);
   }
 
   // Compute command-line length.
   int command_line_length = strlen(path);
   for (int i = 0; i < arguments_length; i++) {
     command_line_length += strlen(arguments[i]);
   }
   // Account for null termination and one space per argument.
   command_line_length += arguments_length + 1;
   static const int kMaxCommandLineLength = 32768;
   if (command_line_length > kMaxCommandLineLength) {
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     free(const_cast<char*>(path));
     for (int i = 0; i < arguments_length; i++) free(arguments[i]);
     DeleteProcThreadAttributeList(attribute_list);
     free(attribute_list);
     return error_code;
   }
 
   // Put together command-line string.
@@ skipping 11 matching lines @@
     ASSERT(remaining >= 0);
   }
   free(const_cast<char*>(path));
   for (int i = 0; i < arguments_length; i++) free(arguments[i]);
 
   // Create environment block if an environment is supplied.
   char* environment_block = NULL;
   if (environment != NULL) {
     // Convert environment strings to system strings.
     for (intptr_t i = 0; i < environment_length; i++) {
-      environment[i] = StringUtils::Utf8ToSystemString(environment[i]);
+      environment[i] = StringUtils::Utf8ToConsoleString(environment[i]);
     }
 
     // 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++) {
       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);
     for (intptr_t i = 0; i < environment_length; i++) free(environment[i]);
   }
 
   if (working_directory != NULL) {
-    working_directory = StringUtils::Utf8ToSystemString(working_directory);
+    working_directory = StringUtils::Utf8ToConsoleString(working_directory);
   }
 
   // Create process.
   BOOL result = CreateProcess(NULL,   // ApplicationName
                               command_line,
                               NULL,   // ProcessAttributes
                               NULL,   // ThreadAttributes
                               TRUE,   // InheritHandles
                               EXTENDED_STARTUPINFO_PRESENT,
                               environment_block,
                               working_directory,
                               reinterpret_cast<STARTUPINFO*>(&startup_info),
                               &process_info);
 
   // Deallocate command-line and environment block strings.
   delete[] command_line;
   delete[] environment_block;
   if (working_directory != NULL) {
     free(const_cast<char*>(working_directory));
   }
 
   DeleteProcThreadAttributeList(attribute_list);
   free(attribute_list);
 
   if (result == 0) {
-    int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
+    int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
 
   ProcessInfoList::AddProcess(process_info.dwProcessId,
                               process_info.hProcess,
                               exit_handles[kWriteHandle]);
 
   // Connect the three std streams.
@@ skipping 34 matching lines @@
 
 
 void Process::TerminateExitCodeHandler() {
   // Nothing needs to be done on Windows.
 }
 
 
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(GetCurrentProcessId());
 }