Changes to support building from Linux

ports/icu/patches/0004-Copy-stubdata-dll-to-bin-for-cross-compile.patch

@@ -0,0 +1,11 @@
+--- a/source/stubdata/CMakeLists.txt
++++ b/source/stubdata/CMakeLists.txt
+@@ -43,7 +43,7 @@
+
+ setup_icu_target("${lib_NAME}" "${CMAKE_CURRENT_LIST_DIR}/sources.txt" "${CMAKE_CURRENT_LIST_DIR}")
+
+-if(CMAKE_HOST_WIN32
++if(WIN32
+    AND BUILD_SHARED_LIBS
+    AND (MSVC OR MINGW)
+ )

ports/icu/patches/0005-Pass-optCpuArch-from-pkgdata-to-writeObjectCode.patch

@@ -0,0 +1,30 @@
+--- a/source/tools/pkgdata/pkgdata.cpp
++++ b/source/tools/pkgdata/pkgdata.cpp
+@@ -769,14 +769,26 @@
+ #ifdef CAN_WRITE_OBJ_CODE
+                     /* Try to detect the arch type, use nullptr if unsuccessful */
+                     char optMatchArch[10] = { 0 };
+                     pkg_createOptMatchArch(optMatchArch);
++
++                    /* Determine the CPU architecture string for writeObjectCode.
++                     * When using Clang on Windows, the _M_* macros reflect the
++                     * target architecture set by the compiler driver. */
++                    const char *optCpuArch = nullptr;
++#if defined(_M_AMD64)
++                    optCpuArch = "x64";
++#elif defined(_M_ARM64)
++                    optCpuArch = "arm64";
++#elif defined(_M_IX86)
++                    optCpuArch = "x86";
++#endif
+                     writeObjectCode(
+                         datFileNamePath,
+                         o->tmpDir,
+                         o->entryName,
+                         (optMatchArch[0] == 0 ? nullptr : optMatchArch),
+-                        nullptr,
++                        optCpuArch,
+                         nullptr,
+                         gencFilePath,
+                         sizeof(gencFilePath),
+                         true);

ports/icu/patches/0006-Skip-pkgdata-link-step-when-cross-compiling.patch

@@ -0,0 +1,15 @@
+--- a/source/tools/pkgdata/pkgdata.cpp
++++ b/source/tools/pkgdata/pkgdata.cpp
+@@ -1795,5 +1795,12 @@
+ static int32_t pkg_createWindowsDLL(const char mode, const char *gencFilePath, UPKGOptions *o) {
+     int32_t result = 0;
+     char cmd[LARGE_BUFFER_MAX_SIZE];
++
++    /* When cross-compiling from a non-Windows host, the CMake build system
++     * links the data library itself; skip the link/lib step here. */
++    const char *skipLink = getenv("ICU_SKIP_PKGDATA_LINK");
++    if (skipLink && skipLink[0] == '1')
++        return 0;
++
+     if (IN_STATIC_MODE(mode)) {
+         char staticLibFilePath[SMALL_BUFFER_MAX_SIZE] = "";

ports/icu/portfile.cmake

@@ -20,6 +20,14 @@ set(PATCHES
     ${CMAKE_CURRENT_LIST_DIR}/patches/0001-Add-CMake-platform.patch
     # Patch specifically for vcpkg on top of above
     ${CMAKE_CURRENT_LIST_DIR}/patches/0002-Remove-install-suffix-on-Windows.patch
+    # Append CMAKE_EXECUTABLE_SUFFIX to tool paths for cross-compilation
+    ${CMAKE_CURRENT_LIST_DIR}/patches/0003-Append-CMAKE_EXECUTABLE_SUFFIX-to-tool-paths.patch
+    # Copy stubdata DLL to bin/ during cross-compilation (not just native Windows)
+    ${CMAKE_CURRENT_LIST_DIR}/patches/0004-Copy-stubdata-dll-to-bin-for-cross-compile.patch
+    # Pass optCpuArch to writeObjectCode to avoid nullptr dereference with clang
+    ${CMAKE_CURRENT_LIST_DIR}/patches/0005-Pass-optCpuArch-from-pkgdata-to-writeObjectCode.patch
+    # Allow overriding link.exe/LIB.exe via env vars for cross-compilation
+    ${CMAKE_CURRENT_LIST_DIR}/patches/0006-Skip-pkgdata-link-step-when-cross-compiling.patch
 )
 
 # Extract archive
@@ -51,6 +59,13 @@ else ()
     set(ENABLE_TOOLS ON)
 endif ()
 
+# When cross-compiling for Windows from a non-Windows host, pkgdata.exe runs
+# under Wine but cannot invoke link.exe/LIB.exe. The CMake build links the
+# data library itself, so skip the redundant link step in pkgdata (patch 0006).
+if (NOT VCPKG_HOST_IS_WINDOWS AND ENABLE_TOOLS)
+    set(ENV{ICU_SKIP_PKGDATA_LINK} 1)
+endif ()
+
 vcpkg_cmake_configure(
     SOURCE_PATH ${SOURCE_PATH}/source
     OPTIONS
@@ -101,7 +116,10 @@ if (ENABLE_TOOLS)
         file(RENAME ${CURRENT_PACKAGES_DIR}/sbin/${tool}${TOOL_EXTENSION} ${CURRENT_PACKAGES_DIR}/tools/icu/${tool}${TOOL_EXTENSION})
     endforeach()
 
-    vcpkg_copy_tool_dependencies(${CURRENT_PACKAGES_DIR}/tools/icu)
+    # vcpkg_copy_tool_dependencies requires PowerShell, skip on non-Windows hosts
+    if (VCPKG_HOST_IS_WINDOWS)
+        vcpkg_copy_tool_dependencies(${CURRENT_PACKAGES_DIR}/tools/icu)
+    endif ()
 endif ()
 
 # Prepare distribution

ports/vcpkg-tool-meson/0001-Detect-clang-cl-by-binary-name-on-non-Windows-hosts.patch

@@ -0,0 +1,31 @@
+--- meson-1.9.0/mesonbuild/compilers/detect.py	2025-08-24 12:24:15.000000000 -0400
++++ meson-1.9.0-patched/mesonbuild/compilers/detect.py	2026-02-05 21:55:31.816774859 -0500
+@@ -452,6 +452,28 @@
+                     full_version=full_version, linker=linker)
+
+         if 'clang' in out or 'Clang' in out:
++            # On Linux, clang-cl doesn't output "CL.EXE COMPATIBILITY" so the
++            # earlier check misses it. Detect by binary name and redirect to
++            # the ClangCl handler.
++            compiler_name = os.path.basename(compiler[0])
++            if 'clang-cl' in compiler_name and env.machines[for_machine].is_windows():
++                arg = '--version'
++                try:
++                    p, out, err = Popen_safe(compiler + [arg])
++                except OSError as e:
++                    popen_exceptions[join_args(compiler + [arg])] = e
++                version = search_version(out)
++                match = re.search('^Target: (.*?)-', out, re.MULTILINE)
++                target = match.group(1) if match else 'unknown target'
++                cls = c.ClangClCCompiler if lang == 'c' else cpp.ClangClCPPCompiler
++                # Use the linker from the cross file (c_ld), falling back to lld-link
++                ld_entry = env.lookup_binary_entry(for_machine, lang + '_ld')
++                linker_cmd = ld_entry if ld_entry is not None else ['lld-link']
++                linker = guess_win_linker(env, linker_cmd, cls, version, for_machine)
++                return cls(
++                    compiler, version, for_machine, is_cross, info, target,
++                    linker=linker)
++
+             linker = None
+
+             defines = _get_clang_compiler_defines(compiler, lang)

ports/vcpkg-tool-meson/0002-Pass-fuse-ld-to-clang-cl-for-correct-linker-selectio.patch

@@ -0,0 +1,18 @@
+--- meson-1.9.0/mesonbuild/compilers/mixins/visualstudio.py	2025-08-24 12:24:15.000000000 -0400
++++ meson-1.9.0-patched/mesonbuild/compilers/mixins/visualstudio.py	2026-02-05 21:55:49.130235239 -0500
+@@ -480,7 +480,14 @@
+     def linker_to_compiler_args(self, args: T.List[str]) -> T.List[str]:
+         # clang-cl forwards arguments span-wise with the /LINK flag
+         # therefore -Wl will be received by lld-link or LINK and rejected
+-        return super().use_linker_args(self.linker.id, '') + super().linker_to_compiler_args([flag[4:] if flag.startswith('-Wl,') else flag for flag in args])
++        # Tell clang-cl which linker binary to use via -fuse-ld so that
++        # on non-Windows hosts it doesn't fall back to /usr/bin/ld.
++        import os
++        ld_args: T.List[str] = []
++        if hasattr(self.linker, 'exelist') and self.linker.exelist:
++            ld_name = os.path.basename(self.linker.exelist[0])
++            ld_args = [f'-fuse-ld={ld_name}']
++        return ld_args + super().linker_to_compiler_args([flag[4:] if flag.startswith('-Wl,') else flag for flag in args])
+
+     def get_dependency_compile_args(self, dep: 'Dependency') -> T.List[str]:
+         if dep.get_include_type() == 'system':

ports/vcpkg-tool-meson/adjust-args.patch

@@ -0,0 +1,13 @@
+diff --git a/mesonbuild/cmake/toolchain.py b/mesonbuild/cmake/toolchain.py
+index 11a00be5d..89ae490ff 100644
+--- a/mesonbuild/cmake/toolchain.py
++++ b/mesonbuild/cmake/toolchain.py
+@@ -202,7 +202,7 @@ class CMakeToolchain:
+     @staticmethod
+     def is_cmdline_option(compiler: 'Compiler', arg: str) -> bool:
+         if compiler.get_argument_syntax() == 'msvc':
+-            return arg.startswith('/')
++            return arg.startswith(('/','-'))
+         else:
+             if os.path.basename(compiler.get_exe()) == 'zig' and arg in {'ar', 'cc', 'c++', 'dlltool', 'lib', 'ranlib', 'objcopy', 'rc'}:
+                 return True

ports/vcpkg-tool-meson/adjust-python-dep.patch

@@ -0,0 +1,45 @@
+diff --git a/mesonbuild/dependencies/python.py b/mesonbuild/dependencies/python.py
+index 883a29a..d9a82af 100644
+--- a/mesonbuild/dependencies/python.py
++++ b/mesonbuild/dependencies/python.py
+@@ -232,8 +232,10 @@ class _PythonDependencyBase(_Base):
+                 else:
+                     if self.is_freethreaded:
+                         libpath = Path('libs') / f'python{vernum}t.lib'
++                        libpath = Path('libs') / f'..' / f'..' / f'..' / f'lib' / f'python{vernum}t.lib'
+                     else:
+                         libpath = Path('libs') / f'python{vernum}.lib'
++                        libpath = Path('libs') / f'..' / f'..' / f'..' / f'lib' / f'python{vernum}.lib'
+                     # For a debug build, pyconfig.h may force linking with
+                     # pythonX_d.lib (see meson#10776). This cannot be avoided
+                     # and won't work unless we also have a debug build of
+@@ -250,6 +252,8 @@ class _PythonDependencyBase(_Base):
+                         vscrt = self.env.coredata.optstore.get_value('b_vscrt')
+                         if vscrt in {'mdd', 'mtd', 'from_buildtype', 'static_from_buildtype'}:
+                             vscrt_debug = True
++                    if is_debug_build:
++                       libpath = Path('libs') / f'..' / f'..' / f'..' / f'debug/lib' / f'python{vernum}_d.lib'
+                     if is_debug_build and vscrt_debug and not self.variables.get('Py_DEBUG'):
+                         mlog.warning(textwrap.dedent('''\
+                             Using a debug build type with MSVC or an MSVC-compatible compiler
+@@ -350,9 +354,10 @@ class PythonSystemDependency(SystemDependency, _PythonDependencyBase):
+             self.is_found = True
+
+         # compile args
++        verdot = self.variables.get('py_version_short')
+         inc_paths = mesonlib.OrderedSet([
+             self.variables.get('INCLUDEPY'),
+-            self.paths.get('include'),
++            self.paths.get('include') + f'/../../../include/python${verdot}',
+             self.paths.get('platinclude')])
+
+         self.compile_args += ['-I' + path for path in inc_paths if path]
+@@ -416,7 +421,7 @@ def python_factory(env: 'Environment', for_machine: 'MachineChoice',
+             candidates.append(functools.partial(wrap_in_pythons_pc_dir, pkg_name, env, kwargs, installation))
+             # We only need to check both, if a python install has a LIBPC. It might point to the wrong location,
+             # e.g. relocated / cross compilation, but the presence of LIBPC indicates we should definitely look for something.
+-            if pkg_libdir is not None:
++            if True or pkg_libdir is not None:
+                 candidates.append(functools.partial(PythonPkgConfigDependency, pkg_name, env, kwargs, installation))
+         else:
+             candidates.append(functools.partial(PkgConfigDependency, 'python3', env, kwargs))

ports/vcpkg-tool-meson/install.cmake

@@ -0,0 +1,5 @@
+file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/tools/meson")
+file(INSTALL "${SOURCE_PATH}/meson.py"
+             "${SOURCE_PATH}/mesonbuild"
+    DESTINATION "${CURRENT_PACKAGES_DIR}/tools/meson"
+)

ports/vcpkg-tool-meson/meson-56879d5.diff

@@ -0,0 +1,24 @@
+diff --git a/mesonbuild/msetup.py b/mesonbuild/msetup.py
+index 8d7dd0bbf756..f1fa777d179a 100644
+--- a/mesonbuild/msetup.py
++++ b/mesonbuild/msetup.py
+@@ -16,6 +16,7 @@
+ if T.TYPE_CHECKING:
+     from typing_extensions import Protocol
+     from .coredata import SharedCMDOptions
++    from .interpreter import SubprojectHolder
+
+     class CMDOptions(SharedCMDOptions, Protocol):
+
+@@ -192,9 +193,9 @@ def generate(self, capture: bool = False, vslite_ctx: T.Optional[dict] = None) -
+                                     'Some other Meson process is already using this build directory. Exiting.'):
+             return self._generate(env, capture, vslite_ctx)
+
+-    def check_unused_options(self, coredata: 'coredata.CoreData', cmd_line_options: T.Dict[OptionKey, str], all_subprojects: T.Mapping[str, object]) -> None:
++    def check_unused_options(self, coredata: 'coredata.CoreData', cmd_line_options: T.Dict[OptionKey, str], all_subprojects: T.Mapping[str, SubprojectHolder]) -> None:
+         errlist: T.List[str] = []
+-        known_subprojects = all_subprojects.keys()
++        known_subprojects = [name for name, obj in all_subprojects.items() if obj.found()]
+         for opt in cmd_line_options:
+             # Accept options that exist or could appear in subsequent reconfigurations,
+             # including options for subprojects that were not used

ports/vcpkg-tool-meson/meson-intl.patch

@@ -0,0 +1,13 @@
+diff --git a/mesonbuild/dependencies/misc.py b/mesonbuild/dependencies/misc.py
+--- a/mesonbuild/dependencies/misc.py
++++ b/mesonbuild/dependencies/misc.py
+@@ -593,7 +593,8 @@ iconv_factory = DependencyFactory(
+
+ packages['intl'] = intl_factory = DependencyFactory(
+     'intl',
++    [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM, DependencyMethods.CMAKE],
++    cmake_name='Intl',
+-    [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM],
+     builtin_class=IntlBuiltinDependency,
+     system_class=IntlSystemDependency,
+ )

ports/vcpkg-tool-meson/meson.template.in

@@ -0,0 +1,43 @@
+[binaries]
+cmake = ['@CMAKE_COMMAND@']
+ninja = ['@NINJA@']
+pkg-config = ['@PKGCONFIG@']
+@MESON_MT@
+@MESON_AR@
+@MESON_RC@
+@MESON_C@
+@MESON_C_LD@
+@MESON_CXX@
+@MESON_CXX_LD@
+@MESON_OBJC@
+@MESON_OBJC_LD@
+@MESON_OBJCPP@
+@MESON_OBJCPP_LD@
+@MESON_FC@
+@MESON_FC_LD@
+@MESON_WINDRES@
+@MESON_ADDITIONAL_BINARIES@
+[properties]
+cmake_toolchain_file  = '@SCRIPTS@/buildsystems/vcpkg.cmake'
+@MESON_ADDITIONAL_PROPERTIES@
+[cmake]
+CMAKE_BUILD_TYPE = '@MESON_CMAKE_BUILD_TYPE@'
+VCPKG_TARGET_TRIPLET = '@TARGET_TRIPLET@'
+VCPKG_HOST_TRIPLET = '@_HOST_TRIPLET@'
+VCPKG_CHAINLOAD_TOOLCHAIN_FILE = '@VCPKG_CHAINLOAD_TOOLCHAIN_FILE@'
+VCPKG_CRT_LINKAGE = '@VCPKG_CRT_LINKAGE@'
+_VCPKG_INSTALLED_DIR = '@_VCPKG_INSTALLED_DIR@'
+@MESON_HOST_MACHINE@
+@MESON_BUILD_MACHINE@
+[built-in options]
+default_library = '@MESON_DEFAULT_LIBRARY@'
+werror = false
+@MESON_CFLAGS@
+@MESON_CXXFLAGS@
+@MESON_FCFLAGS@
+@MESON_OBJCFLAGS@
+@MESON_OBJCPPFLAGS@
+# b_vscrt
+@MESON_VSCRT_LINKAGE@
+# c_winlibs/cpp_winlibs
+@MESON_WINLIBS@

ports/vcpkg-tool-meson/portfile.cmake

@@ -0,0 +1,46 @@
+# This port represents a dependency on the Meson build system.
+# In the future, it is expected that this port acquires and installs Meson.
+# Currently is used in ports that call vcpkg_find_acquire_program(MESON) in order to force rebuilds.
+
+set(VCPKG_POLICY_CMAKE_HELPER_PORT enabled)
+
+set(patches
+  meson-intl.patch
+  adjust-python-dep.patch
+  adjust-args.patch
+  remove-pkgconfig-specialization.patch
+  meson-56879d5.diff  # Remove with 1.9.1
+  0001-Detect-clang-cl-by-binary-name-on-non-Windows-hosts.patch
+  0002-Pass-fuse-ld-to-clang-cl-for-correct-linker-selectio.patch
+)
+set(scripts
+  vcpkg-port-config.cmake
+  vcpkg_configure_meson.cmake
+  vcpkg_install_meson.cmake
+  meson.template.in
+)
+set(to_hash 
+  "${CMAKE_CURRENT_LIST_DIR}/vcpkg.json"
+  "${CMAKE_CURRENT_LIST_DIR}/portfile.cmake"
+)
+foreach(file IN LISTS patches scripts)
+  set(filepath  "${CMAKE_CURRENT_LIST_DIR}/${file}")
+  list(APPEND to_hash "${filepath}")
+  file(COPY "${filepath}" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}")
+endforeach()
+
+set(meson_path_hash "")
+foreach(filepath IN LISTS to_hash)
+  file(SHA1 "${filepath}" to_append)
+  string(APPEND meson_path_hash "${to_append}")
+endforeach()
+string(SHA512 meson_path_hash "${meson_path_hash}")
+
+string(SUBSTRING "${meson_path_hash}" 0 6 MESON_SHORT_HASH)
+list(TRANSFORM patches REPLACE [[^(..*)$]] [["${CMAKE_CURRENT_LIST_DIR}/\0"]])
+list(JOIN patches "\n            " PATCHES)
+configure_file("${CMAKE_CURRENT_LIST_DIR}/vcpkg-port-config.cmake" "${CURRENT_PACKAGES_DIR}/share/${PORT}/vcpkg-port-config.cmake" @ONLY)
+
+vcpkg_install_copyright(FILE_LIST "${VCPKG_ROOT_DIR}/LICENSE.txt")
+
+include("${CURRENT_PACKAGES_DIR}/share/${PORT}/vcpkg-port-config.cmake")

ports/vcpkg-tool-meson/remove-pkgconfig-specialization.patch

@@ -0,0 +1,14 @@
+diff --git a/mesonbuild/modules/pkgconfig.py b/mesonbuild/modules/pkgconfig.py
+index bef14e9..fec595f 100644
+--- a/mesonbuild/modules/pkgconfig.py
++++ b/mesonbuild/modules/pkgconfig.py
+@@ -715,6 +715,9 @@ class PkgConfigModule(NewExtensionModule):
+         pcfile = filebase + '.pc'
+         pkgroot = pkgroot_name = kwargs['install_dir'] or default_install_dir
+         if pkgroot is None:
++            pkgroot = os.path.join(_as_str(state.environment.coredata.optstore.get_value_for(OptionKey('libdir'))), 'pkgconfig')
++            pkgroot_name = os.path.join('{libdir}', 'pkgconfig')
++        elif False:
+             m = state.environment.machines.host
+             if m.is_freebsd():
+                 pkgroot = os.path.join(_as_str(state.environment.coredata.optstore.get_value_for(OptionKey('prefix'))), 'libdata', 'pkgconfig')