Add files using upload-large-folder tool

cc-multilingual-main/cc_net/config/lid_exp.json

@@ -0,0 +1,12 @@
+{
+  "output_dir": "/checkpoint/guw/cc_clean2/",
+  "dump": "2019-09",
+  "num_shards": 1600,
+  "pipeline": [
+    "lid_before_dedup",
+    "dedup",
+    "lid_after_dedup"
+  ],
+  "hash_in_mem": 50,
+  "execution": "slurm"
+}

cc-multilingual-main/cc_net/config/mine_segment.json

@@ -0,0 +1,15 @@
+{
+    "dump": "2019-09",
+    "mined_dir": "mini_by_segment",
+    "pipeline": [
+        "dedup",
+        "lid",
+        "keep_lang",
+        "sp",
+        "lm",
+        "pp_bucket",
+        "minify",
+        "split_by_segment"
+    ],
+    "execution": "slurm"
+}

cc-multilingual-main/cc_net/config/myconfig.json

@@ -0,0 +1,21 @@
+{
+    "hash_in_mem": 20,
+    "dump": "2020-05",
+    "num_shards": 1600,
+    "lang_whitelist": ["as","bn","gu","kn","hi","ml","mr","ne","or","pb","sa","sd","ta","ur","te","ks","sat","mai","mni","kok","doi","brx"],
+    "num_segments_per_shard": -1,
+    "mine_num_processes": 16,
+    "pipeline": [
+        "lid",
+        "keep_lang",
+        "pp_bucket",
+        "split_by_lang"
+    ],
+    "task_parallelism":32,
+    "cleanup_after_regroup": true,
+    "execution": "auto",
+    "target_size": "5M",
+    "output_dir": "/mnt/weka/peacock/wet-data/output",
+    "mined_dir": "mined",
+    "cache_dir": "/mnt/weka/peacock/wet-data/cache"
+}

cc-multilingual-main/cc_net/config/test_reproduce.json

@@ -0,0 +1,16 @@
+{
+    "hash_in_mem": 2,
+    "dump": "2019-09",
+    "num_shards": 1,
+    "num_segments_per_shard": 1,
+    "pipeline": [
+        "fetch_metadata",
+        "split_by_lang"
+    ],
+    "metadata": "test_data2/mined_by_segment",
+    "execution": "debug",
+    "output_dir": "test_data2",
+    "mined_dir": "reproduce",
+    "target_size": "32M",
+    "cache_dir": "test_data/wet_cache"
+}

cc-multilingual-main/cc_net/config/test_segment.json

@@ -0,0 +1,23 @@
+{
+    "hash_in_mem": 2,
+    "dump": "2019-09",
+    "num_shards": 4,
+    "num_segments_per_shard": 1,
+    "mine_num_processes": 0,
+    "lang_whitelist": ["de", "it", "fr"],
+    "pipeline": [
+        "dedup",
+        "lid",
+        "keep_lang",
+        "sp",
+        "lm",
+        "pp_bucket",
+        "minify",
+        "split_by_segment"
+    ],
+    "execution": "debug",
+    "output_dir": "test_data2",
+    "mined_dir": "mined_by_segment",
+    "target_size": "32M",
+    "cache_dir": "test_data/wet_cache"
+}

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/compile_wrapper_consider_clang-cl.patch

@@ -0,0 +1,12 @@
+diff --git a/usr/share/automake-1.16/compile b/usr/share/automake-1.16/compile
+index 2078fc833..dfc946593 100755
+--- a/usr/share/automake-1.16/compile
++++ b/usr/share/automake-1.16/compile
+@@ -256,6 +256,7 @@ EOF
+     exit $?
+     ;;
+   cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \
++  clang-cl | *[/\\]clang-cl | clang-cl.exe | *[/\\]clang-cl.exe | \
+   icl | *[/\\]icl | icl.exe | *[/\\]icl.exe )
+     func_cl_wrapper "$@"      # Doesn't return...
+     ;;

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/execute_process.cmake

@@ -0,0 +1,12 @@
+if (NOT DEFINED Z_VCPKG_OVERRIDEN_EXECUTE_PROCESS)
+  set(Z_VCPKG_OVERRIDEN_EXECUTE_PROCESS ON)
+
+  if (DEFINED VCPKG_DOWNLOAD_MODE)
+    function(execute_process)
+      message(FATAL_ERROR "This command cannot be executed in Download Mode.\nHalting portfile execution.\n")
+    endfunction()
+    set(Z_VCPKG_EXECUTE_PROCESS_NAME "_execute_process")
+  else()
+    set(Z_VCPKG_EXECUTE_PROCESS_NAME "execute_process")
+  endif()
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_apply_patches.cmake

@@ -0,0 +1,17 @@
+function(vcpkg_apply_patches)
+    z_vcpkg_deprecation_message("vcpkg_apply_patches has been deprecated in favor of the `PATCHES` argument to `vcpkg_from_*`.")
+
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "QUIET" "SOURCE_PATH" "PATCHES")
+
+    if(arg_QUIET)
+        set(quiet "QUIET")
+    else()
+        set(quiet)
+    endif()
+
+    z_vcpkg_apply_patches(
+        SOURCE_PATH "${arg_SOURCE_PATH}"
+        ${quiet}
+        PATCHES ${arg_PATCHES}
+    )
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_cmake.cmake

@@ -0,0 +1,95 @@
+function(vcpkg_build_cmake)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        "DISABLE_PARALLEL;ADD_BIN_TO_PATH"
+        "TARGET;LOGFILE_ROOT"
+        ""
+    )
+
+    if(Z_VCPKG_CMAKE_BUILD_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_build_cmake in the same port is unsupported.")
+    endif()
+
+    if(NOT DEFINED arg_LOGFILE_ROOT)
+        set(arg_LOGFILE_ROOT "build")
+    endif()
+
+    vcpkg_list(SET build_param)
+    vcpkg_list(SET parallel_param)
+    vcpkg_list(SET no_parallel_param)
+
+    if("${Z_VCPKG_CMAKE_GENERATOR}" STREQUAL "Ninja")
+        vcpkg_list(SET build_param "-v") # verbose output
+        vcpkg_list(SET parallel_param "-j${VCPKG_CONCURRENCY}")
+        vcpkg_list(SET no_parallel_param "-j1")
+    elseif("${Z_VCPKG_CMAKE_GENERATOR}" MATCHES "^Visual Studio")
+        vcpkg_list(SET build_param
+            "/p:VCPkgLocalAppDataDisabled=true"
+            "/p:UseIntelMKL=No"
+        )
+        vcpkg_list(SET parallel_param "/m")
+    elseif("${Z_VCPKG_CMAKE_GENERATOR}" STREQUAL "NMake Makefiles")
+        # No options are currently added for nmake builds
+    elseif(Z_VCPKG_CMAKE_GENERATOR STREQUAL "Unix Makefiles")
+        vcpkg_list(SET build_param "VERBOSE=1")
+        vcpkg_list(SET parallel_param "-j${VCPKG_CONCURRENCY}")
+        vcpkg_list(SET no_parallel_param "")
+    elseif(Z_VCPKG_CMAKE_GENERATOR STREQUAL "Xcode")
+        vcpkg_list(SET parallel_param -jobs "${VCPKG_CONCURRENCY}")
+        vcpkg_list(SET no_parallel_param -jobs 1)
+    else()
+        message(FATAL_ERROR "Unrecognized GENERATOR setting from vcpkg_configure_cmake(). Valid generators are: Ninja, Visual Studio, and NMake Makefiles")
+    endif()
+
+    vcpkg_list(SET target_param)
+    if(arg_TARGET)
+        vcpkg_list(SET target_param "--target" "${arg_TARGET}")
+    endif()
+
+    foreach(build_type IN ITEMS debug release)
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "${build_type}")
+            if("${build_type}" STREQUAL "debug")
+                set(short_build_type "dbg")
+                set(config "Debug")
+            else()
+                set(short_build_type "rel")
+                set(config "Release")
+            endif()
+
+            message(STATUS "Building ${TARGET_TRIPLET}-${short_build_type}")
+
+            if(arg_ADD_BIN_TO_PATH)
+                vcpkg_backup_env_variables(VARS PATH)
+                if("${build_type}" STREQUAL "debug")
+                    vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/debug/bin")
+                else()
+                    vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/bin")
+                endif()
+            endif()
+
+            if(arg_DISABLE_PARALLEL)
+                vcpkg_execute_build_process(
+                    COMMAND
+                        "${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
+                        -- ${build_param} ${no_parallel_param}
+                    WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_build_type}"
+                    LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_build_type}"
+                )
+            else()
+                vcpkg_execute_build_process(
+                    COMMAND
+                        "${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
+                        -- ${build_param} ${parallel_param}
+                    NO_PARALLEL_COMMAND
+                        "${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
+                        -- ${build_param} ${no_parallel_param}
+                    WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_build_type}"
+                    LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_build_type}"
+                )
+            endif()
+
+            if(arg_ADD_BIN_TO_PATH)
+                vcpkg_restore_env_variables(VARS PATH)
+            endif()
+        endif()
+    endforeach()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_make.cmake

