@cpp.js/package-gdal 1.0.0 → 2.0.0-beta.2

package/dist/prebuilt/Emscripten-x86_64/lib/cmake/gdal/thirdparty/FindDotnet.cmake

@@ -1,496 +0,0 @@
-#.rst
-# from https://github.com/microsoft/GraphEngine/blob/master/cmake/FindDotnet.cmake
-# published under MIT licence https://github.com/microsoft/GraphEngine/blob/master/LICENSE.md
-# edited 2021 Paul Harwood
-#
-# FindDotnet
-# ----------
-#
-# Find DotNet executable, and initialize functions for adding dotnet projects.
-#
-# Results are reported in the following variables::
-#
-#   DOTNET_FOUND          - True if dotnet executable is found
-#   DOTNET_EXE            - Dotnet executable
-#   DOTNET_VERSION        - Dotnet version as reported by dotnet executable
-#   DOTNET_SDKS           - Dotnet SDKs loaded as reported by dotnet executable
-#   NUGET_EXE             - Nuget executable (WIN32 only)
-#   NUGET_CACHE_PATH      - Nuget package cache path
-#
-# The following functions are defined to add dotnet/msbuild projects:
-#
-# ADD_DOTNET -- add a project to be built by dotnet.
-#
-# ```
-# ADD_DOTNET(<project_file> [RELEASE|DEBUG] [X86|X64|ANYCPU]
-#            [CONFIG configuration]
-#            [PLATFORM platform]
-#            [PACKAGE nuget_package_dependencies... ]
-#            [VERSION nuget_package_version]
-#            [DEPENDS depend_nuget_packages... ]
-#            [OUTPUT_PATH output_path]
-#            [CUSTOM_BUILDPROPS <CustomProp>value</CustomProp>....]
-#            [SOURCES additional_csproj_dependencies... ]
-#            [ARGUMENTS additional_build_args...]
-#            [PACK_ARGUMENTS additional_pack_args...])
-# ```
-#
-# RUN_DOTNET -- Run a project with `dotnet run`. The `OUTPUT` argument represents artifacts
-#               produced by running the .NET program, and can be consumed from other build steps.
-#
-# ```
-# RUN_DOTNET(<project_file> [RELEASE|DEBUG] [X86|X64|ANYCPU]
-#            [ARGUMENTS program_args...]
-#            [OUTPUT outputs...]
-#            [CONFIG configuration]
-#            [PLATFORM platform]
-#            [DEPENDS depend_nuget_packages... ]
-#            [OUTPUT_PATH output_path relative to cmake binary output dir]
-#            [CUSTOM_BUILDPROPS <CustomProp>value</CustomProp>....]
-#            [SOURCES additional_file_dependencies... ])
-# ```
-#
-# ADD_MSBUILD -- add a project to be built by msbuild. Windows-only. When building in Unix systems, msbuild targets are skipped.
-#
-# ```
-# ADD_MSBUILD(<project_file> [RELEASE|DEBUG] [X86|X64|ANYCPU]
-#            [CONFIG configuration]
-#            [PLATFORM platform]
-#            [PACKAGE output_nuget_packages... ]
-#            [DEPENDS depend_nuget_packages... ]
-#            [CUSTOM_BUILDPROPS <CustomProp>value</CustomProp>....]
-#            [SOURCES additional_file_dependencies... ]
-#            [ARGUMENTS additional_build_args...]
-#            [PACK_ARGUMENTS additional_pack_args...])
-# ```
-#
-# SMOKETEST_DOTNET -- add a dotnet smoke test project to the build. The project will be run during a build,
-# and if the program fails to build or run, the build fails. Currently only .NET Core App framework is supported.
-# Multiple smoke tests will be run one-by-one to avoid global resource conflicts.
-#
-# SMOKETEST_DOTNET(<project_file> [RELEASE|DEBUG] [X86|X64|ANYCPU]
-#                 [ARGUMENTS program_args...]
-#                 [CONFIG configuration]
-#                 [PLATFORM platform]
-#                 [DEPENDS depend_nuget_packages... ]
-#                 [OUTPUT_PATH output_path relative to cmake binary output dir]
-#                 [CUSTOM_BUILDPROPS <CustomProp>value</CustomProp>....]
-#                 [SOURCES additional_file_dependencies... ])
-#
-# For all the above functions, `RELEASE|DEBUG` overrides `CONFIG`, `X86|X64|ANYCPU` overrides PLATFORM.
-#
-#
-# DOTNET_REGISTER_LOCAL_REPOSITORY -- register a local NuGet package repository.
-#
-# ```
-# DOTNET_REGISTER_LOCAL_REPOSITORY(repo_name repo_path)
-# ```
-#
-# TEST_DOTNET -- add a dotnet test project to ctest. The project will be run with `dotnet test`,
-# and trx test reports will be generated in the build directory. For Windows, all target frameworks
-# are tested against. For other platforms, only .NET Core App is tested against.
-# Test failures will not fail the build.
-# Tests are only run with `ctest -C <config>`, not with `cmake --build ...`
-#
-# ```
-# TEST_DOTNET(<project_file>
-#             [ARGUMENTS additional_dotnet_test_args...]
-#             [OUTPUT_PATH output_path relative to cmake binary output dir])
-# ```
-#
-# GEN_DOTNET_PROPS -- Generates a Directory.Build.props file. The created file is populated with MSBuild properties:
-#  - DOTNET_PACKAGE_VERSION: a version string that can be referenced in the actual project file as $(DOTNET_PACKAGE_VERSION).
-#    The version string value can be set with PACKAGE_VERSION argument, and defaults to '1.0.0'.
-#  - XPLAT_LIB_DIR: points to the cmake build root directory.
-#  - OutputPath: Points to the cmake binary directory (overridden by OUTPUT_PATH, relatively). Therefore, projects built without cmake will consistently output
-#    to the cmake build directory.
-#  - Custom properties can be injected with XML_INJECT argument, which injects an arbitrary string into the project XML file.
-#
-# ```
-# GEN_DOTNET_PROPS(<target_props_file>
-#                  [PACKAGE_VERSION version]
-#                  [XML_INJECT xml_injection])
-# ```
-#
-
-IF(DOTNET_FOUND)
-    RETURN()
-ENDIF()
-
-SET(NUGET_CACHE_PATH "~/.nuget/packages")
-FIND_PROGRAM(DOTNET_EXE dotnet)
-SET(DOTNET_MODULE_DIR ${CMAKE_CURRENT_LIST_DIR})
-
-IF(NOT DOTNET_EXE)
-    SET(DOTNET_FOUND FALSE)
-    IF(Dotnet_FIND_REQUIRED)
-        MESSAGE(SEND_ERROR "Command 'dotnet' is not found.")
-    ENDIF()
-    RETURN()
-ENDIF()
-
-EXECUTE_PROCESS(
-    COMMAND "${DOTNET_EXE}" --version
-    OUTPUT_VARIABLE DOTNET_VERSION
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-
-EXECUTE_PROCESS(
-    COMMAND "${DOTNET_EXE}" --list-sdks
-    OUTPUT_VARIABLE DOTNET_SDK_STRING
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-
-string(REGEX REPLACE "[\r\n]+" ";" DOTNET_SDK_STRING "${DOTNET_SDK_STRING}" )
-
-set(DOTNET_SDKS)
-foreach(ITR ${DOTNET_SDK_STRING} )
-    string(REGEX MATCH "^[0-9]+\.[0-9]+" SDK "${ITR}" )
-    list(APPEND DOTNET_SDKS ${SDK} )
-endforeach()
-list(REMOVE_DUPLICATES DOTNET_SDKS )
-
-IF(WIN32)
-   FIND_PROGRAM(NUGET_EXE nuget PATHS ${CMAKE_BINARY_DIR}/tools)
-   IF(NUGET_EXE)
-       MESSAGE("-- Found nuget: ${NUGET_EXE}")
-   ELSE()
-        SET(NUGET_EXE ${CMAKE_BINARY_DIR}/tools/nuget.exe)
-        MESSAGE("-- Downloading nuget...")
-        FILE(DOWNLOAD https://dist.nuget.org/win-x86-commandline/latest/nuget.exe ${NUGET_EXE})
-        MESSAGE("nuget.exe downloaded and saved to ${NUGET_EXE}")
-   ENDIF()
-ENDIF()
-
-FUNCTION(DOTNET_REGISTER_LOCAL_REPOSITORY repo_name repo_path)
-	MESSAGE("-- Registering NuGet local repository '${repo_name}' at '${repo_path}'.")
-    GET_FILENAME_COMPONENT(repo_path ${repo_path} ABSOLUTE)
-    IF(WIN32)
-        STRING(REPLACE "/" "\\" repo_path ${repo_path})
-        EXECUTE_PROCESS(COMMAND ${NUGET_EXE} sources list OUTPUT_QUIET)
-        EXECUTE_PROCESS(COMMAND ${NUGET_EXE} sources Remove -Name "${repo_name}" OUTPUT_QUIET ERROR_QUIET)
-        EXECUTE_PROCESS(COMMAND ${NUGET_EXE} sources Add -Name "${repo_name}" -Source "${repo_path}")
-    ELSE()
-        GET_FILENAME_COMPONENT(nuget_config ~/.nuget/NuGet/NuGet.Config ABSOLUTE)
-        EXECUTE_PROCESS(COMMAND ${DOTNET_EXE} nuget locals all --list OUTPUT_QUIET)
-        EXECUTE_PROCESS(COMMAND sed -e "/${repo_name}/d" -i'' "${nuget_config}")
-        EXECUTE_PROCESS(COMMAND sed -e "s#</packageSources>#  <add key=\\\"${repo_name}\\\" value=\\\"${repo_path}\\\" />\\n  </packageSources>#g" -i'' "${nuget_config}")
-    ENDIF()
-ENDFUNCTION()
-
-FUNCTION(DOTNET_GET_DEPS _DN_PROJECT arguments)
-    CMAKE_PARSE_ARGUMENTS(
-        # prefix
-        _DN
-        # options (flags)
-        "RELEASE;DEBUG;X86;X64;ANYCPU;NETCOREAPP"
-        # oneValueArgs
-        "NAME;CONFIG;PLATFORM;VERSION;OUTPUT_PATH"
-        # multiValueArgs
-        "PACKAGE;DEPENDS;ARGUMENTS;PACK_ARGUMENTS;OUTPUT;SOURCES;CUSTOM_BUILDPROPS,BUILD_OPTIONS"
-        # the input arguments
-        ${arguments})
-
-    GET_FILENAME_COMPONENT(_DN_abs_proj "${_DN_PROJECT}" ABSOLUTE)
-    GET_FILENAME_COMPONENT(_DN_proj_dir "${_DN_abs_proj}" DIRECTORY)
-    GET_FILENAME_COMPONENT(_DN_projname "${_DN_PROJECT}" NAME)
-    STRING(REGEX REPLACE "\\.[^.]*$" "" _DN_projname_noext ${_DN_projname})
-
-    FILE(GLOB_RECURSE DOTNET_deps
-        ${_DN_proj_dir}/*.cs
-        ${_DN_proj_dir}/*.fs
-        ${_DN_proj_dir}/*.vb
-        ${_DN_proj_dir}/*.xaml
-        ${_DN_proj_dir}/*.resx
-        ${_DN_proj_dir}/*.xml
-        ${_DN_proj_dir}/*.*proj
-        ${_DN_proj_dir}/*.cs
-        ${_DN_proj_dir}/*.config)
-    LIST(APPEND DOTNET_deps ${_DN_SOURCES})
-    SET(_DN_deps "")
-    FOREACH(dep ${DOTNET_deps})
-        IF(NOT dep MATCHES /obj/ AND NOT dep MATCHES /bin/)
-            LIST(APPEND _DN_deps ${dep})
-        ENDIF()
-    ENDFOREACH()
-
-
-    IF(_DN_RELEASE)
-        SET(_DN_CONFIG Release)
-    ELSEIF(_DN_DEBUG)
-        SET(_DN_CONFIG Debug)
-    ENDIF()
-
-    IF(NOT _DN_CONFIG)
-        SET(_DN_CONFIG "$<$<CONFIG:Debug>:Debug>$<$<NOT:$<CONFIG:Debug>>:Release>")
-    ENDIF()
-
-    # If platform is not specified, do not pass the Platform property.
-    # dotnet will pick the default Platform.
-
-    IF(_DN_X86)
-        SET(_DN_PLATFORM x86)
-    ELSEIF(_DN_X64)
-        SET(_DN_PLATFORM x64)
-    ELSEIF(_DN_ANYCPU)
-        SET(_DN_PLATFORM "AnyCPU")
-    ENDIF()
-
-    # If package version is not set, first fallback to DOTNET_PACKAGE_VERSION
-    # If again not set, defaults to 1.0.0
-    IF(NOT _DN_VERSION)
-        SET(_DN_VERSION ${DOTNET_PACKAGE_VERSION})
-    ENDIF()
-    IF(NOT _DN_VERSION)
-        SET(_DN_VERSION "1.0.0")
-    ENDIF()
-
-    # Set the output path to the binary directory.
-    # Build outputs in separated output directories prevent overwriting.
-    # Later we then copy the outputs to the destination.
-
-    IF(NOT _DN_OUTPUT_PATH)
-        SET(_DN_OUTPUT_PATH ${_DN_projname_noext})
-    ENDIF()
-
-    GET_FILENAME_COMPONENT(_DN_OUTPUT_PATH ${_DN_OUTPUT_PATH} ABSOLUTE)
-
-    # In a cmake build, the XPLAT libraries are always copied over.
-    # Set the proper directory for .NET projects.
-    SET(_DN_XPLAT_LIB_DIR ${CMAKE_BINARY_DIR})
-
-    SET(DOTNET_PACKAGES ${_DN_PACKAGE}  PARENT_SCOPE)
-    SET(DOTNET_CONFIG   ${_DN_CONFIG}   PARENT_SCOPE)
-    SET(DOTNET_PLATFORM ${_DN_PLATFORM} PARENT_SCOPE)
-    SET(DOTNET_DEPENDS  ${_DN_DEPENDS}  PARENT_SCOPE)
-    SET(DOTNET_SOURCES  ${_DN_SOURCES}  PARENT_SCOPE)
-    if(_DN_NAME)
-        SET(DOTNET_PROJNAME ${_DN_NAME} PARENT_SCOPE)
-    else()
-        SET(DOTNET_PROJNAME ${_DN_projname_noext} PARENT_SCOPE)
-    endif()
-    SET(DOTNET_PROJPATH ${_DN_abs_proj} PARENT_SCOPE)
-    SET(DOTNET_PROJDIR  ${_DN_proj_dir} PARENT_SCOPE)
-    SET(DOTNET_ARGUMENTS ${_DN_ARGUMENTS} PARENT_SCOPE)
-    SET(DOTNET_RUN_OUTPUT ${_DN_OUTPUT} PARENT_SCOPE)
-    SET(DOTNET_PACKAGE_VERSION ${_DN_VERSION} PARENT_SCOPE)
-    SET(DOTNET_OUTPUT_PATH ${_DN_OUTPUT_PATH} PARENT_SCOPE)
-    SET(DOTNET_deps ${_DN_deps} PARENT_SCOPE)
-
-    IF(_DN_PLATFORM)
-        SET(_DN_PLATFORM_PROP "/p:Platform=${_DN_PLATFORM}")
-    ENDIF()
-
-    SET(_DN_IMPORT_PROP ${CMAKE_CURRENT_BINARY_DIR}/${_DN_projname}.imports.props)
-    CONFIGURE_FILE(${DOTNET_MODULE_DIR}/DotnetImports.props.in ${_DN_IMPORT_PROP})
-    SET(_DN_IMPORT_ARGS "/p:DirectoryBuildPropsPath=${_DN_IMPORT_PROP}")
-
-    SET(DOTNET_IMPORT_PROPERTIES ${_DN_IMPORT_ARGS} PARENT_SCOPE)
-    SET(DOTNET_BUILD_PROPERTIES ${_DN_PLATFORM_PROP} ${_DN_IMPORT_ARGS} PARENT_SCOPE)
-    SET(DOTNET_BUILD_OPTIONS ${_DN_BUILD_OPTIONS} PARENT_SCOPE)
-    SET(DOTNET_PACK_OPTIONS --include-symbols ${_DN_PACK_OPTIONS} ${_DN_PACK_ARGUMENTS} PARENT_SCOPE)
-
-ENDFUNCTION()
-
-MACRO(ADD_DOTNET_DEPENDENCY_TARGETS )
-    FOREACH(dep ${DOTNET_DEPENDS})
-        ADD_DEPENDENCIES(${DOTNET_PROJNAME} ${dep})
-        if(CMAKE_VERBOSE_MAKEFILE)
-            MESSAGE("     ${DOTNET_PROJNAME} has dependency ${dep}")
-        endif()
-    ENDFOREACH()
-
-    FOREACH(pkg ${DOTNET_PACKAGES})
-        if( NOT( TARGET DOTNET_PURGE_${pkg} ) )
-            STRING(TOLOWER ${pkg} pkg_lowercase)
-            GET_FILENAME_COMPONENT(cache_path ${NUGET_CACHE_PATH}/${pkg_lowercase} ABSOLUTE)
-            IF(WIN32)
-                SET(rm_command powershell -NoLogo -NoProfile -NonInteractive -Command "Remove-Item -Recurse -Force -ErrorAction Ignore '${cache_path}'\; exit 0")
-            ELSE()
-                SET(rm_command rm -rf ${cache_path})
-            ENDIF()
-            ADD_CUSTOM_TARGET(
-                DOTNET_PURGE_${pkg}
-                COMMAND ${CMAKE_COMMAND} -E echo "======= [x] Purging nuget package cache for ${pkg}"
-                COMMAND ${rm_command}
-                DEPENDS ${DOTNET_deps}
-            )
-        endif ( NOT( TARGET DOTNET_PURGE_${pkg} ) )
-        ADD_DEPENDENCIES(${DOTNET_PROJNAME} DOTNET_PURGE_${pkg})
-        if(CMAKE_VERBOSE_MAKEFILE)
-            MESSAGE("==== ${DOTNET_PROJNAME} uses nuget package ${pkg}")
-        endif()
-    ENDFOREACH()
-ENDMACRO()
-
-MACRO(DOTNET_BUILD_COMMANDS)
-    IF(${DOTNET_IS_MSBUILD})
-        SET(build_dotnet_cmds
-            COMMAND ${CMAKE_COMMAND} -E echo "======= Building msbuild project ${DOTNET_PROJNAME} [${DOTNET_CONFIG} ${DOTNET_PLATFORM}]"
-            COMMAND ${NUGET_EXE} restore -Force ${DOTNET_PROJPATH}
-            COMMAND ${DOTNET_EXE} msbuild ${DOTNET_PROJPATH} /t:Clean ${DOTNET_BUILD_PROPERTIES} /p:Configuration="${DOTNET_CONFIG}"
-            COMMAND ${DOTNET_EXE} msbuild ${DOTNET_PROJPATH} /t:Build ${DOTNET_BUILD_PROPERTIES} /p:Configuration="${DOTNET_CONFIG}" ${DOTNET_ARGUMENTS})
-        SET(build_dotnet_type "msbuild")
-    ELSE()
-        SET(build_dotnet_cmds
-            COMMAND ${CMAKE_COMMAND} -E echo "======= Building .NET project ${DOTNET_PROJNAME} [${DOTNET_CONFIG} ${DOTNET_PLATFORM}]")
-        foreach (_src ${DOTNET_SOURCES} )
-            LIST(APPEND build_dotnet_cmds COMMAND ${DOTNET_EXE} add ${DOTNET_PROJPATH} reference ${_src})
-        endforeach ()
-        foreach ( _pkg ${DOTNET_PACKAGES} )
-            set(_ADD_PROPERTIES)
-            if ( _pkg MATCHES "^OSGeo*.")
-                set(_ADD_PROPERTIES --version "${DOTNET_PACKAGE_VERSION}")
-            endif()
-            LIST(APPEND build_dotnet_cmds COMMAND ${DOTNET_EXE} add ${DOTNET_PROJPATH} package ${_ADD_PROPERTIES} ${_pkg})
-        endforeach()
-        LIST(APPEND build_dotnet_cmds
-            COMMAND ${DOTNET_EXE} clean ${DOTNET_PROJPATH} ${DOTNET_BUILD_PROPERTIES}
-            COMMAND ${DOTNET_EXE} build -c ${DOTNET_CONFIG} ${DOTNET_BUILD_PROPERTIES} ${DOTNET_BUILD_OPTIONS} ${DOTNET_ARGUMENTS} ${DOTNET_PROJPATH})
-        SET(build_dotnet_type "dotnet")
-    ENDIF()
-
-    # DOTNET_OUTPUTS refer to artifacts produced, that the proj_name target depends on.
-    SET(DOTNET_OUTPUTS)
-    if(CMAKE_VERBOSE_MAKEFILE)
-        IF(NOT DOTNET_PACKAGES})
-            MESSAGE("-- Adding ${build_dotnet_type} project ${DOTNET_PROJPATH} (version ${DOTNET_PACKAGE_VERSION})")
-        ELSE()
-            MESSAGE("-- Adding ${build_dotnet_type} project ${DOTNET_PROJPATH} (no nupkg)")
-        ENDIF()
-    endif()
-
-    LIST(APPEND build_dotnet_cmds COMMAND ${DOTNET_EXE} pack
-                        --no-build --no-restore ${DOTNET_PROJPATH}
-                        -c ${DOTNET_CONFIG} ${DOTNET_BUILD_PROPERTIES} ${DOTNET_PACK_OPTIONS}
-                        --output ${CMAKE_CURRENT_BINARY_DIR} -p:PackageVersion=${DOTNET_PACKAGE_VERSION} )
-    LIST(APPEND DOTNET_OUTPUTS ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.buildtimestamp)
-    LIST(APPEND build_dotnet_cmds COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.buildtimestamp)
-
-    ADD_CUSTOM_COMMAND(
-        OUTPUT ${DOTNET_OUTPUTS}
-        VERBATIM
-        DEPENDS ${DOTNET_deps}  ${DOTNET_PROJPATH}
-        ${build_dotnet_cmds}
-        )
-    ADD_CUSTOM_TARGET(
-        ${DOTNET_PROJNAME} ALL
-        DEPENDS ${DOTNET_OUTPUTS})
-
-ENDMACRO()
-
-FUNCTION(ADD_DOTNET DOTNET_PROJECT)
-    DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN}")
-    SET(DOTNET_IS_MSBUILD FALSE)
-    DOTNET_BUILD_COMMANDS()
-    ADD_DOTNET_DEPENDENCY_TARGETS()
-ENDFUNCTION()
-
-FUNCTION(ADD_MSBUILD DOTNET_PROJECT)
-    IF(NOT WIN32)
-        MESSAGE("-- Building non-Win32, skipping ${DOTNET_PROJECT}")
-        RETURN()
-    ENDIF()
-
-    DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN}")
-    SET(DOTNET_IS_MSBUILD TRUE)
-    DOTNET_BUILD_COMMANDS()
-    ADD_DOTNET_DEPENDENCY_TARGETS()
-ENDFUNCTION()
-
-FUNCTION(RUN_DOTNET DOTNET_PROJECT)
-    DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN};NETCOREAPP")
-    MESSAGE("-- Adding dotnet run project ${DOTNET_PROJECT}")
-    FILE(MAKE_DIRECTORY ${DOTNET_OUTPUT_PATH})
-    ADD_CUSTOM_COMMAND(
-        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.runtimestamp ${DOTNET_RUN_OUTPUT}
-        DEPENDS ${DOTNET_deps}
-        COMMAND ${DOTNET_EXE} restore ${DOTNET_PROJPATH} ${DOTNET_IMPORT_PROPERTIES}
-        COMMAND ${DOTNET_EXE} clean ${DOTNET_PROJPATH} ${DOTNET_BUILD_PROPERTIES}
-        COMMAND ${DOTNET_EXE} build --no-restore ${DOTNET_PROJPATH} -c ${DOTNET_CONFIG} ${DOTNET_BUILD_PROPERTIES} ${DOTNET_BUILD_OPTIONS}
-        # XXX tfm
-        COMMAND ${DOTNET_EXE} ${DOTNET_OUTPUT_PATH}/netcoreapp3.1/${DOTNET_PROJNAME}.dll ${DOTNET_ARGUMENTS}
-        COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.runtimestamp
-        WORKING_DIRECTORY ${DOTNET_OUTPUT_PATH})
-    ADD_CUSTOM_TARGET(
-        ${DOTNET_PROJNAME}
-        DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.runtimestamp ${DOTNET_RUN_OUTPUT})
-    ADD_DOTNET_DEPENDENCY_TARGETS()
-ENDFUNCTION()
-
-FUNCTION(TEST_DOTNET DOTNET_PROJECT)
-    DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN}")
-    MESSAGE("-- Adding dotnet test project ${DOTNET_PROJECT}")
-    IF(WIN32)
-        SET(test_framework_args "")
-    ELSE()
-        SET(test_framework_args -f netcoreapp3.1)
-    ENDIF()
-
-    ADD_TEST(NAME              ${DOTNET_PROJNAME}
-             COMMAND           ${DOTNET_EXE} test ${test_framework_args} --results-directory "${CMAKE_BINARY_DIR}" --logger trx ${DOTNET_ARGUMENTS}
-             WORKING_DIRECTORY ${DOTNET_OUTPUT_PATH})
-
-ENDFUNCTION()
-
-SET_PROPERTY(GLOBAL PROPERTY DOTNET_LAST_SMOKETEST "")
-
-FUNCTION(SMOKETEST_DOTNET DOTNET_PROJECT)
-    MESSAGE("-- Adding dotnet smoke test project ${DOTNET_PROJECT}")
-    IF(WIN32)
-        RUN_DOTNET(${DOTNET_PROJECT} "${ARGN}")
-    ELSE()
-        RUN_DOTNET(${DOTNET_PROJECT} "${ARGN}")
-    ENDIF()
-
-    DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN}")
-    ADD_CUSTOM_TARGET(
-        ${DOTNET_PROJNAME}
-        ALL
-        DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.runtimestamp)
-    ADD_DOTNET_DEPENDENCY_TARGETS()
-    GET_PROPERTY(_dn_last_smoketest GLOBAL PROPERTY DOTNET_LAST_SMOKETEST)
-    IF(_dn_last_smoketest)
-        MESSAGE("${_dn_last_smoketest} -> SMOKETEST_${DOTNET_PROJNAME}")
-        ADD_DEPENDENCIES(${DOTNET_PROJNAME} ${_dn_last_smoketest})
-    ENDIF()
-    # Chain the smoke tests together so they are executed sequentially
-    SET_PROPERTY(GLOBAL PROPERTY DOTNET_LAST_SMOKETEST SMOKETEST_${DOTNET_PROJNAME})
-
-ENDFUNCTION()
-
-SET(DOTNET_IMPORTS_TEMPLATE ${CMAKE_CURRENT_LIST_DIR}/DotnetImports.props.in)
-
-FUNCTION(GEN_DOTNET_PROPS target_props_file)
-    CMAKE_PARSE_ARGUMENTS(
-        # prefix
-        _DNP
-        # options (flags)
-        ""
-        # oneValueArgs
-        "PACKAGE_VERSION;XML_INJECT"
-        # multiValueArgs
-        ""
-        # the input arguments
-        ${ARGN})
-
-    IF(NOT _DNP_PACKAGE_VERSION)
-        SET(_DNP_PACKAGE_VERSION 1.0.0)
-    ENDIF()
-
-    IF(_DNP_XML_INJECT)
-        SET(_DN_CUSTOM_BUILDPROPS ${_DNP_XML_INJECT})
-    ENDIF()
-
-    SET(_DN_OUTPUT_PATH ${CMAKE_BINARY_DIR})
-    SET(_DN_XPLAT_LIB_DIR ${CMAKE_BINARY_DIR})
-    SET(_DN_VERSION ${_DNP_PACKAGE_VERSION})
-    CONFIGURE_FILE(${DOTNET_IMPORTS_TEMPLATE} ${target_props_file})
-    UNSET(_DN_OUTPUT_PATH)
-    UNSET(_DN_XPLAT_LIB_DIR)
-    UNSET(_DN_VERSION)
-ENDFUNCTION()
-
-
-MESSAGE("-- Found .NET toolchain: ${DOTNET_EXE} (version ${DOTNET_VERSION})")
-SET(DOTNET_FOUND TRUE)

package/dist/prebuilt/Emscripten-x86_64/lib/cmake/gdal/thirdparty/FindInt128.cmake

@@ -1,65 +0,0 @@
-# ============================================================================
-#  MCKL/cmake/FindInt128.cmake
-# ----------------------------------------------------------------------------
-#  MCKL: Monte Carlo Kernel Library
-# ----------------------------------------------------------------------------
-#  Copyright (c) 2013-2017, Yan Zhou
-#  All rights reserved.
-#
-#  Redistribution and use in source and binary forms, with or without
-#  modification, are permitted provided that the following conditions are met:
-#
-#    Redistributions of source code must retain the above copyright notice,
-#    this list of conditions and the following disclaimer.
-#
-#    Redistributions in binary form must reproduce the above copyright notice,
-#    this list of conditions and the following disclaimer in the documentation
-#    and/or other materials provided with the distribution.
-#
-#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
-#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-#  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-#  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-#  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-#  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-#  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-#  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-#  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-#  POSSIBILITY OF SUCH DAMAGE.
-# ============================================================================
-
-# Find 128-bits integer type
-#
-# The following variable is set
-#
-# INT128_FOUND - TRUE if 128-bits integer type is found and works correctly
-# INT128_TYPE  - The type of the 128-bits integer
-
-if(DEFINED INT128_FOUND)
-    return()
-endif(DEFINED INT128_FOUND)
-
-set(SAFE_CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS})
-
-set(INT128_TEST_SOURCE "#include <cassert>\nint main(){\n
-    unsigned long long a = 0x0123456789ABCDEF;unsigned long long b = 0xFEDCBA9876543210;
-    unsigned INT128 c = static_cast<unsigned INT128>(a) * static_cast<unsigned INT128>(b);
-    assert(static_cast<unsigned long long>(c >> 0x00) == 0x2236D88FE5618CF0);
-    assert(static_cast<unsigned long long>(c >> 0x40) == 0x0121FA00AD77D742);return 0;}"
-)
-set(INT128_TRY_TYPE "__int128")
-set(CMAKE_REQUIRED_DEFINITIONS ${SAFE_CMAKE_REQUIRED_DEFINITIONS}
-    -DINT128=${INT128_TRY_TYPE})
-include(CheckCXXSourceCompiles)
-check_cxx_source_compiles("${INT128_TEST_SOURCE}" INT128_TEST)
-if(INT128_TEST)
-    set(INT128_TYPE ${INT128_TRY_TYPE} CACHE STRING "128-bit type")
-    set(INT128_FOUND TRUE CACHE BOOL "Found 128-bits integer type")
-else(INT128_TEST)
-    set(INT128_FOUND FALSE CACHE BOOL "NOT Found 128-bit integer type")
-endif(INT128_TEST)
-mark_as_advanced(INT128_TYPE)
-mark_as_advanced(INT128_FOUND)
-
-set(CMAKE_REQUIRED_DEFINITIONS ${SAFE_CMAKE_REQUIRED_DEFINITIONS})