Add a windows launcher program to replace the current .bat files

This is still just an experiment but eventually I hope to remove
the `.bat` files in favor of this executable.

There are several reasons to want to do this:

1. Batch files are notoriously painful to work with and mis-understood.
2. Should be faster (no need to launch cmd.exe).
3. Works around several known issues with .bat files including one that
   is known unsolvable one (see emcc.bat for more details)

Author: sbc100

tools/maint/win32_launcher/README.md

@@ -0,0 +1,11 @@
+Windows Python Script Launcher
+==============================
+
+This directory contains a simple launcher program for windows which is used to
+execute the emscripten compiler entry points using the python interpreter.  It
+uses the its own name (the name of the currently running executable) to
+determine which python script to run and serves the same purpose as the
+``run_python.sh`` script does on non-windows platforms.
+
+We build this executable statically using ``/MT`` so that it is maximally
+portable.

tools/maint/win32_launcher/build.bat

@@ -0,0 +1 @@
+cl launcher.c /Fe:launcher.exe /MT

tools/maint/win32_launcher/build.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
+cd ${SCRIPT_DIR}
+
+x86_64-w64-mingw32-gcc -municode -static-libgcc -static-libstdc++ -s -O2 launcher.c -o launcher.exe -lshlwapi -lshell32

tools/maint/win32_launcher/launcher.c

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2025 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+// Define _WIN32_WINNT to Windows 7 for max portability
+#define _WIN32_WINNT 0x0601
+
+#include <windows.h>
+#include <shellapi.h>
+#include <shlwapi.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#pragma comment(lib, "shlwapi.lib")
+#pragma comment(lib, "shell32.lib")
+
+wchar_t* get_python_executable() {
+  wchar_t* python_exe_w = _wgetenv(L"EMSDK_PYTHON");
+  if (!python_exe_w) {
+    return L"python";
+  }
+  return python_exe_w;
+}
+
+wchar_t* get_long_path(const wchar_t* path) {
+  DWORD path_len = GetFullPathNameW(path, 0, NULL, NULL);
+  if (path_len == 0)
+    abort();
+
+  wchar_t* full_path = malloc(sizeof(wchar_t) * (path_len + 4));
+  if (!full_path)
+    abort();
+
+  wcscpy_s(full_path, path_len + 4, L"\\\\?\\");
+  if (GetFullPathNameW(path, path_len, full_path + 4, NULL) == 0) {
+    abort();
+  }
+  return full_path;
+}
+
+// Get the name of the currently running executable (module)
+wchar_t* get_module_path() {
+  DWORD buffer_size = MAX_PATH;
+  wchar_t* module_path_w = malloc(sizeof(wchar_t) * buffer_size);
+  if (!module_path_w)
+    abort();
+
+  DWORD path_len = GetModuleFileNameW(NULL, module_path_w, buffer_size);
+  while (path_len > 0 && path_len == buffer_size) {
+    buffer_size *= 2;
+    module_path_w = realloc(module_path_w, sizeof(wchar_t) * buffer_size);
+    if (!module_path_w)
+      abort();
+    path_len = GetModuleFileNameW(NULL, module_path_w, buffer_size);
+  }
+
+  if (path_len == 0)
+    abort();
+
+  return module_path_w;
+}
+
+BOOL handle_ccache(wchar_t** application_name, wchar_t** command_line, const wchar_t* launcher_path_w) {
+  wchar_t* ccache_env = _wgetenv(L"_EMCC_CCACHE");
+  if (!_wgetenv(L"_EMCC_CCACHE")) {
+    return FALSE;
+  }
+
+  _wputenv_s(L"_EMCC_CCACHE", L"");
+  *application_name = L"ccache.exe";
+
+  wchar_t* long_launcher_path = get_long_path(launcher_path_w);
+
+  size_t command_line_len = wcslen(*application_name) + wcslen(long_launcher_path) + 5;
+  *command_line = malloc(sizeof(wchar_t) * command_line_len);
+  if (!*command_line) {
+    abort();
+  }
+
+  swprintf(*command_line, command_line_len, L"\"%s\" \"%s\"", *application_name, long_launcher_path);
+  free(long_launcher_path);
+  return TRUE;
+}
+
+int wmain(int argc, wchar_t** argv) {
+  // Unset _PYTHON_SYSCONFIGDATA_NAME to match batch file behavior.
+  _wputenv_s(L"_PYTHON_SYSCONFIGDATA_NAME", L"");
+
+  wchar_t* launcher_path_w = get_module_path();
+
+  wchar_t* launcher_dir = wcsdup(launcher_path_w);
+  PathRemoveFileSpecW(launcher_dir);
+
+  size_t path_len = wcslen(launcher_path_w);
+  wchar_t* launcher_name_w = malloc((path_len + 1) * sizeof(wchar_t));
+  if (!launcher_name_w) {
+    abort();
+  }
+  wcscpy_s(launcher_name_w, path_len + 1, launcher_path_w);
+  PathStripPathW(launcher_name_w);
+  PathRemoveExtensionW(launcher_name_w);
+
+  size_t script_path_len = wcslen(launcher_dir) + wcslen(launcher_name_w) + 6;
+  wchar_t* script_path_w = malloc(sizeof(wchar_t) * script_path_len);
+  swprintf(script_path_w, script_path_len, L"%s\\%s.py", launcher_dir, launcher_name_w);
+
+  wchar_t* application_name = NULL;
+  wchar_t* command_line = NULL;
+
+  if (!handle_ccache(&application_name, &command_line, launcher_path_w)) {
+    application_name = get_python_executable();
+    wchar_t* long_script_path = get_long_path(script_path_w);
+    size_t command_line_len = wcslen(application_name) + wcslen(long_script_path) + 10;
+    command_line = malloc(sizeof(wchar_t) * command_line_len);
+    swprintf(command_line, command_line_len, L"\"%s\" -E \"%s\"", application_name, long_script_path);
+    free(long_script_path);
+  }
+
+  // Build the final command line
+  int arg_count;
+  LPWSTR* arg_list = CommandLineToArgvW(GetCommandLineW(), &arg_count);
+  for (int i = 1; i < arg_count; i++) {
+    size_t current_len = wcslen(command_line);
+    size_t arg_len = wcslen(arg_list[i]);
+    wchar_t* new_command_line = realloc(command_line, (current_len + arg_len + 2) * sizeof(wchar_t));
+    if (new_command_line) {
+      command_line = new_command_line;
+      wcscat_s(command_line, current_len + arg_len + 2, L" ");
+      wcscat_s(command_line, current_len + arg_len + 2, arg_list[i]);
+    }
+  }
+  LocalFree(arg_list);
+
+  // Work around python bug 34780 by closing stdin, so that it is not inherited
+  // by the python subprocess.
+  wchar_t* workaround_env = _wgetenv(L"EM_WORKAROUND_PYTHON_BUG_34780");
+  if (workaround_env) {
+    CloseHandle(GetStdHandle(STD_INPUT_HANDLE));
+  }
+
+  STARTUPINFOW si;
+  PROCESS_INFORMATION pi;
+  ZeroMemory(&si, sizeof(si));
+  si.cb = sizeof(si);
+  ZeroMemory(&pi, sizeof(pi));
+
+  if (!CreateProcessW(application_name, command_line, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
+    wprintf(L"CreateProcess failed (%d).\n", GetLastError());
+    abort();
+  }
+
+  WaitForSingleObject(pi.hProcess, INFINITE);
+
+  DWORD exit_code;
+  GetExitCodeProcess(pi.hProcess, &exit_code);
+  CloseHandle(pi.hProcess);
+  CloseHandle(pi.hThread);
+  return exit_code;
+}