@@ -0,0 +1,193 @@
+function(vcpkg_build_make)
+    z_vcpkg_get_cmake_vars(cmake_vars_file)
+    include("${cmake_vars_file}")
+
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "ADD_BIN_TO_PATH;ENABLE_INSTALL;DISABLE_PARALLEL"
+        "LOGFILE_ROOT;BUILD_TARGET;SUBPATH;MAKEFILE;INSTALL_TARGET"
+        "OPTIONS"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_make_build was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED arg_LOGFILE_ROOT)
+        set(arg_LOGFILE_ROOT "build")
+    endif()
+
+    if(NOT DEFINED arg_BUILD_TARGET)
+        set(arg_BUILD_TARGET "all")
+    endif()
+
+    if (NOT DEFINED arg_MAKEFILE)
+        set(arg_MAKEFILE Makefile)
+    endif()
+
+    if(NOT DEFINED arg_INSTALL_TARGET)
+        set(arg_INSTALL_TARGET "install")
+    endif()
+
+    if(WIN32)
+        set(Z_VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR})
+    else()
+        string(REPLACE " " "\ " Z_VCPKG_INSTALLED "${CURRENT_INSTALLED_DIR}")
+    endif()
+
+    vcpkg_list(SET make_opts)
+    vcpkg_list(SET install_opts)
+    if (CMAKE_HOST_WIN32)
+        set(path_backup "$ENV{PATH}")
+        vcpkg_add_to_path(PREPEND "${SCRIPTS}/buildsystems/make_wrapper")
+        if(NOT DEFINED Z_VCPKG_MAKE)
+            vcpkg_acquire_msys(MSYS_ROOT)
+            find_program(Z_VCPKG_MAKE make PATHS "${MSYS_ROOT}/usr/bin" NO_DEFAULT_PATH REQUIRED)
+        endif()
+        set(make_command "${Z_VCPKG_MAKE}")
+        vcpkg_list(SET make_opts ${arg_OPTIONS} -j ${VCPKG_CONCURRENCY} --trace -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
+        vcpkg_list(SET no_parallel_make_opts ${arg_OPTIONS} -j 1 --trace -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
+
+        string(REPLACE " " [[\ ]] vcpkg_package_prefix "${CURRENT_PACKAGES_DIR}")
+        string(REGEX REPLACE [[([a-zA-Z]):/]] [[/\1/]] vcpkg_package_prefix "${vcpkg_package_prefix}")
+        vcpkg_list(SET install_opts -j ${VCPKG_CONCURRENCY} --trace -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${vcpkg_package_prefix})
+        vcpkg_list(SET no_parallel_install_opts -j 1 --trace -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${vcpkg_package_prefix})
+        #TODO: optimize for install-data (release) and install-exec (release/debug)
+
+    else()
+        if(VCPKG_HOST_IS_FREEBSD OR VCPKG_HOST_IS_OPENBSD)
+            find_program(Z_VCPKG_MAKE gmake REQUIRED)
+        else()
+            find_program(Z_VCPKG_MAKE make REQUIRED)
+        endif()
+        set(make_command "${Z_VCPKG_MAKE}")
+        vcpkg_list(SET make_opts ${arg_OPTIONS} V=1 -j ${VCPKG_CONCURRENCY} -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
+        vcpkg_list(SET no_parallel_make_opts ${arg_OPTIONS} V=1 -j 1 -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
+        vcpkg_list(SET install_opts -j ${VCPKG_CONCURRENCY} -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${CURRENT_PACKAGES_DIR})
+        vcpkg_list(SET no_parallel_install_opts -j 1 -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${CURRENT_PACKAGES_DIR})
+    endif()
+
+    # Since includes are buildtype independent those are setup by vcpkg_configure_make
+    vcpkg_backup_env_variables(VARS LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH CPPFLAGS CFLAGS CXXFLAGS RCFLAGS)
+
+    z_vcpkg_configure_make_common_definitions()
+
+    foreach(buildtype IN ITEMS "debug" "release")
+        if (buildtype STREQUAL "debug" AND _VCPKG_MAKE_NO_DEBUG)
+            continue()
+        endif()
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "${buildtype}")
+            string(TOUPPER "${buildtype}" cmake_buildtype)
+            set(short_buildtype "${short_name_${cmake_buildtype}}")
+            set(path_suffix "${path_suffix_${cmake_buildtype}}")
+
+            set(working_directory "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_buildtype}/${arg_SUBPATH}")
+            message(STATUS "Building ${TARGET_TRIPLET}-${short_buildtype}")
+
+            if("libtool-link-pass-target" IN_LIST VCPKG_BUILD_MAKE_FIXUP)
+                # Pass --target to the linker, e.g. for Android
+                file(GLOB_RECURSE libtool_files "${working_directory}/libtool")
+                foreach(file IN LISTS libtool_files)
+                    vcpkg_replace_string("${file}" [[-xtarget=*|]] [[-xtarget=*|--target=*|]])
+                endforeach()
+            endif()
+
+            z_vcpkg_configure_make_process_flags("${cmake_buildtype}")
+
+            # Setup environment
+            set(ENV{CPPFLAGS} "${CPPFLAGS_${cmake_buildtype}}")
+            set(ENV{CFLAGS} "${CFLAGS_${cmake_buildtype}}")
+            set(ENV{CXXFLAGS} "${CXXFLAGS_${cmake_buildtype}}")
+            set(ENV{RCFLAGS} "${VCPKG_DETECTED_CMAKE_RC_FLAGS_${cmake_buildtype}}")
+            set(ENV{LDFLAGS} "${LDFLAGS_${cmake_buildtype}}")
+            vcpkg_list(APPEND lib_env_vars LIB LIBPATH LIBRARY_PATH) # LD_LIBRARY_PATH)
+            foreach(lib_env_var IN LISTS lib_env_vars)
+                if(EXISTS "${Z_VCPKG_INSTALLED}${path_suffix}/lib")
+                    vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${Z_VCPKG_INSTALLED}${path_suffix}/lib")
+                endif()
+                if(EXISTS "${Z_VCPKG_INSTALLED}${path_suffix}/lib/manual-link")
+                    vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${Z_VCPKG_INSTALLED}${path_suffix}/lib/manual-link")
+                endif()
+            endforeach()
+            unset(lib_env_vars)
+
+            if(LINK_ENV_${cmake_buildtype})
+                set(config_link_backup "$ENV{_LINK_}")
+                set(ENV{_LINK_} "${LINK_ENV_${cmake_buildtype}}")
+            else()
+                unset(config_link_backup)
+            endif()
+
+            if(arg_ADD_BIN_TO_PATH)
+                set(env_backup_path "$ENV{PATH}")
+                vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}${path_suffix}/bin")
+            endif()
+
+            vcpkg_list(SET make_cmd_line ${make_command} ${make_opts})
+            vcpkg_list(SET no_parallel_make_cmd_line ${make_command} ${no_parallel_make_opts})
+
+            if (arg_DISABLE_PARALLEL)
+                vcpkg_execute_build_process(
+                        COMMAND ${no_parallel_make_cmd_line}
+                        WORKING_DIRECTORY "${working_directory}"
+                        LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_buildtype}"
+                )
+            else()
+                vcpkg_execute_build_process(
+                        COMMAND ${make_cmd_line}
+                        NO_PARALLEL_COMMAND ${no_parallel_make_cmd_line}
+                        WORKING_DIRECTORY "${working_directory}"
+                        LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_buildtype}"
+                )
+            endif()
+
+            file(READ "${CURRENT_BUILDTREES_DIR}/${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_buildtype}-out.log" logdata) 
+            if(logdata MATCHES "Warning: linker path does not have real file for library")
+                message(FATAL_ERROR "libtool could not find a file being linked against!")
+            endif()
+
+            if (arg_ENABLE_INSTALL)
+                message(STATUS "Installing ${TARGET_TRIPLET}-${short_buildtype}")
+                vcpkg_list(SET make_cmd_line ${make_command} ${install_opts})
+                vcpkg_list(SET no_parallel_make_cmd_line ${make_command} ${no_parallel_install_opts})
+                vcpkg_execute_build_process(
+                    COMMAND ${make_cmd_line}
+                    NO_PARALLEL_COMMAND ${no_parallel_make_cmd_line}
+                    WORKING_DIRECTORY "${working_directory}"
+                    LOGNAME "install-${TARGET_TRIPLET}-${short_buildtype}"
+                )
+            endif()
+
+            if(DEFINED config_link_backup)
+                set(ENV{_LINK_} "${config_link_backup}")
+            endif()
+
+            if(arg_ADD_BIN_TO_PATH)
+                set(ENV{PATH} "${env_backup_path}")
+            endif()
+        endif()
+
+        vcpkg_restore_env_variables(VARS LIB LIBPATH LIBRARY_PATH)
+    endforeach()
+
+    if (arg_ENABLE_INSTALL)
+        string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" Z_VCPKG_INSTALL_PREFIX "${CURRENT_INSTALLED_DIR}")
+        file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}_tmp")
+        file(RENAME "${CURRENT_PACKAGES_DIR}" "${CURRENT_PACKAGES_DIR}_tmp")
+        file(RENAME "${CURRENT_PACKAGES_DIR}_tmp${Z_VCPKG_INSTALL_PREFIX}" "${CURRENT_PACKAGES_DIR}")
+        file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}_tmp")
+    endif()
+
+    # Remove libtool files since they contain absolute paths and are not necessary. 
+    file(GLOB_RECURSE libtool_files "${CURRENT_PACKAGES_DIR}/**/*.la")
+    if(libtool_files)
+        file(REMOVE ${libtool_files})
+    endif()
+
+    if (CMAKE_HOST_WIN32)
+        set(ENV{PATH} "${path_backup}")
+    endif()
+
+    vcpkg_restore_env_variables(VARS LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH CPPFLAGS CFLAGS CXXFLAGS RCFLAGS)
+    unset(_VCPKG_MAKE_NO_DEBUG PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_msbuild.cmake

@@ -0,0 +1,87 @@
+function(vcpkg_build_msbuild)
+    cmake_parse_arguments(
+        PARSE_ARGV 0
+        arg
+        "USE_VCPKG_INTEGRATION"
+        "PROJECT_PATH;RELEASE_CONFIGURATION;DEBUG_CONFIGURATION;PLATFORM;PLATFORM_TOOLSET;TARGET_PLATFORM_VERSION;TARGET"
+        "OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_build_msbuild was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED arg_RELEASE_CONFIGURATION)
+        set(arg_RELEASE_CONFIGURATION Release)
+    endif()
+    if(NOT DEFINED arg_DEBUG_CONFIGURATION)
+        set(arg_DEBUG_CONFIGURATION Debug)
+    endif()
+    if(NOT DEFINED arg_PLATFORM)
+        set(arg_PLATFORM "${TRIPLET_SYSTEM_ARCH}")
+    endif()
+    if(NOT DEFINED arg_PLATFORM_TOOLSET)
+        set(arg_PLATFORM_TOOLSET "${VCPKG_PLATFORM_TOOLSET}")
+    endif()
+    if(NOT DEFINED arg_TARGET_PLATFORM_VERSION)
+        vcpkg_get_windows_sdk(arg_TARGET_PLATFORM_VERSION)
+    endif()
+    if(NOT DEFINED arg_TARGET)
+        set(arg_TARGET Rebuild)
+    endif()
+
+    list(APPEND arg_OPTIONS
+        "/t:${arg_TARGET}"
+        "/p:Platform=${arg_PLATFORM}"
+        "/p:PlatformToolset=${arg_PLATFORM_TOOLSET}"
+        "/p:VCPkgLocalAppDataDisabled=true"
+        "/p:UseIntelMKL=No"
+        "/p:WindowsTargetPlatformVersion=${arg_TARGET_PLATFORM_VERSION}"
+        "/p:VcpkgManifestInstall=false"
+        "/p:VcpkgManifestEnabled=false"
+        "/m"
+    )
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
+        # Disable LTCG for static libraries because this setting introduces ABI incompatibility between minor compiler versions
+        # TODO: Add a way for the user to override this if they want to opt-in to incompatibility
+        list(APPEND arg_OPTIONS "/p:WholeProgramOptimization=false")
+    endif()
+
+    if(arg_USE_VCPKG_INTEGRATION)
+        list(
+            APPEND arg_OPTIONS
+            "/p:ForceImportBeforeCppTargets=${SCRIPTS}/buildsystems/msbuild/vcpkg.targets"
+            "/p:VcpkgTriplet=${TARGET_TRIPLET}"
+            "/p:VcpkgInstalledDir=${_VCPKG_INSTALLED_DIR}"
+        )
+    else()
+        list(APPEND arg_OPTIONS "/p:VcpkgEnabled=false")
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        message(STATUS "Building ${arg_PROJECT_PATH} for Release")
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
+        vcpkg_execute_required_process(
+            COMMAND msbuild "${arg_PROJECT_PATH}"
+                "/p:Configuration=${arg_RELEASE_CONFIGURATION}"
+                ${arg_OPTIONS}
+                ${arg_OPTIONS_RELEASE}
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
+            LOGNAME "build-${TARGET_TRIPLET}-rel"
+        )
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        message(STATUS "Building ${arg_PROJECT_PATH} for Debug")
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
+        vcpkg_execute_required_process(
+            COMMAND msbuild "${arg_PROJECT_PATH}"
+                "/p:Configuration=${arg_DEBUG_CONFIGURATION}"
+                ${arg_OPTIONS}
+                ${arg_OPTIONS_DEBUG}
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
+            LOGNAME "build-${TARGET_TRIPLET}-dbg"
+        )
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_qmake.cmake

@@ -0,0 +1,82 @@
+function(z_run_jom_build invoke_command targets log_prefix log_suffix)
+    message(STATUS "Package ${log_prefix}-${TARGET_TRIPLET}-${log_suffix}")
+    vcpkg_execute_build_process(
+        COMMAND "${invoke_command}" -j ${VCPKG_CONCURRENCY} ${targets}
+        NO_PARALLEL_COMMAND "${invoke_command}" -j 1 ${targets}
+        WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${log_suffix}"
+        LOGNAME "package-${log_prefix}-${TARGET_TRIPLET}-${log_suffix}"
+    )
+endfunction()
+
+function(vcpkg_build_qmake)
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "SKIP_MAKEFILES"
+        "BUILD_LOGNAME"
+        "TARGETS;RELEASE_TARGETS;DEBUG_TARGETS"
+    )
+
+    # Make sure that the linker finds the libraries used
+    vcpkg_backup_env_variables(VARS PATH LD_LIBRARY_PATH CL _CL_)
+
+    # This fixes issues on machines with default codepages that are not ASCII compatible, such as some CJK encodings
+    set(ENV{_CL_} "/utf-8")
+
+    if(CMAKE_HOST_WIN32)
+        if(VCPKG_TARGET_IS_MINGW)
+            find_program(MINGW32_MAKE mingw32-make REQUIRED)
+            set(invoke_command "${MINGW32_MAKE}")
+        elseif (VCPKG_QMAKE_USE_NMAKE)
+            find_program(NMAKE nmake)
+            set(invoke_command "${NMAKE}")
+            get_filename_component(nmake_exe_path "${NMAKE}" DIRECTORY)
+            vcpkg_host_path_list(APPEND ENV{PATH} "${nmake_exe_path}")
+            set(ENV{CL} "$ENV{CL} /MP${VCPKG_CONCURRENCY}")
+        else()
+            vcpkg_find_acquire_program(JOM)
+            set(invoke_command "${JOM}")
+        endif()
+    else()
+        find_program(MAKE make)
+        set(invoke_command "${MAKE}")
+    endif()
+
+    if(NOT DEFINED arg_BUILD_LOGNAME)
+        set(arg_BUILD_LOGNAME build)
+    endif()
+
+    set(short_name_debug "dbg")
+    set(path_suffix_debug "/debug")
+    set(targets_debug "${arg_DEBUG_TARGETS}")
+
+    set(short_name_release "rel")
+    set(path_suffix_release "")
+    set(targets_release "${arg_RELEASE_TARGETS}")
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE)
+        set(items debug release)
+    else()
+        set(items release)
+    endif()
+    foreach(build_type IN ITEMS ${items})
+        set(current_installed_prefix "${CURRENT_INSTALLED_DIR}${path_suffix_${build_type}}")
+
+        vcpkg_add_to_path(PREPEND "${current_installed_prefix}/lib" "${current_installed_prefix}/bin")
+
+        # We set LD_LIBRARY_PATH ENV variable to allow executing Qt tools (rcc,...) even with dynamic linking
+        if(CMAKE_HOST_UNIX)
+            set(ENV{LD_LIBRARY_PATH} "")
+            vcpkg_host_path_list(APPEND ENV{LD_LIBRARY_PATH} "${current_installed_prefix}/lib" "${current_installed_prefix}/lib/manual-link")
+        endif()
+
+        vcpkg_list(SET targets ${targets_${build_type}} ${arg_TARGETS})
+        if(NOT arg_SKIP_MAKEFILES)
+            z_run_jom_build("${invoke_command}" qmake_all makefiles "${short_name_${build_type}}")
+        endif()
+        z_run_jom_build("${invoke_command}" "${targets}" "${arg_BUILD_LOGNAME}" "${short_name_${build_type}}")
+
+        vcpkg_restore_env_variables(VARS PATH LD_LIBRARY_PATH)
+    endforeach()
+
+    vcpkg_restore_env_variables(VARS CL _CL_)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_clean_msbuild.cmake

@@ -0,0 +1,9 @@
+function(vcpkg_clean_msbuild)
+    if(NOT ARGC EQUAL 0)
+        message(WARNING "vcpkg_clean_msbuild was passed extra arguments: ${ARGV}")
+    endif()
+    file(REMOVE_RECURSE
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
+    )
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_common_definitions.cmake

@@ -0,0 +1,195 @@
+string(COMPARE NOTEQUAL "${TARGET_TRIPLET}" "${HOST_TRIPLET}" VCPKG_CROSSCOMPILING)
+#Helper variable to identify the Target system. VCPKG_TARGET_IS_<targetname>
+if (NOT DEFINED VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL "")
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+
+    if(DEFINED VCPKG_XBOX_CONSOLE_TARGET AND NOT "${VCPKG_XBOX_CONSOLE_TARGET}" STREQUAL "")
+        set(VCPKG_TARGET_IS_XBOX ON)
+    endif()
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+    set(VCPKG_TARGET_IS_UWP ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    set(VCPKG_TARGET_IS_OSX ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    set(VCPKG_TARGET_IS_IOS ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(VCPKG_TARGET_IS_LINUX ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Android")
+    set(VCPKG_TARGET_IS_ANDROID ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
+    set(VCPKG_TARGET_IS_FREEBSD ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
+    set(VCPKG_TARGET_IS_OPENBSD ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "MinGW")
+    set(VCPKG_TARGET_IS_WINDOWS ON)
+    set(VCPKG_TARGET_IS_MINGW ON)
+elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    set(VCPKG_TARGET_IS_EMSCRIPTEN ON)
+endif()
+
+#Helper variables to identify the host system name
+if (CMAKE_HOST_WIN32)
+    set(VCPKG_HOST_IS_WINDOWS ON)
+elseif (CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+    set(VCPKG_HOST_IS_OSX ON)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+    set(VCPKG_HOST_IS_LINUX ON)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
+    set(VCPKG_HOST_IS_FREEBSD ON)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD")
+    set(VCPKG_HOST_IS_OPENBSD ON)
+endif()
+
+#Helper variable to identify the host path separator.
+if(CMAKE_HOST_WIN32)
+    set(VCPKG_HOST_PATH_SEPARATOR ";")
+elseif(CMAKE_HOST_UNIX)
+    set(VCPKG_HOST_PATH_SEPARATOR ":")
+endif()
+
+#Helper variables to identify executables on host/target
+if(CMAKE_HOST_WIN32)
+    set(VCPKG_HOST_EXECUTABLE_SUFFIX ".exe")
+else()
+    set(VCPKG_HOST_EXECUTABLE_SUFFIX "")
+endif()
+#set(CMAKE_EXECUTABLE_SUFFIX ${VCPKG_HOST_EXECUTABLE_SUFFIX}) not required by find_program
+
+if(VCPKG_TARGET_IS_WINDOWS)
+    set(VCPKG_TARGET_EXECUTABLE_SUFFIX ".exe")
+else()
+    set(VCPKG_TARGET_EXECUTABLE_SUFFIX "")
+endif()
+
+#Helper variables to identify bundles on host/target
+if(VCPKG_HOST_IS_OSX)
+    set(VCPKG_HOST_BUNDLE_SUFFIX ".app")
+else()
+    set(VCPKG_HOST_BUNDLE_SUFFIX "")
+endif()
+
+if(VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_IOS)
+    set(VCPKG_TARGET_BUNDLE_SUFFIX ".app")
+else()
+    set(VCPKG_TARGET_BUNDLE_SUFFIX "")
+endif()
+
+#Helper variables for libraries
+if(VCPKG_TARGET_IS_MINGW)
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".dll.a")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dll")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_PREFIX "lib")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".dll" ".dll.a" ".a" ".lib")
+    set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
+elseif(VCPKG_TARGET_IS_WINDOWS)
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".lib")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dll")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".lib")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_PREFIX "")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".lib" ".dll") #This is a slight modification to CMakes value which does not include ".dll".
+    set(VCPKG_FIND_LIBRARY_PREFIXES "" "lib") #This is a slight modification to CMakes value which does not include "lib".
+elseif(VCPKG_TARGET_IS_OSX)
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX "")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dylib")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".tbd" ".dylib" ".so" ".a")
+    set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
+else()
+    set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
+    set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX "")
+    set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".so")
+    set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
+    set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
+    set(VCPKG_FIND_LIBRARY_SUFFIXES ".so" ".a")
+    set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
+endif()
+#Setting these variables allows find_library to work in script mode and thus in portfiles!
+#This allows us scale down on hardcoded target dependent paths in portfiles
+set(CMAKE_STATIC_LIBRARY_SUFFIX "${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX}")
+set(CMAKE_SHARED_LIBRARY_SUFFIX "${VCPKG_TARGET_SHARED_LIBRARY_SUFFIX}")
+set(CMAKE_IMPORT_LIBRARY_SUFFIX "${VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX}")
+set(CMAKE_STATIC_LIBRARY_PREFIX "${VCPKG_TARGET_STATIC_LIBRARY_PREFIX}")
+set(CMAKE_SHARED_LIBRARY_PREFIX "${VCPKG_TARGET_SHARED_LIBRARY_PREFIX}")
+set(CMAKE_IMPORT_LIBRARY_PREFIX "${VCPKG_TARGET_IMPORT_LIBRARY_PREFIX}")
+
+set(CMAKE_FIND_LIBRARY_SUFFIXES "${VCPKG_FIND_LIBRARY_SUFFIXES}" CACHE INTERNAL "") # Required by find_library
+set(CMAKE_FIND_LIBRARY_PREFIXES "${VCPKG_FIND_LIBRARY_PREFIXES}" CACHE INTERNAL "") # Required by find_library
+
+# Append platform libraries to VCPKG_SYSTEM_LIBRARIES
+# The variable are just appended to permit to custom triplets define the variable
+
+# Platforms with libdl
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES dl)
+endif()
+
+# Platforms with libm
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES m)
+endif()
+
+# Platforms with pthread
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES pthread)
+endif()
+
+# Platforms with libstdc++
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES [[stdc\+\+]])
+endif()
+
+# Platforms with libc++
+if(VCPKG_TARGET_IS_OSX)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES [[c\+\+]])
+endif()
+
+# Platforms with librt
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES rt)
+endif()
+
+# Platforms with GCC libs
+if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES gcc)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES gcc_s)
+endif()
+
+# Platforms with system iconv
+if(VCPKG_TARGET_IS_OSX)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES iconv)
+endif()
+
+# Windows system libs
+if(VCPKG_TARGET_IS_WINDOWS)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES advapi32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES bcrypt)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES dinput8)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES gdi32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES imm32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES oleaut32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES ole32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES psapi)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES secur32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES setupapi)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES shell32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES shlwapi)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES strmiids)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES user32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES uuid)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES version)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES vfw32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES winmm)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES wsock32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES Ws2_32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES wldap32)
+    list(APPEND VCPKG_SYSTEM_LIBRARIES crypt32)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_gn.cmake

