Centralise code to map between UTF-8 and UTF-16 on Windows.

In various places we need to call the Windows API, and because Swift uses UTF-8
for its string representation, we can’t call the ANSI API functions (because the
code page used for the ANSI functions varies depending on the system locale
setting). Instead, we need to use the wide character APIs.

This means that we need to convert UTF-8 to wide character and vice-versa in
various places in the runtime.

rdar://103397975

Author: al45tair

include/swift/Runtime/Win32.h

@@ -0,0 +1,55 @@
+//===--- Win32.h - Win32 utility functions ----------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Utility functions that are specific to the Windows port.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RUNTIME_WIN32_H
+#define SWIFT_RUNTIME_WIN32_H
+
+#ifdef _WIN32
+
+#include "swift/shims/Visibility.h"
+
+#include <wchar.h>
+
+namespace swift {
+namespace win32 {
+
+/// Convert a wide string to UTF-8.
+///
+/// @param str The string to convert.
+///
+/// @returns The string, converted to UTF-8.  The caller is responsible
+///          for freeing this string with @c free() when done with it.
+///
+/// If @a str cannot be converted to UTF-8, a fatal error occurs.
+SWIFT_RUNTIME_STDLIB_INTERNAL
+char *copyUTF8FromWide(const wchar_t *str);
+
+/// Convert a UTF-8 string to a wide string.
+///
+/// @param str The string to convert.
+///
+/// @returns The string, converted to UTF-16.  The caller is responsible
+///          for freeing this string with @c free() when done with it.
+///
+/// If @a str cannot be converted to UTF-16, a fatal error occurs.
+SWIFT_RUNTIME_STDLIB_INTERNAL
+wchar_t *copyWideFromUTF8(const char *str);
+
+}
+}
+#endif // defined(_WIN32)
+
+#endif // SWIFT_RUNTIME_WIN32_H

stdlib/public/CommandLineSupport/CommandLine.cpp

@@ -25,6 +25,7 @@
 #include <string>
 
 #include "swift/Runtime/Debug.h"
+#include "swift/Runtime/Win32.h"
 
 #include "swift/shims/GlobalObjects.h"
 #include "swift/shims/RuntimeStubs.h"
@@ -193,48 +194,6 @@ static void swift::enumerateUnsafeArgv(const F& body) {
 #elif defined(_WIN32)
 #include <stdlib.h>
 
-namespace swift {
-  /// Convert an argument, represented by a wide string, to UTF-8.
-  ///
-  /// @param str The string to convert.
-  /// 
-  /// @returns The string, converted to UTF-8. The caller is responsible for
-  ///   freeing this string when done with it.
-  /// 
-  /// If @a str cannot be converted to UTF-8, a fatal error occurs.
-  static char *copyUTF8FromWide(wchar_t *str) {
-    char *result = nullptr;
-
-    int resultLength = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, str,
-      -1, nullptr, 0, nullptr, nullptr);
-    if (resultLength <= 0) {
-      swift::fatalError(0,
-        "Fatal error: Could not get length of commandline "
-        "argument '%ls': %lu\n",
-        str, GetLastError());
-    }
-
-    result = reinterpret_cast<char *>(malloc(resultLength));
-    if (!result) {
-      swift::fatalError(0,
-        "Fatal error: Could not allocate space for commandline "
-        "argument '%ls': %d\n",
-        str, errno);
-    }
-
-    resultLength = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, str, -1,
-      result, resultLength, nullptr, nullptr);
-    if (resultLength <= 0) {
-      swift::fatalError(0,
-        "Fatal error: Conversion to UTF-8 failed for "
-        "commandline argument '%ls': %lu\n",
-        str, GetLastError());
-    }
-
-    return result;
-  }
-}
-
 static char **swift::getUnsafeArgvArgc(int *outArgLen) {
   return nullptr;
 }
@@ -244,7 +203,7 @@ static void swift::enumerateUnsafeArgv(const F& body) {
   int argc = 0;
   if (LPWSTR *wargv = CommandLineToArgvW(GetCommandLineW(), &argc)) {
     std::for_each(wargv, wargv + argc, [=] (wchar_t *warg) {
-      auto arg = copyUTF8FromWide(warg);
+      auto arg = swift::win32::copyUTF8FromWide(warg);
       body(argc, arg);
       free(arg);
     });

stdlib/public/runtime/CMakeLists.txt

@@ -70,7 +70,8 @@ set(swift_runtime_sources
     SwiftTLSContext.cpp
     ThreadingError.cpp
     AccessibleFunction.cpp
-    RuntimeAttribute.cpp)
+    RuntimeAttribute.cpp
+    Win32.cpp)
 
 # Acknowledge that the following sources are known.
 set(LLVM_OPTIONAL_SOURCES

stdlib/public/runtime/Win32.cpp

@@ -0,0 +1,87 @@
+//===--- Win32.cpp - Win32 utility functions --------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Utility functions that are specific to the Windows port.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Runtime/Debug.h"
+#include "swift/Runtime/Win32.h"
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+char *
+swift::win32::copyUTF8FromWide(const wchar_t *str) {
+  char *result = nullptr;
+  int len = ::WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS,
+                                  str, -1,
+                                  nullptr, 0,
+                                  nullptr, nullptr);
+  if (len <= 0) {
+    swift::fatalError(0, "failed to convert string '%ls' "
+                      "from wide to UTF-8: %lx\n",
+                      str, ::GetLastError());
+  }
+
+  result = reinterpret_cast<char *>(std::malloc(len));
+  if (!result) {
+    swift::fatalError(0, "unable to allocate space to convert '%ls': %d\n",
+                      str, errno);
+  }
+
+  len = ::WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS,
+                              str, -1,
+                              result, len,
+                              nullptr, nullptr);
+
+  if (len <= 0) {
+    swift::fatalError(0, "failed to convert string '%ls' "
+                      "from wide to UTF-8: %lx\n",
+                      str, ::GetLastError());
+  }
+
+  return result;
+}
+
+wchar_t *
+swift::win32::copyWideFromUTF8(const char *str) {
+  wchar_t *result = nullptr;
+  int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
+                                  str, -1,
+                                  nullptr, 0);
+  if (len <= 0) {
+    swift::fatalError(0, "failed to convert string '%s' "
+                      "from UTF-8 to wide: %lx\n",
+                      str, ::GetLastError());
+  }
+
+  result = reinterpret_cast<wchar_t *>(std::malloc(len * sizeof(wchar_t)));
+  if (!result) {
+    swift::fatalError(0, "unable to allocate space to convert '%s': %d\n",
+                      str, errno);
+  }
+
+  len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
+                              str, -1,
+                              result, len);
+  if (len <= 0) {
+    swift::fatalError(0, "failed to convert string '%s' "
+                      "from UTF-8 to wide: %lx\n",
+                      str, ::GetLastError());
+  }
+
+  return result;
+}
+
+#endif // defined(_WIN32)