@@ -0,0 +1,52 @@
+function(z_vcpkg_configure_gn_generate)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;CONFIG;ARGS" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Internal error: generate was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    message(STATUS "Generating build (${arg_CONFIG})...")
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${arg_CONFIG}")
+    vcpkg_execute_required_process(
+        COMMAND "${GN}" gen "${CURRENT_BUILDTREES_DIR}/${arg_CONFIG}" "${arg_ARGS}"
+        WORKING_DIRECTORY "${arg_SOURCE_PATH}"
+        LOGNAME "generate-${arg_CONFIG}"
+    )
+endfunction()
+
+function(vcpkg_configure_gn)
+    if(Z_VCPKG_GN_CONFIGURE_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-gn; using both vcpkg-gn and vcpkg_configure_gn in the same port is unsupported.")
+    else()
+        message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "This function 'vcpkg_configure_gn' is obsolete. Use 'vcpkg_gn_configure' in port 'vcpkg-gn'.")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_configure_gn was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_SOURCE_PATH)
+        message(FATAL_ERROR "SOURCE_PATH must be specified.")
+    endif()
+
+    vcpkg_find_acquire_program(PYTHON3)
+    get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
+    vcpkg_add_to_path(PREPEND "${PYTHON3_DIR}")
+
+    vcpkg_find_acquire_program(GN)
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        z_vcpkg_configure_gn_generate(
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            CONFIG "${TARGET_TRIPLET}-dbg"
+            ARGS "--args=${arg_OPTIONS} ${arg_OPTIONS_DEBUG}"
+        )
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        z_vcpkg_configure_gn_generate(
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            CONFIG "${TARGET_TRIPLET}-rel"
+            ARGS "--args=${arg_OPTIONS} ${arg_OPTIONS_RELEASE}"
+        )
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_meson.cmake

@@ -0,0 +1,452 @@
+function(z_vcpkg_meson_set_proglist_variables config_type)
+    if(VCPKG_TARGET_IS_WINDOWS)
+        set(proglist MT AR)
+    else()
+        set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT)
+    endif()
+    foreach(prog IN LISTS proglist)
+        if(VCPKG_DETECTED_CMAKE_${prog})
+            if(meson_${prog})
+                string(TOUPPER "MESON_${meson_${prog}}" var_to_set)
+                set("${var_to_set}" "${meson_${prog}} = ['${VCPKG_DETECTED_CMAKE_${prog}}']" PARENT_SCOPE)
+            elseif(${prog} STREQUAL AR AND VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${config_type})
+                # Probably need to move AR somewhere else
+                string(TOLOWER "${prog}" proglower)
+                z_vcpkg_meson_convert_compiler_flags_to_list(ar_flags "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${config_type}}")
+                list(PREPEND ar_flags "${VCPKG_DETECTED_CMAKE_${prog}}")
+                z_vcpkg_meson_convert_list_to_python_array(ar_flags ${ar_flags})
+                set("MESON_AR" "${proglower} = ${ar_flags}" PARENT_SCOPE)
+            else()
+                string(TOUPPER "MESON_${prog}" var_to_set)
+                string(TOLOWER "${prog}" proglower)
+                set("${var_to_set}" "${proglower} = ['${VCPKG_DETECTED_CMAKE_${prog}}']" PARENT_SCOPE)
+            endif()
+        endif()
+    endforeach()
+    set(compilers "${arg_LANGUAGES}")
+    if(VCPKG_TARGET_IS_WINDOWS)
+        list(APPEND compilers RC)
+    endif()
+    set(meson_RC windres)
+    set(meson_Fortran fc)
+    set(meson_CXX cpp)
+    foreach(prog IN LISTS compilers)
+        if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER)
+            string(TOUPPER "MESON_${prog}" var_to_set)
+            if(meson_${prog})
+                if(VCPKG_DETECTED_CMAKE_${prog}_FLAGS_${config_type})
+                    # Need compiler flags in prog vars for sanity check.
+                    z_vcpkg_meson_convert_compiler_flags_to_list(${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_FLAGS_${config_type}}")
+                endif()
+                list(PREPEND ${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}")
+                list(FILTER ${prog}flags EXCLUDE REGEX "(-|/)nologo") # Breaks compiler detection otherwise
+                z_vcpkg_meson_convert_list_to_python_array(${prog}flags ${${prog}flags})
+                set("${var_to_set}" "${meson_${prog}} = ${${prog}flags}" PARENT_SCOPE)
+                if (DEFINED VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID AND NOT VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID MATCHES "^(GNU|Intel)$")
+                    string(TOUPPER "MESON_${prog}_LD" var_to_set)
+                    set(${var_to_set} "${meson_${prog}}_ld = ['${VCPKG_DETECTED_CMAKE_LINKER}']" PARENT_SCOPE)
+                endif()
+            else()
+                if(VCPKG_DETECTED_CMAKE_${prog}_FLAGS_${config_type})
+                     # Need compiler flags in prog vars for sanity check.
+                    z_vcpkg_meson_convert_compiler_flags_to_list(${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_FLAGS_${config_type}}")
+                endif()
+                list(PREPEND ${prog}flags "${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}")
+                list(FILTER ${prog}flags EXCLUDE REGEX "(-|/)nologo") # Breaks compiler detection otherwise
+                z_vcpkg_meson_convert_list_to_python_array(${prog}flags ${${prog}flags})
+                string(TOLOWER "${prog}" proglower)
+                set("${var_to_set}" "${proglower} = ${${prog}flags}" PARENT_SCOPE)
+                if (DEFINED VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID AND NOT VCPKG_DETECTED_CMAKE_${prog}_COMPILER_ID MATCHES "^(GNU|Intel)$")
+                    string(TOUPPER "MESON_${prog}_LD" var_to_set)
+                    set(${var_to_set} "${proglower}_ld = ['${VCPKG_DETECTED_CMAKE_LINKER}']" PARENT_SCOPE)
+                endif()
+            endif()
+        endif()
+    endforeach()
+endfunction()
+
+function(z_vcpkg_meson_convert_compiler_flags_to_list out_var compiler_flags)
+    separate_arguments(cmake_list NATIVE_COMMAND "${compiler_flags}")
+    list(TRANSFORM cmake_list REPLACE ";" [[\\;]])
+    set("${out_var}" "${cmake_list}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_meson_convert_list_to_python_array out_var)
+    z_vcpkg_function_arguments(flag_list 1)
+    vcpkg_list(REMOVE_ITEM flag_list "") # remove empty elements if any
+    vcpkg_list(JOIN flag_list "', '" flag_list)
+    set("${out_var}" "['${flag_list}']" PARENT_SCOPE)
+endfunction()
+
+# Generates the required compiler properties for meson
+function(z_vcpkg_meson_set_flags_variables config_type)
+    if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+        set(libpath_flag /LIBPATH:)
+    else()
+        set(libpath_flag -L)
+    endif()
+    if(config_type STREQUAL "DEBUG")
+        set(path_suffix "/debug")
+    else()
+        set(path_suffix "")
+    endif()
+
+    set(includepath "-I${CURRENT_INSTALLED_DIR}/include")
+    set(libpath "${libpath_flag}${CURRENT_INSTALLED_DIR}${path_suffix}/lib")
+
+    foreach(lang IN LISTS arg_LANGUAGES)
+        z_vcpkg_meson_convert_compiler_flags_to_list(${lang}flags "${VCPKG_DETECTED_CMAKE_${lang}_FLAGS_${config_type}}")
+        if(lang MATCHES "^(C|CXX)$")
+            vcpkg_list(APPEND ${lang}flags "${includepath}")
+        endif()
+        z_vcpkg_meson_convert_list_to_python_array(${lang}flags ${${lang}flags})
+        set(lang_mapping "${lang}")
+        if(lang STREQUAL "Fortran")
+            set(lang_mapping "FC")
+        endif()
+        string(TOLOWER "${lang_mapping}" langlower)
+        if(lang STREQUAL "CXX")
+            set(langlower cpp)
+        endif()
+        set(MESON_${lang_mapping}FLAGS "${langlower}_args = ${${lang}flags}\n")
+        set(linker_flags "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${config_type}}")
+        z_vcpkg_meson_convert_compiler_flags_to_list(linker_flags "${linker_flags}")
+        vcpkg_list(APPEND linker_flags "${libpath}")
+        z_vcpkg_meson_convert_list_to_python_array(linker_flags ${linker_flags})
+        string(APPEND MESON_${lang_mapping}FLAGS "${langlower}_link_args = ${linker_flags}\n")
+        set(MESON_${lang_mapping}FLAGS "${MESON_${lang_mapping}FLAGS}" PARENT_SCOPE)
+    endforeach()
+endfunction()
+
+function(z_vcpkg_get_build_and_host_system build_system host_system is_cross) #https://mesonbuild.com/Cross-compilation.html
+    set(build_unknown FALSE)
+    if(CMAKE_HOST_WIN32)
+        if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+            set(build_arch $ENV{PROCESSOR_ARCHITEW6432})
+        else()
+            set(build_arch $ENV{PROCESSOR_ARCHITECTURE})
+        endif()
+        if(build_arch MATCHES "(amd|AMD)64")
+            set(build_cpu_fam x86_64)
+            set(build_cpu x86_64)
+        elseif(build_arch MATCHES "(x|X)86")
+            set(build_cpu_fam x86)
+            set(build_cpu i686)
+        elseif(build_arch MATCHES "^(ARM|arm)64$")
+            set(build_cpu_fam aarch64)
+            set(build_cpu armv8)
+        elseif(build_arch MATCHES "^(ARM|arm)$")
+            set(build_cpu_fam arm)
+            set(build_cpu armv7hl)
+        else()
+            if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+                message(WARNING "Unsupported build architecture ${build_arch}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+            endif()
+            set(build_unknown TRUE)
+        endif()
+    elseif(CMAKE_HOST_UNIX)
+        # at this stage, CMAKE_HOST_SYSTEM_PROCESSOR is not defined
+        execute_process(
+            COMMAND uname -m
+            OUTPUT_VARIABLE MACHINE
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            COMMAND_ERROR_IS_FATAL ANY)
+
+        # Show real machine architecture to visually understand whether we are in a native Apple Silicon terminal or running under Rosetta emulation
+        debug_message("Machine: ${MACHINE}")
+
+        if(MACHINE MATCHES "arm64|aarch64")
+            set(build_cpu_fam aarch64)
+            set(build_cpu armv8)
+        elseif(MACHINE MATCHES "armv7h?l")
+            set(build_cpu_fam arm)
+            set(build_cpu ${MACHINE})
+        elseif(MACHINE MATCHES "x86_64|amd64")
+            set(build_cpu_fam x86_64)
+            set(build_cpu x86_64)
+        elseif(MACHINE MATCHES "x86|i686")
+            set(build_cpu_fam x86)
+            set(build_cpu i686)
+        elseif(MACHINE MATCHES "i386")
+            set(build_cpu_fam x86)
+            set(build_cpu i386)
+        elseif(MACHINE MATCHES "loongarch64")
+            set(build_cpu_fam loongarch64)
+            set(build_cpu loongarch64)
+        else()
+            # https://github.com/mesonbuild/meson/blob/master/docs/markdown/Reference-tables.md#cpu-families
+            if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+                message(WARNING "Unhandled machine: ${MACHINE}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+            endif()
+            set(build_unknown TRUE)
+        endif()
+    else()
+        if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+            message(WARNING "Failed to detect the build architecture! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the build_machine entry!")
+        endif()
+        set(build_unknown TRUE)
+    endif()
+
+    set(build "[build_machine]\n") # Machine the build is performed on
+    string(APPEND build "endian = 'little'\n")
+    if(WIN32)
+        string(APPEND build "system = 'windows'\n")
+    elseif(DARWIN)
+        string(APPEND build "system = 'darwin'\n")
+    elseif(CYGWIN)
+        string(APPEND build "system = 'cygwin'\n")
+    elseif(UNIX)
+        string(APPEND build "system = 'linux'\n")
+    else()
+        set(build_unknown TRUE)
+    endif()
+
+    if(DEFINED build_cpu_fam)
+        string(APPEND build "cpu_family = '${build_cpu_fam}'\n")
+    endif()
+    if(DEFINED build_cpu)
+        string(APPEND build "cpu = '${build_cpu}'")
+    endif()
+    if(NOT build_unknown)
+        set(${build_system} "${build}" PARENT_SCOPE)
+    endif()
+
+    set(host_unkown FALSE)
+    if(VCPKG_TARGET_ARCHITECTURE MATCHES "(amd|AMD|x|X)64")
+        set(host_cpu_fam x86_64)
+        set(host_cpu x86_64)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
+        set(host_cpu_fam x86)
+        set(host_cpu i686)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
+        set(host_cpu_fam aarch64)
+        set(host_cpu armv8)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
+        set(host_cpu_fam arm)
+        set(host_cpu armv7hl)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "loongarch64")
+        set(host_cpu_fam loongarch64)
+        set(host_cpu loongarch64)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "wasm32")
+        set(host_cpu_fam wasm32)
+        set(host_cpu wasm32)
+    else()
+        if(NOT DEFINED VCPKG_MESON_CROSS_FILE OR NOT DEFINED VCPKG_MESON_NATIVE_FILE)
+            message(WARNING "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}! Please set VCPKG_MESON_(CROSS|NATIVE)_FILE to a meson file containing the host_machine entry!" )
+        endif()
+        set(host_unkown TRUE)
+    endif()
+
+    set(host "[host_machine]\n") # host=target in vcpkg. 
+    string(APPEND host "endian = 'little'\n")
+    if(NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_TARGET_IS_MINGW OR VCPKG_TARGET_IS_UWP)
+        set(meson_system_name "windows")
+    else()
+        string(TOLOWER "${VCPKG_CMAKE_SYSTEM_NAME}" meson_system_name)
+    endif()
+    string(APPEND host "system = '${meson_system_name}'\n")
+    string(APPEND host "cpu_family = '${host_cpu_fam}'\n")
+    string(APPEND host "cpu = '${host_cpu}'")
+    if(NOT host_unkown)
+        set(${host_system} "${host}" PARENT_SCOPE)
+    endif()
+
+    if(NOT build_cpu_fam MATCHES "${host_cpu_fam}"
+       OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_IOS OR VCPKG_TARGET_IS_UWP
+       OR (VCPKG_TARGET_IS_MINGW AND NOT WIN32))
+        set(${is_cross} TRUE PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(z_vcpkg_meson_setup_extra_windows_variables config_type)
+    ## b_vscrt
+    if(VCPKG_CRT_LINKAGE STREQUAL "static")
+        set(crt_type "mt")
+    else()
+        set(crt_type "md")
+    endif()
+    if(config_type STREQUAL "DEBUG")
+        set(crt_type "${crt_type}d")
+    endif()
+    set(MESON_VSCRT_LINKAGE "b_vscrt = '${crt_type}'" PARENT_SCOPE)
+    ## winlibs
+    separate_arguments(c_winlibs NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}")
+    separate_arguments(cpp_winlibs NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
+    z_vcpkg_meson_convert_list_to_python_array(c_winlibs ${c_winlibs})
+    z_vcpkg_meson_convert_list_to_python_array(cpp_winlibs ${cpp_winlibs})
+    set(MESON_WINLIBS "c_winlibs = ${c_winlibs}\n")
+    string(APPEND MESON_WINLIBS "cpp_winlibs = ${cpp_winlibs}")
+    set(MESON_WINLIBS "${MESON_WINLIBS}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_meson_setup_variables config_type)
+    set(meson_var_list VSCRT_LINKAGE WINLIBS MT AR RC C C_LD CXX CXX_LD OBJC OBJC_LD OBJCXX OBJCXX_LD FC FC_LD WINDRES CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS FCFLAGS SHARED_LINKER_FLAGS)
+    foreach(var IN LISTS meson_var_list)
+        set(MESON_${var} "")
+    endforeach()
+
+    if(VCPKG_TARGET_IS_WINDOWS)
+        z_vcpkg_meson_setup_extra_windows_variables("${config_type}")
+    endif()
+
+    z_vcpkg_meson_set_proglist_variables("${config_type}")
+    z_vcpkg_meson_set_flags_variables("${config_type}")
+
+    foreach(var IN LISTS meson_var_list)
+        set(MESON_${var} "${MESON_${var}}" PARENT_SCOPE)
+    endforeach()
+endfunction()
+
+function(vcpkg_configure_meson)
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "NO_PKG_CONFIG"
+        "SOURCE_PATH"
+        "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;LANGUAGES;ADDITIONAL_BINARIES;ADDITIONAL_NATIVE_BINARIES;ADDITIONAL_CROSS_BINARIES"
+    )
+
+    if(NOT arg_LANGUAGES)
+        set(arg_LANGUAGES C CXX)
+    endif()
+
+    if(DEFINED arg_ADDITIONAL_NATIVE_BINARIES OR DEFINED arg_ADDITIONAL_CROSS_BINARIES)
+        message(WARNING "Options ADDITIONAL_(NATIVE|CROSS)_BINARIES have been deprecated. Only use ADDITIONAL_BINARIES!")
+    endif()
+
+    vcpkg_list(APPEND arg_ADDITIONAL_BINARIES ${arg_ADDITIONAL_NATIVE_BINARIES} ${arg_ADDITIONAL_CROSS_BINARIES})
+    vcpkg_list(REMOVE_DUPLICATES arg_ADDITIONAL_BINARIES)
+    vcpkg_list(JOIN arg_ADDITIONAL_BINARIES "\n" MESON_ADDITIONAL_BINARIES)
+
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
+
+    if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
+        z_vcpkg_select_default_vcpkg_chainload_toolchain()
+    endif()
+    z_vcpkg_get_cmake_vars(cmake_vars_file)
+    debug_message("Including cmake vars from: ${cmake_vars_file}")
+    include("${cmake_vars_file}")
+
+    vcpkg_find_acquire_program(MESON)
+
+    get_filename_component(CMAKE_PATH "${CMAKE_COMMAND}" DIRECTORY)
+    vcpkg_add_to_path("${CMAKE_PATH}" PREPEND) # Make CMake invokeable for Meson
+
+    vcpkg_find_acquire_program(PYTHON3)
+    get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
+    vcpkg_add_to_path("${PYTHON3_DIR}")
+
+    vcpkg_find_acquire_program(NINJA)
+    get_filename_component(NINJA_PATH ${NINJA} DIRECTORY)
+    vcpkg_add_to_path(PREPEND "${NINJA_PATH}") # Prepend to use the correct ninja.
+
+    set(buildtypes "")
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        set(buildname "DEBUG")
+        vcpkg_list(APPEND buildtypes "${buildname}")
+        set(path_suffix_${buildname} "debug/")
+        set(suffix_${buildname} "dbg")
+        set(meson_input_file_${buildname} "${CURRENT_BUILDTREES_DIR}/meson-${TARGET_TRIPLET}-${suffix_${buildname}}.log")
+    endif()
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        set(buildname "RELEASE")
+        vcpkg_list(APPEND buildtypes "${buildname}")
+        set(path_suffix_${buildname} "")
+        set(suffix_${buildname} "rel")
+        set(meson_input_file_${buildname} "${CURRENT_BUILDTREES_DIR}/meson-${TARGET_TRIPLET}-${suffix_${buildname}}.log")
+    endif()
+
+    vcpkg_list(APPEND arg_OPTIONS --backend ninja --wrap-mode nodownload -Dbuildtype=plain)
+
+    z_vcpkg_get_build_and_host_system(MESON_HOST_MACHINE MESON_BUILD_MACHINE IS_CROSS)
+
+    if(IS_CROSS)
+        # VCPKG_CROSSCOMPILING is not used since it regresses a lot of ports in x64-windows-x triplets
+        # For consistency this should proably be changed in the future?
+        vcpkg_list(APPEND arg_OPTIONS --native "${SCRIPTS}/buildsystems/meson/none.txt")
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --cross "${meson_input_file_DEBUG}")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --cross "${meson_input_file_RELEASE}")
+    else()
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --native "${meson_input_file_DEBUG}")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --native "${meson_input_file_RELEASE}")
+    endif()
+
+    # User provided cross/native files
+    if(VCPKG_MESON_NATIVE_FILE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --native "${VCPKG_MESON_NATIVE_FILE}")
+    endif()
+    if(VCPKG_MESON_NATIVE_FILE_RELEASE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --native "${VCPKG_MESON_NATIVE_FILE_RELEASE}")
+    endif()
+    if(VCPKG_MESON_NATIVE_FILE_DEBUG)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --native "${VCPKG_MESON_NATIVE_FILE_DEBUG}")
+    endif()
+    if(VCPKG_MESON_CROSS_FILE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE}")
+    endif()
+    if(VCPKG_MESON_CROSS_FILE_RELEASE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE_RELEASE}")
+    endif()
+    if(VCPKG_MESON_CROSS_FILE_DEBUG)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG --cross "${VCPKG_MESON_CROSS_FILE_DEBUG}")
+    endif()
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
+        set(MESON_DEFAULT_LIBRARY shared)
+    else()
+        set(MESON_DEFAULT_LIBRARY static)
+    endif()
+
+    vcpkg_list(APPEND arg_OPTIONS --libdir lib) # else meson install into an architecture describing folder
+    vcpkg_list(APPEND arg_OPTIONS_DEBUG -Ddebug=true --prefix "${CURRENT_PACKAGES_DIR}/debug" --includedir ../include)
+    vcpkg_list(APPEND arg_OPTIONS_RELEASE -Ddebug=false --prefix "${CURRENT_PACKAGES_DIR}")
+
+    # select meson cmd-line options
+    if(VCPKG_TARGET_IS_WINDOWS)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}/share']")
+    else()
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}']")
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug']")
+    endif()
+
+    # Allow overrides / additional configuration variables from triplets
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS)
+        vcpkg_list(APPEND arg_OPTIONS ${VCPKG_MESON_CONFIGURE_OPTIONS})
+    endif()
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS_RELEASE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE ${VCPKG_MESON_CONFIGURE_OPTIONS_RELEASE})
+    endif()
+    if(DEFINED VCPKG_MESON_CONFIGURE_OPTIONS_DEBUG)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG ${VCPKG_MESON_CONFIGURE_OPTIONS_DEBUG})
+    endif()
+
+    # configure build
+    foreach(buildtype IN LISTS buildtypes)
+        message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}}")
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}")
+        #setting up PKGCONFIG
+        if(NOT arg_NO_PKG_CONFIG)
+            z_vcpkg_setup_pkgconfig_path(CONFIG "${buildtype}")
+        endif()
+
+        z_vcpkg_meson_setup_variables(${buildtype})
+        configure_file("${SCRIPTS}/buildsystems/meson/meson.template.in" "${meson_input_file_${buildtype}}" @ONLY)
+
+        vcpkg_execute_required_process(
+            COMMAND ${MESON} ${arg_OPTIONS} ${arg_OPTIONS_${buildtype}} ${arg_SOURCE_PATH}
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}"
+            LOGNAME config-${TARGET_TRIPLET}-${suffix_${buildtype}}
+            SAVE_LOG_FILES
+                meson-logs/meson-log.txt
+                meson-info/intro-dependencies.json
+                meson-logs/install-log.txt
+        )
+
+        message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}} done")
+
+        if(NOT arg_NO_PKG_CONFIG)
+            z_vcpkg_restore_pkgconfig_path()
+        endif()
+    endforeach()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_pdbs.cmake

@@ -0,0 +1,49 @@
+function(vcpkg_copy_pdbs)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "" "BUILD_PATHS")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED arg_BUILD_PATHS)
+        set(arg_BUILD_PATHS
+            "${CURRENT_PACKAGES_DIR}/bin/*.dll"
+            "${CURRENT_PACKAGES_DIR}/debug/bin/*.dll"
+        )
+    endif()
+
+    set(dlls_without_matching_pdbs "")
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic" AND VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+        file(GLOB_RECURSE dlls ${arg_BUILD_PATHS})
+
+        set(vslang_backup "$ENV{VSLANG}")
+        set(ENV{VSLANG} 1033)
+
+        foreach(dll IN LISTS dlls)
+            execute_process(COMMAND dumpbin /PDBPATH "${dll}"
+                            COMMAND findstr PDB
+                OUTPUT_VARIABLE pdb_line
+                ERROR_QUIET
+                RESULT_VARIABLE error_code
+            )
+
+            if(error_code EQUAL "0" AND pdb_line MATCHES "PDB file found at.*'(.*)'")
+                set(pdb_path "${CMAKE_MATCH_1}")
+                cmake_path(GET dll PARENT_PATH dll_dir)
+                file(COPY "${pdb_path}" DESTINATION "${dll_dir}")
+            else()
+                list(APPEND dlls_without_matching_pdbs "${dll}")
+            endif()
+        endforeach()
+
+        set(ENV{VSLANG} "${vslang_backup}")
+
+        if(NOT dlls_without_matching_pdbs STREQUAL "")
+            list(JOIN dlls_without_matching_pdbs "\n    " message)
+            message(WARNING "Could not find a matching pdb file for:
+    ${message}\n")
+        endif()
+    endif()
+
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_tools.cmake

@@ -0,0 +1,49 @@
+function(vcpkg_copy_tools)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "AUTO_CLEAN" "SEARCH_DIR;DESTINATION" "TOOL_NAMES")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(NOT DEFINED arg_TOOL_NAMES)
+        message(FATAL_ERROR "TOOL_NAMES must be specified.")
+    endif()
+
+    if(NOT DEFINED arg_DESTINATION)
+        set(arg_DESTINATION "${CURRENT_PACKAGES_DIR}/tools/${PORT}")
+    endif()
+
+    if(NOT DEFINED arg_SEARCH_DIR)
+        set(arg_SEARCH_DIR "${CURRENT_PACKAGES_DIR}/bin")
+    elseif(NOT IS_DIRECTORY "${arg_SEARCH_DIR}")
+        message(FATAL_ERROR "SEARCH_DIR (${arg_SEARCH_DIR}) must be a directory")
+    endif()
+
+    foreach(tool_name IN LISTS arg_TOOL_NAMES)
+        set(tool_path "${arg_SEARCH_DIR}/${tool_name}${VCPKG_TARGET_EXECUTABLE_SUFFIX}")
+        set(tool_pdb "${arg_SEARCH_DIR}/${tool_name}.pdb")
+        if(EXISTS "${tool_path}")
+            file(COPY "${tool_path}" DESTINATION "${arg_DESTINATION}")
+        elseif(NOT "${VCPKG_TARGET_BUNDLE_SUFFIX}" STREQUAL "" AND NOT "${VCPKG_TARGET_BUNDLE_SUFFIX}" STREQUAL "${VCPKG_TARGET_EXECUTABLE_SUFFIX}")
+            set(bundle_path "${arg_SEARCH_DIR}/${tool_name}${VCPKG_TARGET_BUNDLE_SUFFIX}")
+            if(EXISTS "${bundle_path}")
+                file(COPY "${bundle_path}" DESTINATION "${arg_DESTINATION}")
+            else()
+                message(FATAL_ERROR "Couldn't find tool \"${tool_name}\":
+    neither \"${tool_path}\" nor \"${bundle_path}\" exists")
+            endif()
+        else()
+            message(FATAL_ERROR "Couldn't find tool \"${tool_name}\":
+    \"${tool_path}\" does not exist")
+        endif()
+        if(EXISTS "${tool_pdb}")
+            file(COPY "${tool_pdb}" DESTINATION "${arg_DESTINATION}")
+        endif()
+    endforeach()
+
+    if(arg_AUTO_CLEAN)
+        vcpkg_clean_executables_in_bin(FILE_NAMES ${arg_TOOL_NAMES})
+    endif()
+
+    vcpkg_copy_tool_dependencies("${arg_DESTINATION}")
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_download_sourceforge.cmake

@@ -0,0 +1,85 @@
+function(vcpkg_download_sourceforge out_var)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg"
+        ""
+        "REPO;REF;SHA512;FILENAME"
+        "")
+
+    foreach(arg_name IN ITEMS REPO SHA512 FILENAME)
+        if(NOT DEFINED "arg_${arg_name}")
+            message(FATAL_ERROR "${arg_name} is required.")
+        endif()
+    endforeach()
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unrecognized arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    set(sourceforge_host "https://sourceforge.net/projects")
+
+    if(arg_REPO MATCHES "^([^/]*)$") # just one element
+        set(org_name "${CMAKE_MATCH_1}")
+        set(repo_name "")
+    elseif(arg_REPO MATCHES "^([^/]*)/([^/]*)$") # two elements
+        set(org_name "${CMAKE_MATCH_1}")
+        set(repo_name "${CMAKE_MATCH_2}")
+    else()
+        message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name. It must be:
+    - an organization name without any slashes, or
+    - an organization name followed by a repository name separated by a single slash")
+    endif()
+    
+    if(DEFINED arg_REF)
+        set(url "${sourceforge_host}/${org_name}/files/${repo_name}/${arg_REF}/${arg_FILENAME}")
+    elseif(DEFINED repo_name)
+        set(url "${sourceforge_host}/${org_name}/${repo_name}/files/${arg_FILENAME}")
+    else()
+        set(url "${sourceforge_host}/${org_name}/files/${arg_FILENAME}")
+    endif()
+        
+    string(SUBSTRING "${arg_SHA512}" 0 10 sanitized_ref)
+
+    set(sourceforge_mirrors
+        cfhcable        # United States
+        pilotfiber      # New York, NY
+        gigenet         # Chicago, IL
+        versaweb        # Las Vegas, NV
+        ayera           # Modesto, CA
+        netactuate      # Durham, NC
+        phoenixnap      # Tempe, AZ
+        astuteinternet  # Vancouver, BC
+        freefr          # Paris, France
+        netcologne      # Cologne, Germany
+        deac-riga       # Latvia
+        excellmedia     # Hyderabad, India
+        iweb            # Montreal, QC
+        jaist           # Nomi, Japan
+        jztkft          # Mezotur, Hungary
+        managedway      # Detroit, MI
+        nchc            # Taipei, Taiwan
+        netix           # Bulgaria
+        ufpr            # Curitiba, Brazil
+        tenet           # Wynberg, South Africa
+    )
+    if(DEFINED SOURCEFORGE_MIRRORS AND NOT DEFINED VCPKG_SOURCEFORGE_EXTRA_MIRRORS)
+        message(WARNING "Extension point SOURCEFORGE_MIRRORS has been deprecated.
+    Please use the replacement VCPKG_SOURCEFORGE_EXTRA_MIRRORS variable instead.")
+        list(APPEND sourceforge_mirrors "${SOURCEFORGE_MIRRORS}")
+        list(REMOVE_DUPLICATES sourceforge_mirrors)
+    elseif(DEFINED VCPKG_SOURCEFORGE_EXTRA_MIRRORS)
+        list(APPEND sourceforge_mirrors "${VCPKG_SOURCEFORGE_EXTRA_MIRRORS}")
+        list(REMOVE_DUPLICATES sourceforge_mirrors)
+    endif()
+
+    set(all_urls "${url}/download")
+    foreach(mirror IN LISTS sourceforge_mirrors)
+        list(APPEND all_urls "${url}/download?use_mirror=${mirror}")
+    endforeach()
+    
+    vcpkg_download_distfile(archive
+        URLS ${all_urls}
+        SHA512 "${arg_SHA512}"
+        FILENAME "${arg_FILENAME}"
+    )
+
+    set("${out_var}" "${archive}" PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_build_process.cmake

@@ -0,0 +1,141 @@
+set(Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES
+    "LINK : fatal error LNK1102:"
+    " fatal error C1060: "
+    # The linker ran out of memory during execution. We will try continuing once more, with parallelism disabled.
+    "LINK : fatal error LNK1318:"
+    "LINK : fatal error LNK1104:"
+    "LINK : fatal error LNK1201:"
+    "ld terminated with signal 9"
+    "Killed signal terminated program"
+    # Multiple threads using the same directory at the same time cause conflicts, will try again.
+    "Cannot create parent directory"
+    "Cannot write file"
+    # Multiple threads caused the wrong order of creating folders and creating files in folders
+    "Can't open"
+    # `make install` may stumble over concurrency, in particular with `mkdir` on osx.
+    "mkdir [^:]*: File exists"
+)
+list(JOIN Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES "|" Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES)
+
+function(vcpkg_execute_build_process)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "WORKING_DIRECTORY;LOGNAME" "COMMAND;NO_PARALLEL_COMMAND")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    foreach(required_arg IN ITEMS WORKING_DIRECTORY COMMAND)
+        if(NOT DEFINED arg_${required_arg})
+            message(FATAL_ERROR "${required_arg} must be specified.")
+        endif()
+    endforeach()
+
+    if(NOT DEFINED arg_LOGNAME)
+        message(WARNING "LOGNAME should be specified.")
+        set(arg_LOGNAME "build")
+    endif()
+
+    set(log_prefix "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}")
+    set(log_out "${log_prefix}-out.log")
+    set(log_err "${log_prefix}-err.log")
+    set(all_logs "${log_out}" "${log_err}")
+
+    if(X_PORT_PROFILE)
+        vcpkg_list(PREPEND arg_COMMAND "${CMAKE_COMMAND}" "-E" "time")
+        if(DEFINED arg_NO_PARALLEL_COMMAND)
+            vcpkg_list(PREPEND arg_NO_PARALLEL_COMMAND "${CMAKE_COMMAND}" "-E" "time")
+        endif()
+    endif()
+
+    execute_process(
+        COMMAND ${arg_COMMAND}
+        WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+        OUTPUT_FILE "${log_out}"
+        ERROR_FILE "${log_err}"
+        RESULT_VARIABLE error_code
+    )
+    if (NOT error_code MATCHES "^[0-9]+$")
+        list(JOIN arg_COMMAND " " command)
+        message(FATAL_ERROR "Failed to execute command \"${command}\" in working directory \"${arg_WORKING_DIRECTORY}\": ${error_code}")
+    endif()
+    if(NOT error_code EQUAL "0")
+        file(READ "${log_out}" out_contents)
+        file(READ "${log_err}" err_contents)
+        set(all_contents "${out_contents}${err_contents}")
+        if(all_contents MATCHES "${Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES}")
+            message(WARNING "Please ensure your system has sufficient memory.")
+            set(log_out "${log_prefix}-out-1.log")
+            set(log_err "${log_prefix}-err-1.log")
+            list(APPEND all_logs "${log_out}" "${log_err}")
+
+            if(DEFINED arg_NO_PARALLEL_COMMAND)
+                message(STATUS "Restarting build without parallelism")
+                execute_process(
+                    COMMAND ${arg_NO_PARALLEL_COMMAND}
+                    WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+                    OUTPUT_FILE "${log_out}"
+                    ERROR_FILE "${log_err}"
+                    RESULT_VARIABLE error_code
+                )
+            else()
+                message(STATUS "Restarting build")
+                execute_process(
+                    COMMAND ${arg_COMMAND}
+                    WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+                    OUTPUT_FILE "${log_out}"
+                    ERROR_FILE "${log_err}"
+                    RESULT_VARIABLE error_code
+                )
+            endif()
+        elseif(all_contents MATCHES "mt(\\.exe)? : general error c101008d: ")
+            # Antivirus workaround - occasionally files are locked and cause mt.exe to fail
+            message(STATUS "mt.exe has failed. This may be the result of anti-virus. Disabling anti-virus on the buildtree folder may improve build speed")
+            foreach(iteration RANGE 1 3)
+                message(STATUS "Restarting Build ${TARGET_TRIPLET}-${SHORT_BUILDTYPE} because of mt.exe file locking issue. Iteration: ${iteration}")
+
+                set(log_out "${log_prefix}-out-${iteration}.log")
+                set(log_err "${log_prefix}-err-${iteration}.log")
+                list(APPEND all_logs "${log_out}" "${log_err}")
+                execute_process(
+                    COMMAND ${arg_COMMAND}
+                    WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+                    OUTPUT_FILE "${log_out}"
+                    ERROR_FILE "${log_err}"
+                    RESULT_VARIABLE error_code
+                )
+
+                if(error_code EQUAL "0")
+                    break()
+                endif()
+
+                file(READ "${log_out}" out_contents)
+                file(READ "${log_err}" err_contents)
+                set(all_contents "${out_contents}${err_contents}")
+                if(NOT all_contents MATCHES "mt : general error c101008d: ")
+                    break()
+                endif()
+            endforeach()
+        endif()
+    endif()
+
+    if(NOT error_code EQUAL "0")
+        set(stringified_logs "")
+        foreach(log IN LISTS all_logs)
+            if(NOT EXISTS "${log}")
+                continue()
+            endif()
+            file(SIZE "${log}" log_size)
+            if(NOT log_size EQUAL "0")
+                file(TO_NATIVE_PATH "${log}" native_log)
+                string(APPEND stringified_logs "    ${native_log}\n")
+                file(APPEND "${Z_VCPKG_ERROR_LOG_COLLECTION_FILE}" "${native_log}\n")
+            endif()
+        endforeach()
+        z_vcpkg_prettify_command_line(pretty_command ${arg_COMMAND})
+        message(FATAL_ERROR
+            "  Command failed: ${pretty_command}\n"
+            "  Working Directory: ${arg_WORKING_DIRECTORY}\n"
+            "  See logs for more information:\n"
+            "${stringified_logs}"
+        )
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_in_download_mode.cmake

@@ -0,0 +1,46 @@
+function(vcpkg_execute_in_download_mode)
+    # this allows us to grab the value of the output variables, but pass through the rest of the arguments
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "RESULT_VARIABLE;RESULTS_VARIABLE;OUTPUT_VARIABLE;ERROR_VARIABLE" "")
+
+    set(output_and_error_same OFF)
+    set(output_variable_param "")
+    set(error_variable_param "")
+    set(result_variable_param "")
+    set(results_variable_param "")
+    if(DEFINED arg_OUTPUT_VARIABLE AND DEFINED arg_ERROR_VARIABLE AND arg_OUTPUT_VARIABLE STREQUAL arg_ERROR_VARIABLE)
+        set(output_variable_param OUTPUT_VARIABLE out_err_var)
+        set(error_variable_param ERROR_VARIABLE out_err_var)
+        set(output_and_error_same ON)
+    else()
+        if(DEFINED arg_OUTPUT_VARIABLE)
+            set(output_variable_param OUTPUT_VARIABLE out_var)
+        endif()
+        if(DEFINED arg_ERROR_VARIABLE)
+            set(error_variable_param ERROR_VARIABLE err_var)
+        endif()
+    endif()
+    if(DEFINED arg_RESULT_VARIABLE)
+        set(result_variable_param RESULT_VARIABLE result_var)
+    endif()
+    if(DEFINED arg_RESULTS_VARIABLE)
+        set(results_variable_param RESULTS_VARIABLE results_var)
+    endif()
+
+    cmake_language(CALL "${Z_VCPKG_EXECUTE_PROCESS_NAME}"
+        ${arg_UNPARSED_ARGUMENTS}
+        ${output_variable_param}
+        ${error_variable_param}
+        ${result_variable_param}
+        ${results_variable_param}
+    )
+
+    if(output_and_error_same)
+        z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_err_var)
+    else()
+        z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_var)
+        z_vcpkg_forward_output_variable(arg_ERROR_VARIABLE err_var)
+    endif()
+
+    z_vcpkg_forward_output_variable(arg_RESULT_VARIABLE result_var)
+    z_vcpkg_forward_output_variable(arg_RESULTS_VARIABLE results_var)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_required_process_repeat.cmake

@@ -0,0 +1,71 @@
+function(vcpkg_execute_required_process_repeat)
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "ALLOW_IN_DOWNLOAD_MODE"
+        "COUNT;WORKING_DIRECTORY;LOGNAME"
+        "COMMAND"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    foreach(required_arg IN ITEMS COUNT WORKING_DIRECTORY LOGNAME COMMAND)
+        if(NOT DEFINED arg_${required_arg})
+            message(FATAL_ERROR "${required_arg} must be specified.")
+        endif()
+    endforeach()
+
+    # also checks for COUNT being an integer
+    if(NOT arg_COUNT GREATER_EQUAL "1")
+        message(FATAL_ERROR "COUNT (${arg_COUNT}) must be greater than or equal to 1.")
+    endif()
+
+    if (DEFINED VCPKG_DOWNLOAD_MODE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
+        message(FATAL_ERROR
+[[
+This command cannot be executed in Download Mode.
+Halting portfile execution.
+]])
+    endif()
+
+    if(X_PORT_PROFILE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
+        vcpkg_list(PREPEND arg_COMMAND "${CMAKE_COMMAND}" "-E" "time")
+    endif()
+
+    set(all_logs "")
+    foreach(loop_count RANGE 1 ${arg_COUNT})
+        set(out_log "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out-${loop_count}.log")
+        set(err_log "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out-${loop_count}.log")
+        list(APPEND all_logs "${out_log}" "${err_log}")
+
+        vcpkg_execute_in_download_mode(
+            COMMAND ${arg_COMMAND}
+            OUTPUT_FILE "${out_log}"
+            ERROR_FILE "${err_log}"
+            RESULT_VARIABLE error_code
+            WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+        )
+        if(error_code EQUAL "0")
+            return()
+        endif()
+    endforeach()
+
+    set(stringified_logs "")
+    foreach(log IN LISTS all_logs)
+        if(NOT EXISTS "${log}")
+            continue()
+        endif()
+        file(SIZE "${log}" log_size)
+        if(NOT log_size EQUAL "0")
+            file(TO_NATIVE_PATH "${log}" native_log)
+            string(APPEND stringified_logs "    ${native_log}\n")
+        endif()
+    endforeach()
+
+    z_vcpkg_prettify_command_line(pretty_command ${arg_COMMAND})
+    message(FATAL_ERROR
+        "  Command failed: ${pretty_command}\n"
+        "  Working Directory: ${arg_WORKING_DIRECTORY}\n"
+        "  See logs for more information:\n"
+        "${stringified_logs}"
+    )
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_extract_archive.cmake

@@ -0,0 +1,51 @@
+function(vcpkg_extract_archive)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        ""
+        "ARCHIVE;DESTINATION"
+        ""
+    )
+
+    foreach(arg_name IN ITEMS ARCHIVE DESTINATION)
+        if(NOT DEFINED "arg_${arg_name}")
+            message(FATAL_ERROR "${arg_name} is required.")
+        endif()
+    endforeach()
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unrecognized arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(EXISTS "${arg_DESTINATION}")
+        message(FATAL_ERROR "${arg_DESTINATION} was an extraction target, but it already exists.")
+    endif()
+
+    file(MAKE_DIRECTORY "${arg_DESTINATION}")
+
+    cmake_path(GET arg_ARCHIVE EXTENSION archive_extension)
+    string(TOLOWER "${archive_extension}" archive_extension)
+    if("${archive_extension}" MATCHES [[\.msi$]])
+        cmake_path(NATIVE_PATH arg_ARCHIVE archive_native_path)
+        cmake_path(NATIVE_PATH arg_DESTINATION destination_native_path)
+        cmake_path(GET arg_ARCHIVE PARENT_PATH archive_directory)
+        vcpkg_execute_in_download_mode(
+            COMMAND msiexec
+                /a "${archive_native_path}"
+                /qn "TARGETDIR=${destination_native_path}"
+            WORKING_DIRECTORY "${archive_directory}"
+        )
+    elseif("${archive_extension}" MATCHES [[\.7z\.exe$]])
+        vcpkg_find_acquire_program(7Z)
+        vcpkg_execute_in_download_mode(
+            COMMAND ${7Z} x
+                "${arg_ARCHIVE}"
+                "-o${arg_DESTINATION}"
+                -y -bso0 -bsp0
+            WORKING_DIRECTORY "${arg_DESTINATION}"
+        )
+    else()
+        vcpkg_execute_in_download_mode(
+            COMMAND "${CMAKE_COMMAND}" -E tar xzf "${arg_ARCHIVE}"
+            WORKING_DIRECTORY "${arg_DESTINATION}"
+        )
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_fail_port_install.cmake

@@ -0,0 +1,78 @@
+function(vcpkg_fail_port_install)
+    message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "vcpkg_fail_port_install has been removed and all values should be moved by adding `supports` field to manifest file or directly adding `${PORT}:${FAILED_TRIPLET}=fail` to _scripts/ci.baseline.txt_.\nPlease remove `vcpkg_fail_port_install(...)`.\n")
+
+    set(multi_args "ON_TARGET;ON_ARCH;ON_CRT_LINKAGE;ON_LIBRARY_LINKAGE")
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "ALWAYS" "MESSAGE" "${multi_args}")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "vcpkg_fail_port_install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(arg_ALWAYS)
+        vcpkg_list(SET extra_args)
+        foreach(arg IN LISTS multi_args)
+            if(DEFINED "arg_${arg}")
+                vcpkg_list(APPEND extra_args "${arg}" "${arg_${arg}}")
+            endif()
+        endforeach()
+        if(NOT "${extra_args}" STREQUAL "")
+            message(WARNING "vcpkg_fail_port_install set to fail both unconditionally and conditionally on ${extra_args}. This is likely to be an error.")
+        endif()
+        if(NOT DEFINED arg_MESSAGE)
+            message(FATAL_ERROR "vcpkg_fail_port_install(ALWAYS) was called without a specific MESSAGE.")
+        endif()
+
+        message(FATAL_ERROR "${arg_MESSAGE}")
+    endif()
+
+    if(DEFINED arg_MESSAGE)
+        string(APPEND arg_MESSAGE "\n")
+    else()
+        set(arg_MESSAGE "")
+    endif()
+
+    set(fail_port OFF)
+    # Target fail check
+    if(DEFINED arg_ON_TARGET)
+        foreach(target IN LISTS arg_ON_TARGET)
+            string(TOUPPER "${target}" target_upper)
+            if(VCPKG_TARGET_IS_${target_upper})
+                set(fail_port ON)
+                string(APPEND arg_MESSAGE "Target '${target}' not supported by ${PORT}!\n")
+            endif()
+        endforeach()
+    endif()
+
+    # Architecture fail check
+    if(DEFINED arg_ON_ARCH)
+        foreach(arch IN LISTS arg_ON_ARCH)
+            if(VCPKG_TARGET_ARCHITECTURE STREQUAL arch)
+                set(fail_port ON)
+                string(APPEND arg_MESSAGE "Architecture '${arch}' not supported by ${PORT}!\n")
+            endif()
+        endforeach()
+    endif()
+
+    # CRT linkage fail check
+    if(DEFINED arg_ON_CRT_LINKAGE)
+        foreach(crt_linkage IN LISTS arg_ON_CRT_LINKAGE)
+            if(VCPKG_CRT_LINKAGE STREQUAL crt_linkage)
+                set(fail_port ON)
+                string(APPEND arg_MESSAGE "CRT linkage '${VCPKG_CRT_LINKAGE}' not supported by ${PORT}!\n")
+            endif()
+        endforeach()
+    endif()
+
+    # Library linkage fail check
+    if(DEFINED arg_ON_LIBRARY_LINKAGE)
+        foreach(library_linkage IN LISTS arg_ON_LIBRARY_LINKAGE)
+            if(VCPKG_LIBRARY_LINKAGE STREQUAL library_linkage)
+                set(fail_port ON)
+                string(APPEND arg_MESSAGE "Library linkage '${VCPKG_LIBRARY_LINKAGE}' not supported by ${PORT}!\n")
+            endif()
+        endforeach()
+    endif()
+
+    if(fail_port)
+        message(FATAL_ERROR "${arg_MESSAGE}")
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(7Z).cmake

@@ -0,0 +1,9 @@
+set(program_name 7z)
+if(CMAKE_HOST_WIN32)
+    set(tool_subdirectory "23.01")
+    set(paths_to_search "${DOWNLOADS}/tools/7zip_msi-${tool_subdirectory}-windows/Files/7-Zip") # vcpkg fetch 7zip_msi path
+    list(APPEND paths_to_search "${DOWNLOADS}/tools/7z/${tool_subdirectory}/Files/7-Zip")
+    set(download_urls "https://github.com/ip7z/7zip/releases/download/23.01/7z2301.msi" "https://7-zip.org/a/7z2301.msi")
+    set(download_filename "7z2301.msi")
+    set(download_sha512 002c8ab30be802fa5fa90896d2bdf710bfbd89e39487af25af9d63821986e6d11c42b1c4f4acc79d325719b10193cd31c38f648403ef16f0580609afa8da9596)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(ARIA2).cmake

@@ -0,0 +1,8 @@
+set(program_name aria2c)
+set(program_version 1.35.0)
+if(CMAKE_HOST_WIN32)
+    set(paths_to_search "${DOWNLOADS}/tools/aria2c/aria2-${program_version}-win-32bit-build1")
+    set(download_urls "https://github.com/aria2/aria2/releases/download/release-${program_version}/aria2-${program_version}-win-32bit-build1.zip")
+    set(download_filename "aria2-${program_version}-win-32bit-build1.zip")
+    set(download_sha512 933537cad820b1cecf43a9eeca7e1b241dd7b1c902ee942441a166f2c38845f16046321efbdfa2f83c7e9fc50c7ecc5da6fd00e0c6e2124c07d3b783aa5092a4)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(BAZEL).cmake

@@ -0,0 +1,21 @@
+set(program_name bazel)
+set(program_version 4.2.2)
+set(rename_binary_to "bazel")
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+    set(tool_subdirectory "${program_version}-linux")
+    set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64")
+    set(download_filename "bazel-${tool_subdirectory}-x86_64")
+    set(raw_executable ON)
+    set(download_sha512 f38619e054df78cab38278a5901b2798f2e25b5cec53358d98278002e713d225fd3df96a209b7f22a2357835a279cee8ef1768e10561b3e9fe6361f324563bb9)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+    set(tool_subdirectory "${program_version}-darwin")
+    set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64")
+    set(download_filename "bazel-${tool_subdirectory}-x86_64")
+    set(raw_executable ON)
+    set(download_sha512 a3fd8f9d71b0669d742439200f27ee0a3891c1f248df62c841ebb2b416a47534562f429f8a08793b074e9b74f2ede3d97a7e13ac9921c7ee2dc6a2dca8b7f275)
+else()
+    set(tool_subdirectory "${program_version}-windows")
+    set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64.zip")
+    set(download_filename "bazel-${tool_subdirectory}-x86_64.zip")
+    set(download_sha512 8a8196e242964114316232818cb81bfa19ebfd3a029ebf550a241e33b22a6e9ed636dade06411a8706c05c4e73def0bc8d7f45ff0ec5478bcc5de21b5638204d)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(BISON).cmake

@@ -0,0 +1,20 @@
+if(CMAKE_HOST_WIN32)
+    # This download shall be the same as in vcpkg_find_acquire_program(FLEX).cmake
+    set(program_version 2.5.25)
+    set(download_urls "https://github.com/lexxmark/winflexbison/releases/download/v${program_version}/win_flex_bison-${program_version}.zip")
+    set(download_filename "win_flex_bison-${program_version}.zip")
+    set(download_sha512 2a829eb05003178c89f891dd0a67add360c112e74821ff28e38feb61dac5b66e9d3d5636ff9eef055616aaf282ee8d6be9f14c6ae4577f60bdcec96cec9f364e)
+    set(tool_subdirectory "${program_version}")
+    set(program_name win_bison)
+    set(paths_to_search "${DOWNLOADS}/tools/win_flex/${program_version}")
+    if(NOT EXISTS "${paths_to_search}/data/m4sugar/m4sugar.m4")
+        file(REMOVE_RECURSE "${paths_to_search}")
+    endif()
+else()
+    set(program_name bison)
+    set(apt_package_name bison)
+    set(brew_package_name bison)
+    if (APPLE)
+        set(paths_to_search /opt/homebrew/opt/bison/bin /usr/local/opt/bison/bin)
+    endif()
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(CLANG).cmake

@@ -0,0 +1,31 @@
+set(program_name clang)
+set(tool_subdirectory "clang-15.0.6")
+set(program_version 15.0.6)
+if(CMAKE_HOST_WIN32)
+    set(paths_to_search
+        # Support LLVM in Visual Studio 2019
+        "$ENV{LLVMInstallDir}/x64/bin"
+        "$ENV{LLVMInstallDir}/bin"
+        "$ENV{VCINSTALLDIR}/Tools/Llvm/x64/bin"
+        "$ENV{VCINSTALLDIR}/Tools/Llvm/bin"
+        "${DOWNLOADS}/tools/${tool_subdirectory}-windows/bin"
+        "${DOWNLOADS}/tools/clang/${tool_subdirectory}/bin")
+
+    if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+        set(host_arch "$ENV{PROCESSOR_ARCHITEW6432}")
+    else()
+        set(host_arch "$ENV{PROCESSOR_ARCHITECTURE}")
+    endif()
+
+    if(host_arch MATCHES "64")
+        set(download_urls "https://github.com/llvm/llvm-project/releases/download/llvmorg-${program_version}/LLVM-${program_version}-win64.exe")
+        set(download_filename "LLVM-${program_version}-win64.7z.exe")
+        set(download_sha512 2dd6f3eea106f2b905e6658ea5ea12856d17285adbfba055edc2d6b6389c4c2f7aa001df5cb0d8fb84fa7fa47d5035a7fddf276523b472dd55f150ae25938768)
+    else()
+        set(download_urls "https://github.com/llvm/llvm-project/releases/download/llvmorg-${program_version}/LLVM-${program_version}-win32.exe")
+        set(download_filename "LLVM-${program_version}-win32.7z.exe")
+        set(download_sha512 90225D650EADB0E590A9912B479B46A575D41A19EB5F2DA03C4DC8B032DC0790222F0E3706DFE2A35C0E7747941972AC26CB47D3EB13730DB76168931F37E5F1)
+    endif()
+endif()
+set(brew_package_name "llvm")
+set(apt_package_name "clang")

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(DARK).cmake

@@ -0,0 +1,8 @@
+set(program_name dark)
+if(CMAKE_HOST_WIN32)
+    set(tool_subdirectory "wix311-binaries")
+    set(paths_to_search "${DOWNLOADS}/tools/dark/${tool_subdirectory}")
+    set(download_urls "https://github.com/wixtoolset/wix3/releases/download/wix311rtm/wix311-binaries.zip")
+    set(download_filename "wix311-binaries.zip")
+    set(download_sha512 74f0fa29b5991ca655e34a9d1000d47d4272e071113fada86727ee943d913177ae96dc3d435eaf494d2158f37560cd4c2c5274176946ebdb17bf2354ced1c516)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(FLEX).cmake

@@ -0,0 +1,17 @@
+if(CMAKE_HOST_WIN32)
+    # This download shall be the same as in vcpkg_find_acquire_program(BISON).cmake
+    set(program_version 2.5.25)
+    set(download_urls "https://github.com/lexxmark/winflexbison/releases/download/v${program_version}/win_flex_bison-${program_version}.zip")
+    set(download_filename "win_flex_bison-${program_version}.zip")
+    set(download_sha512 2a829eb05003178c89f891dd0a67add360c112e74821ff28e38feb61dac5b66e9d3d5636ff9eef055616aaf282ee8d6be9f14c6ae4577f60bdcec96cec9f364e)
+    set(tool_subdirectory "${program_version}")
+    set(program_name win_flex)
+    set(paths_to_search "${DOWNLOADS}/tools/win_flex/${program_version}")
+    if(NOT EXISTS "${paths_to_search}/data/m4sugar/m4sugar.m4")
+        file(REMOVE_RECURSE "${paths_to_search}")
+    endif()
+else()
+    set(program_name flex)
+    set(apt_package_name flex)
+    set(brew_package_name flex)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GASPREPROCESSOR).cmake

@@ -0,0 +1,11 @@
+set(raw_executable true)
+set(program_name gas-preprocessor)
+set(interpreter PERL)
+set(search_names "gas-preprocessor.pl")
+set(paths_to_search "${DOWNLOADS}/tools/gas-preprocessor/${tool_subdirectory}")
+set(rename_binary_to "gas-preprocessor.pl")
+set(commit_id 9309c67acb535ca6248f092e96131d8eb07eefc1)
+set(download_urls "https://raw.githubusercontent.com/FFmpeg/gas-preprocessor/${commit_id}/gas-preprocessor.pl")
+string(SUBSTRING ${commit_id} 0 8 tool_subdirectory)
+set(download_filename "gas-preprocessor-${tool_subdirectory}.pl")
+set(download_sha512 b4749cf8aa758e3f28d4b21803422a5c2588f5fc48cfd317564606b374f8d739c636067cf7a4956d7365d63b055bc6e7626c304857e6c9013d6b4a0db9d8ad4f)

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GN).cmake

@@ -0,0 +1,45 @@
+set(program_name gn)
+set(rename_binary_to "gn")
+if(EXISTS "${CURRENT_HOST_INSTALLED_DIR}/share/gn/version.txt")
+    file(READ "${CURRENT_HOST_INSTALLED_DIR}/share/gn/version.txt" program_version)
+    set(paths_to_search "${CURRENT_HOST_INSTALLED_DIR}/tools/gn")
+else() # Old behavior
+    message("Consider adding vcpkg-tool-gn as a host dependency of this port or create an issue at https://github.com/microsoft/vcpkg/issues")
+    set(cipd_download_gn "https://chrome-infra-packages.appspot.com/dl/gn/gn")
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+        EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE HOST_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(HOST_ARCH STREQUAL "aarch64")
+            set(program_version "GkfFAfAUyE-qfeWkdUMaeM1Ov64Fk3SjSj9pwKqZX7gC")
+            set(gn_platform "linux-arm64")
+            set(download_sha512 "E88201309A12C00CE60137261B8E1A759780C81D1925B819583B16D2095A16A7D32EFB2AF36C1E1D6EAA142BF6A6A811847D3140E4E94967EE28F4ADF6373E4B")
+        else()
+            set(program_version "Fv1ENXodhXmEXy_xpZr2gQkVJh57w_IsbsrEJOU0_EoC")
+            set(gn_platform "linux-amd64")
+            set(download_sha512 "A7A5CD5633C5547EC1B1A95958486DDAAC91F1A65881EDC0AD8F74DF44E82F08BA74358E9A72DFCDDE6F534A6B9C9A430D3E16ACE2E4346C4D2E9113F7654B3F")
+        endif()
+    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+        EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE HOST_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(HOST_ARCH STREQUAL "arm64")
+            set(program_version "qMPtGq7xZlpb-lHjP-SK27ftT4X71WIvguuyx6X14DEC")
+            set(gn_platform "mac-arm64")
+            set(download_sha512 "D096FB958D017807427911089AB5A7655AED117F6851C0491AC8063CEDB544423122EF64DF4264ECA86C20A2BDE9E64D7B72DA7ED8C95C2BA79A68B8247D36B8")
+        else()
+            set(program_version "0x2juPLNfP9603GIyZrUfflxK6LiMcppLAoxEpYuIYoC")
+            set(gn_platform "mac-amd64")
+            set(download_sha512 "2696ECE7B2C8008CABDDF10024017E2ECF875F8679424E77052252BDDC83A2096DF3C61D89CD25120EF27E0458C8914BEEED9D418593BDBC4F6ED33A8D4C3DC5")
+        endif()
+    else()
+        if("$ENV{PROCESSOR_ARCHITECTURE}" STREQUAL "ARM64")
+            set(program_version "q5ExVHmXyD34Q_Tzb-aRxsPipO-e37-csVRhVM7IJh0C")
+            set(gn_platform "windows-amd64")
+            set(download_sha512 "FA764AA44EB6F48ED50E855B4DC1DD1ABE35E45FD4AAC7F059A35293A14894C1B591215E34FB0CE9362E646EA9463BA3B489EFB7EBBAA2693D14238B50E4E686")
+        else() # AMD64
+            set(program_version "q5ExVHmXyD34Q_Tzb-aRxsPipO-e37-csVRhVM7IJh0C")
+            set(gn_platform "windows-amd64")
+            set(download_sha512 "FA764AA44EB6F48ED50E855B4DC1DD1ABE35E45FD4AAC7F059A35293A14894C1B591215E34FB0CE9362E646EA9463BA3B489EFB7EBBAA2693D14238B50E4E686")
+        endif()
+    endif()
+endif()
+set(tool_subdirectory "${program_version}")
+set(download_urls "${cipd_download_gn}/${gn_platform}/+/${program_version}")
+set(download_filename "gn-${gn_platform}.zip")

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GO).cmake

@@ -0,0 +1,10 @@
+set(program_name go)
+set(brew_package_name "go")
+set(apt_package_name "golang-go")
+if(CMAKE_HOST_WIN32)
+    set(tool_subdirectory 1.21.1.windows-386)
+    set(paths_to_search "${DOWNLOADS}/tools/go/${tool_subdirectory}/go/bin")
+    set(download_urls "https://dl.google.com/go/go${tool_subdirectory}.zip")
+    set(download_filename "go${tool_subdirectory}.zip")
+    set(download_sha512 417a4bd95a10f21c2166badd2303e1956d91d0e783e334c99ea0176a323e815729c8c3af3f7ec68f057b757d06bcc75be82584031c4069c89a2db62bbfa902e8)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(NASM).cmake

@@ -0,0 +1,13 @@
+set(program_name nasm)
+set(program_version 2.16.01)
+set(brew_package_name "nasm")
+set(apt_package_name "nasm")
+if(CMAKE_HOST_WIN32)
+    set(download_urls
+        "https://www.nasm.us/pub/nasm/releasebuilds/${program_version}/win64/nasm-${program_version}-win64.zip"
+        "https://gstreamer.freedesktop.org/src/mirror/nasm-${program_version}-win64.zip"
+    )
+    set(download_filename "nasm-${program_version}-win64.zip")
+    set(download_sha512 ce4d02f530dc3376b4513f219bbcec128ee5bebd8a5c332599b48d8071f803d1538d7258fec7c2e9b4d725b8d7314cea2696289d0493017eb13bfe70e5cb5062)
+    set(paths_to_search "${DOWNLOADS}/tools/nasm/nasm-${program_version}")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PERL).cmake

@@ -0,0 +1,13 @@
+set(program_name perl)
+set(program_version 5.38.0.1)
+set(brew_package_name "perl")
+set(apt_package_name "perl")
+if(CMAKE_HOST_WIN32)
+    set(download_urls
+        "https://github.com/StrawberryPerl/Perl-Dist-Strawberry/releases/download/SP_5380_5361/strawberry-perl-5.38.0.1-64bit-portable.zip"
+    )
+    set(download_filename "strawberry-perl-5.38.0.1-64bit-portable.zip")
+    set(download_sha512 9b604f19e245a809bd18857bd91ebaec81ca031394ec69a3369df64d3590d2c9d557326d8aa10f91e78b1f1d56689aa57a8ec3a8cad4d2e542c96eb714a3831d)
+    set(tool_subdirectory ${program_version})
+    set(paths_to_search ${DOWNLOADS}/tools/perl/${tool_subdirectory}/perl/bin)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PYTHON2).cmake

@@ -0,0 +1,27 @@
+if(CMAKE_HOST_WIN32)
+    set(program_name python)
+    set(program_version 2.7.18)
+    if(EXISTS "${CURRENT_HOST_INSTALLED_DIR}/share/vcpkg-tool-python2/details.cmake")
+        include("${CURRENT_HOST_INSTALLED_DIR}/share/vcpkg-tool-python2/details.cmake")
+    else() # Old behavior
+        if (VCPKG_TARGET_ARCHITECTURE STREQUAL x86)
+            set(tool_subdirectory "python-${program_version}-x86")
+            set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}.msi")
+            set(download_filename "python-${program_version}.msi")
+            set(download_sha512 2c112733c777ddbf189b0a54047a9d5851ebce0564cc38b9687d79ce6c7a09006109dbad8627fb1a60c3ad55e261db850d9dfa454af0533b460b2afc316fe115)
+        else()
+            set(tool_subdirectory "python-${program_version}-x64")
+            set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}.amd64.msi")
+            set(download_filename "python-${program_version}.amd64.msi")
+            set(download_sha512 6a81a413b80fd39893e7444fd47efa455d240cbb77a456c9d12f7cf64962b38c08cfa244cd9c50a65947c40f936c6c8c5782f7236d7b92445ab3dd01e82af23e)
+        endif()
+        set(paths_to_search "${DOWNLOADS}/tools/python/${tool_subdirectory}")
+    endif()
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+    # macOS includes Python 2.7 built-in as `python`
+    set(program_name python)
+    set(brew_package_name "python2")
+else()
+    set(program_name python2)
+    set(apt_package_name "python")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(PYTHON3).cmake

@@ -0,0 +1,32 @@
+if(CMAKE_HOST_WIN32)
+    set(program_name python)
+    set(program_version 3.11.8)
+    if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+        set(build_arch $ENV{PROCESSOR_ARCHITEW6432})
+    else()
+        set(build_arch $ENV{PROCESSOR_ARCHITECTURE})
+    endif()
+    if(build_arch MATCHES "^(ARM|arm)64$")
+        set(tool_subdirectory "python-${program_version}-arm64")
+        set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}-embed-arm64.zip")
+        set(download_filename "python-${program_version}-embed-arm64.zip")
+        set(download_sha512 42b820e34c4a77fe928e0af395292d804dcbf7e1132cf353ce6ce23435a687ec580f03ccbf3cd94d98c9dc5ac951f8ca64dbd65cded7ef1d675a39d63f8ace8d)
+    elseif(build_arch MATCHES "(amd|AMD)64")
+        set(tool_subdirectory "python-${program_version}-x64")
+        set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}-embed-amd64.zip")
+        set(download_filename "python-${program_version}-embed-amd64.zip")
+        set(download_sha512 da5f01e94d3505eebdfd4d2e70d9cf494925199024479cc29ef144567906b2e8ad55a855b199a755318f5fb9a260f21b987a5fc85f31acf631af4b677921251d)
+    else()
+        set(tool_subdirectory "python-${program_version}-x86")
+        set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}-embed-win32.zip")
+        set(download_filename "python-${program_version}-embed-win32.zip")
+        set(download_sha512 c88ef02f0860000dbc59361cfe051e3e8dc7d208ed39bb5bc20a3e8b8711b578926e281a11941787ea61b2ef05b945ab3133322dcb85b916f79ac4ada57f6309)
+    endif()
+
+    set(paths_to_search "${DOWNLOADS}/tools/python/${tool_subdirectory}")
+    vcpkg_list(SET post_install_command "${CMAKE_COMMAND}" -E rm python311._pth)
+else()
+    set(program_name python3)
+    set(brew_package_name "python")
+    set(apt_package_name "python3")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(RUBY).cmake

@@ -0,0 +1,8 @@
+set(program_name "ruby")
+set(program_version 2.7.4-1)
+if(CMAKE_HOST_WIN32)
+    set(download_urls "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-${program_version}/rubyinstaller-${program_version}-x86.7z")
+    set(download_filename "rubyinstaller-${program_version}-x86.7z")
+    set(download_sha512 4bf459c987b407bdda328c52d95060bf6ad48fc3e5ed5f64d4b205c5b4153c7a00cb6f9da6c0bcd5f2e001e9dc3dda0b72269ec4afdeffd658b93c085cd1d859)
+    set(paths_to_search "${DOWNLOADS}/tools/ruby/rubyinstaller-${program_version}-x86/bin")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(SCONS).cmake

@@ -0,0 +1,10 @@
+set(program_name scons)
+set(program_version 4.1.0)
+set(interpreter PYTHON2)
+set(search_names "scons.py")
+if(CMAKE_HOST_WIN32)
+    set(download_urls "https://sourceforge.net/projects/scons/files/scons-local-${program_version}.zip/download")
+    set(download_filename "scons-local-${program_version}.zip")
+    set(download_sha512 b173176ce8aca25039c64fcc68ec1b9ad31e03a926fd545e7631b3f9b374d914adffc593f505e3e7e2867b0ffe85e8deb0b39afe314edf05d02974ce5db1badb)
+    set(tool_subdirectory "${program_version}")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(SWIG).cmake

@@ -0,0 +1,16 @@
+set(program_version 4.0.2)
+set(program_name swig)
+if(CMAKE_HOST_WIN32)
+    set(download_filename "swigwin-${program_version}.zip")
+    set(download_sha512 "b8f105f9b9db6acc1f6e3741990915b533cd1bc206eb9645fd6836457fd30789b7229d2e3219d8e35f2390605ade0fbca493ae162ec3b4bc4e428b57155db03d")
+    vcpkg_list(SET sourceforge_args
+        REPO swig/swigwin
+        REF "swigwin-${program_version}"
+    )
+
+    set(tool_subdirectory "b8f105f9b9-f0518bc3b7")
+    set(paths_to_search "${DOWNLOADS}/tools/swig/b8f105f9b9-f0518bc3b7/swigwin-${program_version}")
+else()
+    set(apt_package_name "swig")
+    set(brew_package_name "swig")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_bitbucket.cmake

@@ -0,0 +1,93 @@
+function(vcpkg_from_bitbucket)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        ""
+        "OUT_SOURCE_PATH;REPO;REF;SHA512;HEAD_REF"
+        "PATCHES")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_from_bitbucket was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(DEFINED arg_REF AND NOT DEFINED arg_SHA512)
+        message(FATAL_ERROR "SHA512 must be specified if REF is specified.")
+    endif()
+    if(NOT DEFINED arg_REF AND DEFINED arg_SHA512)
+        message(FATAL_ERROR "REF must be specified if SHA512 is specified.")
+    endif()
+
+    if(NOT DEFINED arg_OUT_SOURCE_PATH)
+        message(FATAL_ERROR "OUT_SOURCE_PATH must be specified.")
+    endif()
+    if(NOT DEFINED arg_REPO)
+        message(FATAL_ERROR "The Bitbucket repository must be specified.")
+    endif()
+
+    if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
+        message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified.")
+    endif()
+
+    if(NOT arg_REPO MATCHES "^([^/]*)/([^/]*)$")
+        message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name:
+    must be an organization name followed by a repository name separated by a single slash.")
+    endif()
+    set(org_name "${CMAKE_MATCH_1}")
+    set(repo_name "${CMAKE_MATCH_2}")
+
+    set(redownload_param "")
+    set(working_directory_param "")
+    set(sha512_param "SHA512" "${arg_SHA512}")
+    set(ref_to_use "${arg_REF}")
+    if(VCPKG_USE_HEAD_VERSION)
+        if(DEFINED arg_HEAD_REF)
+            set(redownload_param "ALWAYS_REDOWNLOAD")
+            set(sha512_param "SKIP_SHA512")
+            set(working_directory_param "WORKING_DIRECTORY" "${CURRENT_BUILDTREES_DIR}/src/head")
+            set(ref_to_use "${arg_HEAD_REF}")
+        else()
+            message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
+        endif()
+    elseif(NOT DEFINED arg_REF)
+        message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
+    endif()
+
+    # avoid using either - or _, to allow both `foo/bar` and `foo-bar` to coexist
+    # we assume that no one will name a ref "foo_-bar"
+    string(REPLACE "/" "_-" sanitized_ref "${ref_to_use}")
+    set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}.tar.gz")
+
+    # exports VCPKG_HEAD_VERSION to the caller. This will get picked up by ports.cmake after the build.
+    if(VCPKG_USE_HEAD_VERSION)
+        vcpkg_download_distfile(archive_version
+            URLS "https://api.bitbucket.com/2.0/repositories/${org_name}/${repo_name}/refs/branches/${arg_HEAD_REF}"
+            FILENAME "${downloaded_file_name}.version"
+            SKIP_SHA512
+            ALWAYS_REDOWNLOAD
+        )
+        # Parse the github refs response with regex.
+        # TODO: add json-pointer support to vcpkg
+        file(READ "${archive_version}" version_contents)
+        if(NOT version_contents MATCHES [["hash": "([a-f0-9]+)"]])
+            message(FATAL_ERROR "Failed to parse API response from '${version_url}':
+
+${version_contents}
+")
+        endif()
+        set(VCPKG_HEAD_VERSION "${CMAKE_MATCH_1}" PARENT_SCOPE)
+    endif()
+
+    # download the file information from bitbucket.
+    vcpkg_download_distfile(archive
+        URLS "https://bitbucket.com/${org_name}/${repo_name}/get/${ref_to_use}.tar.gz"
+        FILENAME "${downloaded_file_name}"
+        ${sha512_param}
+        ${redownload_param}
+    )
+    vcpkg_extract_source_archive_ex(
+        OUT_SOURCE_PATH SOURCE_PATH
+        ARCHIVE "${archive}"
+        REF "${sanitized_ref}"
+        PATCHES ${arg_PATCHES}
+        ${working_directory_param}
+    )
+    set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_git.cmake

@@ -0,0 +1,189 @@
+function(vcpkg_from_git)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        ""
+        "OUT_SOURCE_PATH;URL;REF;FETCH_REF;HEAD_REF;TAG;LFS"
+        "PATCHES"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_from_git was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(DEFINED arg_TAG)
+        message(WARNING "The TAG argument to vcpkg_from_git has been deprecated and has no effect.")
+    endif()
+
+    if(NOT DEFINED arg_OUT_SOURCE_PATH)
+        message(FATAL_ERROR "OUT_SOURCE_PATH must be specified")
+    endif()
+    if(NOT DEFINED arg_URL)
+        message(FATAL_ERROR "URL must be specified")
+    endif()
+    if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
+        message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified")
+    endif()
+    if(DEFINED arg_FETCH_REF AND NOT DEFINED arg_REF)
+        message(FATAL_ERROR "REF must be specified if FETCH_REF is specified")
+    endif()
+    if(NOT DEFINED arg_LFS AND "LFS" IN_LIST arg_KEYWORDS_MISSING_VALUES)
+        set(arg_LFS "${arg_URL}")
+    endif()
+
+    vcpkg_list(SET git_fetch_shallow_param --depth 1)
+    vcpkg_list(SET extract_working_directory_param)
+    vcpkg_list(SET skip_patch_check_param)
+    set(git_working_directory "${DOWNLOADS}/git-tmp")
+    set(do_download OFF)
+
+    if(VCPKG_USE_HEAD_VERSION AND DEFINED arg_HEAD_REF)
+        vcpkg_list(SET working_directory_param "WORKING_DIRECTORY" "${CURRENT_BUILDTREES_DIR}/src/head")
+        vcpkg_list(SET git_fetch_shallow_param --depth 1)
+        vcpkg_list(SET skip_patch_check_param SKIP_PATCH_CHECK)
+        set(ref_to_fetch "${arg_HEAD_REF}")
+        set(git_working_directory "${CURRENT_BUILDTREES_DIR}/src/git-tmp")
+        string(REPLACE "/" "_-" sanitized_ref "${arg_HEAD_REF}")
+
+        if(NOT _VCPKG_NO_DOWNLOADS)
+            set(do_download ON)
+        endif()
+    else()
+        if(NOT DEFINED arg_REF)
+            message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
+        endif()
+        if(VCPKG_USE_HEAD_VERSION)
+            message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
+        endif()
+
+        if(DEFINED arg_FETCH_REF)
+            set(ref_to_fetch "${arg_FETCH_REF}")
+            vcpkg_list(SET git_fetch_shallow_param)
+        else()
+            set(ref_to_fetch "${arg_REF}")
+        endif()
+        string(REPLACE "/" "_-" sanitized_ref "${arg_REF}")
+    endif()
+
+    set(temp_archive "${DOWNLOADS}/temp/${PORT}-${sanitized_ref}.tar.gz")
+    set(archive "${DOWNLOADS}/${PORT}-${sanitized_ref}.tar.gz")
+
+    if(NOT EXISTS "${archive}")
+        if(_VCPKG_NO_DOWNLOADS)
+            message(FATAL_ERROR "Downloads are disabled, but '${archive}' does not exist.")
+        endif()
+        set(do_download ON)
+    endif()
+
+    if(do_download)
+        message(STATUS "Fetching ${arg_URL} ${ref_to_fetch}...")
+        find_program(GIT NAMES git git.cmd)
+        file(MAKE_DIRECTORY "${DOWNLOADS}")
+        # Note: git init is safe to run multiple times
+        vcpkg_execute_required_process(
+            ALLOW_IN_DOWNLOAD_MODE
+            COMMAND "${GIT}" init "${git_working_directory}"
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}"
+            LOGNAME "git-init-${TARGET_TRIPLET}"
+        )
+        vcpkg_execute_required_process(
+            ALLOW_IN_DOWNLOAD_MODE
+            COMMAND "${GIT}" fetch "${arg_URL}" "${ref_to_fetch}" ${git_fetch_shallow_param} -n
+            WORKING_DIRECTORY "${git_working_directory}"
+            LOGNAME "git-fetch-${TARGET_TRIPLET}"
+        )
+        if(arg_LFS)
+            # Running "git lfs" searches for "git-lfs[.exe]" on the path
+            vcpkg_execute_in_download_mode(
+                COMMAND "${GIT}" lfs --version
+                OUTPUT_VARIABLE lfs_version_output
+                ERROR_VARIABLE lfs_version_error
+                RESULT_VARIABLE lfs_version_result
+                WORKING_DIRECTORY "${git_working_directory}"
+            )
+            if(lfs_version_result)
+                message(FATAL_ERROR "Git LFS is required for ${PORT}")
+            endif()
+
+            vcpkg_execute_required_process(
+                ALLOW_IN_DOWNLOAD_MODE
+                COMMAND "${GIT}" lfs install --local --force
+                WORKING_DIRECTORY "${git_working_directory}"
+                LOGNAME "git-lfs-install-${TARGET_TRIPLET}"
+            )
+            vcpkg_execute_required_process(
+                ALLOW_IN_DOWNLOAD_MODE
+                COMMAND "${GIT}" lfs fetch "${arg_LFS}" "${ref_to_fetch}"
+                WORKING_DIRECTORY "${git_working_directory}"
+                LOGNAME "git-lfs-fetch-${TARGET_TRIPLET}"
+            )
+        endif()
+
+        if(VCPKG_USE_HEAD_VERSION)
+            set(expected_rev_parse FETCH_HEAD)
+        else()
+            set(expected_rev_parse "${arg_REF}")
+        endif()
+
+        vcpkg_execute_in_download_mode(
+            COMMAND "${GIT}" rev-parse "${expected_rev_parse}"
+            OUTPUT_VARIABLE rev_parse_ref
+            ERROR_VARIABLE rev_parse_ref
+            RESULT_VARIABLE error_code
+            WORKING_DIRECTORY "${git_working_directory}"
+        )
+
+        if(error_code)
+            if(VCPKG_USE_HEAD_VERSION)
+                message(FATAL_ERROR "Unable to determine the commit SHA of the HEAD version to use after \
+fetching ${ref_to_fetch} from the git repository. (git rev-parse ${expected_rev_parse} failed)")
+            elseif(DEFINED arg_FETCH_REF)
+                message(FATAL_ERROR "After fetching ${ref_to_fetch}, the target ref ${expected_rev_parse} appears \
+inaccessible. A common cause of this failure is setting REF to a named branch or tag rather than a commit SHA. REF \
+must be a commit SHA. (git rev-parse ${expected_rev_parse} failed)")
+            else()
+                message(FATAL_ERROR "After fetching ${ref_to_fetch}, the target ref ${expected_rev_parse} appears \
+inaccessible. A common cause of this failure is setting REF to a named branch or tag rather than a commit SHA. REF \
+must be a commit SHA. If the git server does not advertise commit SHAs \
+(uploadpack.allowReachableSHA1InWant is false), you can set FETCH_REF to a named branch in which the desired commit \
+SHA is in the history. For example, you may be able to fix this error by changing \"REF ${arg_REF}\" to \
+\"REF a-commit-sha FETCH_REF ${arg_REF}\". (git rev-parse ${expected_rev_parse} failed)")
+            endif()
+        endif()
+
+        string(STRIP "${rev_parse_ref}" rev_parse_ref)
+        if(VCPKG_USE_HEAD_VERSION)
+            set(VCPKG_HEAD_VERSION "${rev_parse_ref}" PARENT_SCOPE)
+        elseif(NOT "${rev_parse_ref}" STREQUAL "${arg_REF}")
+                message(FATAL_ERROR "After fetching ${ref_to_fetch}, the requested REF (${arg_REF}) does not match \
+its commit SHA returned by git rev-parse (${rev_parse_ref}). This is usually caused by trying to set REF to a named \
+branch or tag rather than a commit SHA. REF must be a commit SHA. If the  git server does not advertise commit SHAs \
+(uploadpack.allowReachableSHA1InWant is false), you can set FETCH_REF to a named branch in which the desired commit \
+SHA is in the history. For example, you may be able to fix this error by changing \"REF ${arg_REF}\" to \
+\"REF a-commit-sha FETCH_REF ${arg_REF}\".
+    [Expected : ( ${arg_REF} )])
+    [  Actual : ( ${rev_parse_ref} )]"
+            )
+        endif()
+
+        file(MAKE_DIRECTORY "${DOWNLOADS}/temp")
+        vcpkg_execute_required_process(
+            ALLOW_IN_DOWNLOAD_MODE
+            COMMAND "${GIT}" -c core.autocrlf=false archive "${rev_parse_ref}" -o "${temp_archive}"
+            WORKING_DIRECTORY "${git_working_directory}"
+            LOGNAME git-archive
+        )
+        file(RENAME "${temp_archive}" "${archive}")
+    else()
+        message(STATUS "Using cached ${archive}")
+    endif()
+
+    vcpkg_extract_source_archive_ex(
+        OUT_SOURCE_PATH SOURCE_PATH
+        ARCHIVE "${archive}"
+        REF "${sanitized_ref}"
+        PATCHES ${arg_PATCHES}
+        NO_REMOVE_ONE_LEVEL
+        ${extract_working_directory_param}
+        ${skip_patch_check_param}
+    )
+
+    set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_from_github.cmake

@@ -0,0 +1,122 @@
+function(vcpkg_from_github)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg"
+        ""
+        "OUT_SOURCE_PATH;REPO;REF;SHA512;HEAD_REF;GITHUB_HOST;AUTHORIZATION_TOKEN;FILE_DISAMBIGUATOR"
+        "PATCHES")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_from_github was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(DEFINED arg_REF AND NOT DEFINED arg_SHA512)
+        message(FATAL_ERROR "SHA512 must be specified if REF is specified.")
+    endif()
+    if(NOT DEFINED arg_REF AND DEFINED arg_SHA512)
+        message(FATAL_ERROR "REF must be specified if SHA512 is specified.")
+    endif()
+
+    if(NOT DEFINED arg_OUT_SOURCE_PATH)
+        message(FATAL_ERROR "OUT_SOURCE_PATH must be specified.")
+    endif()
+    if(NOT DEFINED arg_REPO)
+        message(FATAL_ERROR "The GitHub repository must be specified.")
+    endif()
+
+    if(NOT DEFINED arg_GITHUB_HOST)
+        set(github_host "https://github.com")
+        set(github_api_url "https://api.github.com")
+    else()
+        set(github_host "${arg_GITHUB_HOST}")
+        set(github_api_url "${arg_GITHUB_HOST}/api/v3")
+    endif()
+
+    set(headers_param "")
+    if(DEFINED arg_AUTHORIZATION_TOKEN)
+        set(headers_param "HEADERS" "Authorization: token ${arg_AUTHORIZATION_TOKEN}")
+    endif()
+
+
+    if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
+        message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified.")
+    endif()
+
+    if(NOT arg_REPO MATCHES "^([^/]*)/([^/]*)$")
+        message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name:
+    must be an organization name followed by a repository name separated by a single slash.")
+    endif()
+    set(org_name "${CMAKE_MATCH_1}")
+    set(repo_name "${CMAKE_MATCH_2}")
+
+    if(VCPKG_USE_HEAD_VERSION AND NOT DEFINED arg_HEAD_REF)
+        message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
+        set(VCPKG_USE_HEAD_VERSION OFF)
+    elseif(NOT VCPKG_USE_HEAD_VERSION AND NOT DEFINED arg_REF)
+        message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
+    endif()
+
+    # exports VCPKG_HEAD_VERSION to the caller. This will get picked up by ports.cmake after the build.
+    if(VCPKG_USE_HEAD_VERSION)
+        string(REPLACE "/" "_-" sanitized_head_ref "${arg_HEAD_REF}")
+        vcpkg_download_distfile(archive_version
+            URLS "${github_api_url}/repos/${org_name}/${repo_name}/git/refs/heads/${arg_HEAD_REF}"
+            FILENAME "${org_name}-${repo_name}-${sanitized_head_ref}.version"
+            ${headers_param}
+            SKIP_SHA512
+            ALWAYS_REDOWNLOAD
+        )
+        # Parse the github refs response with regex.
+        file(READ "${archive_version}" version_contents)
+        string(JSON head_version
+            ERROR_VARIABLE head_version_err
+            GET "${version_contents}"
+            "object"
+            "sha"
+        )
+        if(NOT "${head_version_err}" STREQUAL "NOTFOUND")
+            message(FATAL_ERROR "Failed to parse API response from '${version_url}':
+${version_contents}
+
+Error was: ${head_version_err}
+")
+        endif()
+
+        set(VCPKG_HEAD_VERSION "${head_version}" PARENT_SCOPE)
+        set(ref_to_use "${head_version}")
+
+        vcpkg_list(SET redownload_param ALWAYS_REDOWNLOAD)
+        vcpkg_list(SET sha512_param SKIP_SHA512)
+        vcpkg_list(SET working_directory_param WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/src/head")
+        vcpkg_list(SET skip_patch_check_param SKIP_PATCH_CHECK)
+    else()
+        set(ref_to_use "${arg_REF}")
+
+        vcpkg_list(SET redownload_param)
+        vcpkg_list(SET working_directory_param)
+        vcpkg_list(SET skip_patch_check_param)
+        vcpkg_list(SET sha512_param SHA512 "${arg_SHA512}")
+    endif()
+
+    string(REPLACE "/" "_-" sanitized_ref "${ref_to_use}")
+    if(DEFINED arg_FILE_DISAMBIGUATOR AND NOT VCPKG_USE_HEAD_REF)
+        set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}-${arg_FILE_DISAMBIGUATOR}.tar.gz")
+    else()
+        set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}.tar.gz")
+    endif()
+    # Try to download the file information from github
+    vcpkg_download_distfile(archive
+        URLS "${github_host}/${org_name}/${repo_name}/archive/${ref_to_use}.tar.gz"
+        FILENAME "${downloaded_file_name}"
+        ${headers_param}
+        ${sha512_param}
+        ${redownload_param}
+    )
+    vcpkg_extract_source_archive_ex(
+        OUT_SOURCE_PATH SOURCE_PATH
+        ARCHIVE "${archive}"
+        REF "${sanitized_ref}"
+        PATCHES ${arg_PATCHES}
+        ${working_directory_param}
+        ${skip_patch_check_param}
+    )
+    set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_cmake.cmake

@@ -0,0 +1,23 @@
+function(vcpkg_install_cmake)
+    if(Z_VCPKG_CMAKE_INSTALL_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_install_cmake in the same port is unsupported.")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "DISABLE_PARALLEL;ADD_BIN_TO_PATH" "" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "vcpkg_cmake_install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    vcpkg_list(SET params)
+    foreach(arg IN ITEMS DISABLE_PARALLEL ADD_BIN_TO_PATH)
+        if(arg_${arg})
+            vcpkg_list(APPEND params "${arg}")
+        endif()
+    endforeach()
+
+    vcpkg_build_cmake(Z_VCPKG_DISABLE_DEPRECATION MESSAGE
+        ${params}
+        LOGFILE_ROOT install
+        TARGET install
+    )
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_gn.cmake

@@ -0,0 +1,118 @@
+function(z_vcpkg_install_gn_get_target_type out_var)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "SOURCE_PATH;BUILD_DIR;TARGET" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Internal error: get_target_type was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    execute_process(
+        COMMAND "${GN}" desc "${arg_BUILD_DIR}" "${arg_TARGET}"
+        WORKING_DIRECTORY "${arg_SOURCE_PATH}"
+        OUTPUT_VARIABLE output
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(output MATCHES [[type: ([A-Za-z0-9_]+)]])
+        set("${out_var}" "${CMAKE_MATCH_1}" PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "invalid result from `gn desc`: ${output}")
+    endif()
+endfunction()
+
+function(z_vcpkg_install_gn_get_desc out_var)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "SOURCE_PATH;BUILD_DIR;TARGET;WHAT_TO_DISPLAY" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Internal error: get_desc was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    execute_process(
+        COMMAND "${GN}" desc "${arg_BUILD_DIR}" "${arg_TARGET}" "${arg_WHAT_TO_DISPLAY}"
+        WORKING_DIRECTORY "${arg_SOURCE_PATH}"
+        OUTPUT_VARIABLE output
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    string(REPLACE ";" "\\;" output "${output}")
+    string(REGEX REPLACE "\n|(\r\n)" ";" output "${output}")
+    set("${out_var}" "${output}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_install_gn_install)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;BUILD_DIR;INSTALL_DIR" "TARGETS")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Internal error: install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    foreach(target IN LISTS arg_TARGETS)
+        # GN targets must start with a //
+        z_vcpkg_install_gn_get_desc(outputs
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            BUILD_DIR "${arg_BUILD_DIR}"
+            TARGET "//${target}"
+            WHAT_TO_DISPLAY outputs
+        )
+        z_vcpkg_install_gn_get_target_type(target_type
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            BUILD_DIR "${arg_BUILD_DIR}"
+            TARGET "//${target}"
+        )
+
+        foreach(output IN LISTS outputs)
+            if(output MATCHES "^//")
+                # relative path (e.g. //out/Release/target.lib)
+                string(REGEX REPLACE "^//" "${arg_SOURCE_PATH}/" output "${output}")
+            elseif(output MATCHES "^/" AND CMAKE_HOST_WIN32)
+                # absolute path (e.g. /C:/path/to/target.lib)
+                string(REGEX REPLACE "^/" "" output "${output}")
+            endif()
+
+            if(NOT EXISTS "${output}")
+                message(WARNING "Output for target `${target}` doesn't exist: ${output}.")
+                continue()
+            endif()
+
+            if(target_type STREQUAL "executable")
+                file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/tools")
+            elseif(output MATCHES "(\\.dll|\\.pdb)$")
+                file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/bin")
+            else()
+                file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/lib")
+            endif()
+        endforeach()
+    endforeach()
+endfunction()
+
+function(vcpkg_install_gn)
+    if(Z_VCPKG_GN_INSTALL_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-gn; using both vcpkg-gn and vcpkg_install_gn in the same port is unsupported.")
+    else()
+        message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "This function 'vcpkg_install_gn' is obsolete. Use 'vcpkg_gn_install' in port 'vcpkg-gn'.")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "SOURCE_PATH" "TARGETS")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_install_gn was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_SOURCE_PATH)
+        message(FATAL_ERROR "SOURCE_PATH must be specified.")
+    endif()
+
+    vcpkg_build_ninja(TARGETS ${arg_TARGETS})
+
+    vcpkg_find_acquire_program(GN)
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        z_vcpkg_install_gn_install(
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            BUILD_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
+            INSTALL_DIR "${CURRENT_PACKAGES_DIR}/debug"
+            TARGETS ${arg_TARGETS}
+        )
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        z_vcpkg_install_gn_install(
+            SOURCE_PATH "${arg_SOURCE_PATH}"
+            BUILD_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
+            INSTALL_DIR "${CURRENT_PACKAGES_DIR}"
+            TARGETS ${arg_TARGETS}
+        )
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_make.cmake

@@ -0,0 +1,7 @@
+function(vcpkg_install_make)
+    vcpkg_build_make(
+        ${ARGN}
+        LOGFILE_ROOT
+        ENABLE_INSTALL
+    )
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_install_qmake.cmake

@@ -0,0 +1,45 @@
+function(vcpkg_install_qmake)
+    z_vcpkg_function_arguments(args)
+
+    vcpkg_build_qmake(${args})
+
+    file(GLOB_RECURSE release_libs
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.lib"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.a"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.so"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.so.*"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.dylib"
+    )
+    file(GLOB_RECURSE release_bins
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.dll"
+    )
+    file(GLOB_RECURSE debug_libs
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.lib"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.a"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.so"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.so.*"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.dylib"
+    )
+    file(GLOB_RECURSE debug_bins
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.dll"
+    )
+    if("${release_libs}" STREQUAL "" AND "${debug_libs}" STREQUAL "")
+        message(FATAL_ERROR "Build did not appear to produce any libraries. If this is intended, use `vcpkg_build_qmake()` directly.")
+    endif()
+    if(NOT "${release_libs}" STREQUAL "")
+        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/lib")
+        file(COPY ${release_libs} DESTINATION "${CURRENT_PACKAGES_DIR}/lib")
+    endif()
+    if(NOT "${debug_libs}" STREQUAL "")
+        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/debug/lib")
+        file(COPY ${debug_libs} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/lib")
+    endif()
+    if(NOT "${release_bins}" STREQUAL "")
+        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/bin")
+        file(COPY ${release_bins} DESTINATION "${CURRENT_PACKAGES_DIR}/bin")
+    endif()
+    if(NOT "${debug_bins}" STREQUAL "")
+        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/debug/bin")
+        file(COPY ${debug_bins} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/bin")
+    endif()
+endfunction()