From 73246da0a5853b93acde05d33be4f7ddb3533ed1 Mon Sep 17 00:00:00 2001 From: Manuinder Sekhon Date: Sun, 28 Mar 2021 00:15:17 +0530 Subject: [PATCH] create build files and compile for android and iOS --- .vscode/settings.json | 6 + libc_deepspeech/.gitignore | 14 + libc_deepspeech/build/android/CMakeLists.txt | 20 + .../android/arm64-v8a/libdeepspeechlibc.so | Bin 0 -> 9760 bytes .../android/armeabi-v7a/libdeepspeechlibc.so | Bin 0 -> 8176 bytes .../ios/Release-iphoneos/libdeepspeechlibc.a | Bin 0 -> 4704 bytes libc_deepspeech/build/ios/CMakeLists.txt | 13 + libc_deepspeech/build/ios/ios.toolchain.cmake | 725 ++++++++++++++++++ 8 files changed, 778 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 libc_deepspeech/.gitignore create mode 100644 libc_deepspeech/build/android/CMakeLists.txt create mode 100755 libc_deepspeech/build/bin/android/arm64-v8a/libdeepspeechlibc.so create mode 100755 libc_deepspeech/build/bin/android/armeabi-v7a/libdeepspeechlibc.so create mode 100644 libc_deepspeech/build/bin/ios/Release-iphoneos/libdeepspeechlibc.a create mode 100644 libc_deepspeech/build/ios/CMakeLists.txt create mode 100644 libc_deepspeech/build/ios/ios.toolchain.cmake diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..a7d6252 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,6 @@ +{ + "files.associations": { + "libc_deepspeech.h": "c", + "deepspeech.h": "c" + } +} \ No newline at end of file diff --git a/libc_deepspeech/.gitignore b/libc_deepspeech/.gitignore new file mode 100644 index 0000000..7f9f9c3 --- /dev/null +++ b/libc_deepspeech/.gitignore @@ -0,0 +1,14 @@ +CMakeFiles/ +*.cmake +CMakeCache.txt +Makefile +CmakeScripts/ +Project.build +Project.xcodeproj +XCBuildData/ +.ninja* +*.ninja +.DS_Store +build_files/ + +!ios.toolchain.cmake \ No newline at end of file diff --git a/libc_deepspeech/build/android/CMakeLists.txt b/libc_deepspeech/build/android/CMakeLists.txt new file mode 100644 index 0000000..d67f71d --- /dev/null +++ b/libc_deepspeech/build/android/CMakeLists.txt @@ -0,0 +1,20 @@ +cmake_minimum_required(VERSION 3.4.1) + +# Library source files. +FILE(GLOB SRC ../../*.c) + +# Add our own library, we will call it libcdeepspeech +add_library(deepspeechlibc SHARED ${SRC}) +include_directories(../../) + +# Include DeepSpeech 0.9.3 +add_library(libdeepspeech SHARED IMPORTED) + +# Get absolute path for desired architecture +get_filename_component(ABI_LIB_PATH ../../../libdeepspeech_0.9.3/android/${ANDROID_ABI}/libdeepspeech.so ABSOLUTE) + +set_target_properties( libdeepspeech PROPERTIES IMPORTED_LOCATION ${ABI_LIB_PATH} ) +include_directories( ../../../libdeepspeech_0.9.3/ ) + +# Link our library with deepspeech 0.9.3 library +target_link_libraries( deepspeechlibc libdeepspeech ) diff --git a/libc_deepspeech/build/bin/android/arm64-v8a/libdeepspeechlibc.so b/libc_deepspeech/build/bin/android/arm64-v8a/libdeepspeechlibc.so new file mode 100755 index 0000000000000000000000000000000000000000..a43496f21aa9d4c280a2c69a798fbe975b4e1e9c GIT binary patch literal 9760 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 H{__6~7Ro;0 literal 0 HcmV?d00001 diff --git a/libc_deepspeech/build/bin/android/armeabi-v7a/libdeepspeechlibc.so b/libc_deepspeech/build/bin/android/armeabi-v7a/libdeepspeechlibc.so new file mode 100755 index 0000000000000000000000000000000000000000..3c9f18c0ccf977598dd727eeb8ad55256af3a3c6 GIT binary patch literal 8176 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 Qp@jWT;h?%t8bf~n1YJW3I{*Lx literal 0 HcmV?d00001 diff --git a/libc_deepspeech/build/bin/ios/Release-iphoneos/libdeepspeechlibc.a b/libc_deepspeech/build/bin/ios/Release-iphoneos/libdeepspeechlibc.a new file mode 100644 index 0000000000000000000000000000000000000000..9d389bc477d536db6c490778f3a4b7f862d4e5ea GIT binary patch literal 4704 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 D_Ge6h literal 0 HcmV?d00001 diff --git a/libc_deepspeech/build/ios/CMakeLists.txt b/libc_deepspeech/build/ios/CMakeLists.txt new file mode 100644 index 0000000..db463f4 --- /dev/null +++ b/libc_deepspeech/build/ios/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.4.1) + +# Library source files. +FILE(GLOB SRC ../../*.c) + +add_library(deepspeechlibc STATIC ${SRC}) +include_directories(../../) + +# Find DeepSpeech 0.9.3 framework +find_library(DEEPSPEECH_LIB NAMES deepspeech_ios HINTS "../../../libdeepspeech_0.9.3") + +# Link our library with DeepSpeech 0.9.3 framework +target_link_libraries(deepspeechlibc ${DEEPSPEECH_LIB}) diff --git a/libc_deepspeech/build/ios/ios.toolchain.cmake b/libc_deepspeech/build/ios/ios.toolchain.cmake new file mode 100644 index 0000000..d9271e6 --- /dev/null +++ b/libc_deepspeech/build/ios/ios.toolchain.cmake @@ -0,0 +1,725 @@ +# This file is part of the ios-cmake project. It was retrieved from +# https://github.com/cristeab/ios-cmake.git, which is a fork of +# https://code.google.com/p/ios-cmake/. Which in turn is based off of +# the Platform/Darwin.cmake and Platform/UnixPaths.cmake files which +# are included with CMake 2.8.4 +# +# The ios-cmake project is licensed under the new BSD license. +# +# Copyright (c) 2014, Bogdan Cristea and LTE Engineering Software, +# Kitware, Inc., Insight Software Consortium. All rights reserved. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. 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. +# +# 3. Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# 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. +# +# This file is based off of the Platform/Darwin.cmake and +# Platform/UnixPaths.cmake files which are included with CMake 2.8.4 +# It has been altered for iOS development. +# +# Updated by Alex Stewart (alexs.mac@gmail.com) +# +# ***************************************************************************** +# Now maintained by Alexander Widerberg (widerbergaren [at] gmail.com) +# under the BSD-3-Clause license +# https://github.com/leetal/ios-cmake +# ***************************************************************************** +# +# INFORMATION / HELP +# +# The following arguments control the behaviour of this toolchain: +# +# PLATFORM: (default "OS") +# OS = Build for iPhoneOS. +# OS64 = Build for arm64 iphoneOS. +# OS64COMBINED = Build for arm64 x86_64 iphoneOS. Combined into FAT STATIC lib (supported on 3.14+ of CMakewith "-G Xcode" argument ONLY) +# SIMULATOR = Build for x86 i386 iphoneOS Simulator. +# SIMULATOR64 = Build for x86_64 iphoneOS Simulator. +# TVOS = Build for arm64 tvOS. +# TVOSCOMBINED = Build for arm64 x86_64 tvOS. Combined into FAT STATIC lib (supported on 3.14+ of CMake with "-G Xcode" argument ONLY) +# SIMULATOR_TVOS = Build for x86_64 tvOS Simulator. +# WATCHOS = Build for armv7k arm64_32 for watchOS. +# WATCHOSCOMBINED = Build for armv7k arm64_32 x86_64 watchOS. Combined into FAT STATIC lib (supported on 3.14+ of CMake with "-G Xcode" argument ONLY) +# SIMULATOR_WATCHOS = Build for x86_64 for watchOS Simulator. +# +# CMAKE_OSX_SYSROOT: Path to the SDK to use. By default this is +# automatically determined from PLATFORM and xcodebuild, but +# can also be manually specified (although this should not be required). +# +# CMAKE_DEVELOPER_ROOT: Path to the Developer directory for the platform +# being compiled for. By default this is automatically determined from +# CMAKE_OSX_SYSROOT, but can also be manually specified (although this should +# not be required). +# +# DEPLOYMENT_TARGET: Minimum SDK version to target. Default 2.0 on watchOS and 9.0 on tvOS+iOS +# +# ENABLE_BITCODE: (1|0) Enables or disables bitcode support. Default 1 (true) +# +# ENABLE_ARC: (1|0) Enables or disables ARC support. Default 1 (true, ARC enabled by default) +# +# ENABLE_VISIBILITY: (1|0) Enables or disables symbol visibility support. Default 0 (false, visibility hidden by default) +# +# ENABLE_STRICT_TRY_COMPILE: (1|0) Enables or disables strict try_compile() on all Check* directives (will run linker +# to actually check if linking is possible). Default 0 (false, will set CMAKE_TRY_COMPILE_TARGET_TYPE to STATIC_LIBRARY) +# +# ARCHS: (armv7 armv7s armv7k arm64 arm64_32 i386 x86_64) If specified, will override the default architectures for the given PLATFORM +# OS = armv7 armv7s arm64 (if applicable) +# OS64 = arm64 (if applicable) +# SIMULATOR = i386 +# SIMULATOR64 = x86_64 +# TVOS = arm64 +# SIMULATOR_TVOS = x86_64 (i386 has since long been deprecated) +# WATCHOS = armv7k arm64_32 (if applicable) +# SIMULATOR_WATCHOS = x86_64 (i386 has since long been deprecated) +# +# This toolchain defines the following variables for use externally: +# +# XCODE_VERSION: Version number (not including Build version) of Xcode detected. +# SDK_VERSION: Version of SDK being used. +# CMAKE_OSX_ARCHITECTURES: Architectures being compiled for (generated from PLATFORM). +# APPLE_TARGET_TRIPLE: Used by autoconf build systems. NOTE: If "ARCHS" are overridden, this will *NOT* be set! +# +# This toolchain defines the following macros for use externally: +# +# set_xcode_property (TARGET XCODE_PROPERTY XCODE_VALUE XCODE_VARIANT) +# A convenience macro for setting xcode specific properties on targets. +# Available variants are: All, Release, RelWithDebInfo, Debug, MinSizeRel +# example: set_xcode_property (myioslib IPHONEOS_DEPLOYMENT_TARGET "3.1" "all"). +# +# find_host_package (PROGRAM ARGS) +# A macro used to find executable programs on the host system, not within the +# environment. Thanks to the android-cmake project for providing the +# command. +# +# ******************************** DEPRECATIONS ******************************* +# +# IOS_DEPLOYMENT_TARGET: (Deprecated) Alias to DEPLOYMENT_TARGET +# CMAKE_IOS_DEVELOPER_ROOT: (Deprecated) Alias to CMAKE_DEVELOPER_ROOT +# IOS_PLATFORM: (Deprecated) Alias to PLATFORM +# IOS_ARCH: (Deprecated) Alias to ARCHS +# +# ***************************************************************************** +# + +# Fix for PThread library not in path +set(CMAKE_THREAD_LIBS_INIT "-lpthread") +set(CMAKE_HAVE_THREADS_LIBRARY 1) +set(CMAKE_USE_WIN32_THREADS_INIT 0) +set(CMAKE_USE_PTHREADS_INIT 1) + +# Cache what generator is used +set(USED_CMAKE_GENERATOR "${CMAKE_GENERATOR}" CACHE STRING "Expose CMAKE_GENERATOR" FORCE) + +if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14") + set(MODERN_CMAKE YES) +endif() + +# Get the Xcode version being used. +execute_process(COMMAND xcodebuild -version + OUTPUT_VARIABLE XCODE_VERSION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +string(REGEX MATCH "Xcode [0-9\\.]+" XCODE_VERSION "${XCODE_VERSION}") +string(REGEX REPLACE "Xcode ([0-9\\.]+)" "\\1" XCODE_VERSION "${XCODE_VERSION}") + +######## ALIASES (DEPRECATION WARNINGS) + +if(DEFINED IOS_PLATFORM) + set(PLATFORM ${IOS_PLATFORM}) + message(DEPRECATION "IOS_PLATFORM argument is DEPRECATED. Consider using the new PLATFORM argument instead.") +endif() + +if(DEFINED IOS_DEPLOYMENT_TARGET) + set(DEPLOYMENT_TARGET ${IOS_DEPLOYMENT_TARGET}) + message(DEPRECATION "IOS_DEPLOYMENT_TARGET argument is DEPRECATED. Consider using the new DEPLOYMENT_TARGET argument instead.") +endif() + +if(DEFINED CMAKE_IOS_DEVELOPER_ROOT) + set(CMAKE_DEVELOPER_ROOT ${CMAKE_IOS_DEVELOPER_ROOT}) + message(DEPRECATION "CMAKE_IOS_DEVELOPER_ROOT argument is DEPRECATED. Consider using the new CMAKE_DEVELOPER_ROOT argument instead.") +endif() + +if(DEFINED IOS_ARCH) + set(ARCHS ${IOS_ARCH}) + message(DEPRECATION "IOS_ARCH argument is DEPRECATED. Consider using the new ARCHS argument instead.") +endif() + +######## END ALIASES + +# Unset the FORCE on cache variables if in try_compile() +set(FORCE_CACHE FORCE) +get_property(_CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE) +if(_CMAKE_IN_TRY_COMPILE) + unset(FORCE_CACHE) +endif() + +# Default to building for iPhoneOS if not specified otherwise, and we cannot +# determine the platform from the CMAKE_OSX_ARCHITECTURES variable. The use +# of CMAKE_OSX_ARCHITECTURES is such that try_compile() projects can correctly +# determine the value of PLATFORM from the root project, as +# CMAKE_OSX_ARCHITECTURES is propagated to them by CMake. +if(NOT DEFINED PLATFORM) + if (CMAKE_OSX_ARCHITECTURES) + if(CMAKE_OSX_ARCHITECTURES MATCHES ".*arm.*" AND CMAKE_OSX_SYSROOT MATCHES ".*iphoneos.*") + set(PLATFORM "OS") + elseif(CMAKE_OSX_ARCHITECTURES MATCHES "i386" AND CMAKE_OSX_SYSROOT MATCHES ".*iphonesimulator.*") + set(PLATFORM "SIMULATOR") + elseif(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64" AND CMAKE_OSX_SYSROOT MATCHES ".*iphonesimulator.*") + set(PLATFORM "SIMULATOR64") + elseif(CMAKE_OSX_ARCHITECTURES MATCHES "arm64" AND CMAKE_OSX_SYSROOT MATCHES ".*appletvos.*") + set(PLATFORM "TVOS") + elseif(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64" AND CMAKE_OSX_SYSROOT MATCHES ".*appletvsimulator.*") + set(PLATFORM "SIMULATOR_TVOS") + elseif(CMAKE_OSX_ARCHITECTURES MATCHES ".*armv7k.*" AND CMAKE_OSX_SYSROOT MATCHES ".*watchos.*") + set(PLATFORM "WATCHOS") + elseif(CMAKE_OSX_ARCHITECTURES MATCHES "i386" AND CMAKE_OSX_SYSROOT MATCHES ".*watchsimulator.*") + set(PLATFORM "SIMULATOR_WATCHOS") + endif() + endif() + if (NOT PLATFORM) + set(PLATFORM "OS") + endif() +endif() + +set(PLATFORM_INT "${PLATFORM}" CACHE STRING "Type of platform for which the build targets.") + +# Handle the case where we are targeting iOS and a version above 10.3.4 (32-bit support dropped officially) +if(PLATFORM_INT STREQUAL "OS" AND DEPLOYMENT_TARGET VERSION_GREATER_EQUAL 10.3.4) + set(PLATFORM_INT "OS64") + message(STATUS "Targeting minimum SDK version ${DEPLOYMENT_TARGET}. Dropping 32-bit support.") +elseif(PLATFORM_INT STREQUAL "SIMULATOR" AND DEPLOYMENT_TARGET VERSION_GREATER_EQUAL 10.3.4) + set(PLATFORM_INT "SIMULATOR64") + message(STATUS "Targeting minimum SDK version ${DEPLOYMENT_TARGET}. Dropping 32-bit support.") +endif() + +# Determine the platform name and architectures for use in xcodebuild commands +# from the specified PLATFORM name. +if(PLATFORM_INT STREQUAL "OS") + set(SDK_NAME iphoneos) + if(NOT ARCHS) + set(ARCHS armv7 armv7s arm64) + set(APPLE_TARGET_TRIPLE_INT arm-apple-ios) + endif() +elseif(PLATFORM_INT STREQUAL "OS64") + set(SDK_NAME iphoneos) + if(NOT ARCHS) + if (XCODE_VERSION VERSION_GREATER 10.0) + set(ARCHS arm64) # Add arm64e when Apple have fixed the integration issues with it, libarclite_iphoneos.a is currently missung bitcode markers for example + else() + set(ARCHS arm64) + endif() + set(APPLE_TARGET_TRIPLE_INT aarch64-apple-ios) + endif() +elseif(PLATFORM_INT STREQUAL "OS64COMBINED") + set(SDK_NAME iphoneos) + if(MODERN_CMAKE) + if(NOT ARCHS) + if (XCODE_VERSION VERSION_GREATER 10.0) + set(ARCHS arm64 x86_64) # Add arm64e when Apple have fixed the integration issues with it, libarclite_iphoneos.a is currently missung bitcode markers for example + else() + set(ARCHS arm64 x86_64) + endif() + set(APPLE_TARGET_TRIPLE_INT aarch64-x86_64-apple-ios) + endif() + else() + message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the OS64COMBINED setting work") + endif() +elseif(PLATFORM_INT STREQUAL "SIMULATOR") + set(SDK_NAME iphonesimulator) + if(NOT ARCHS) + set(ARCHS i386) + set(APPLE_TARGET_TRIPLE_INT i386-apple-ios) + endif() + message(DEPRECATION "SIMULATOR IS DEPRECATED. Consider using SIMULATOR64 instead.") +elseif(PLATFORM_INT STREQUAL "SIMULATOR64") + set(SDK_NAME iphonesimulator) + if(NOT ARCHS) + set(ARCHS x86_64) + set(APPLE_TARGET_TRIPLE_INT x86_64-apple-ios) + endif() +elseif(PLATFORM_INT STREQUAL "TVOS") + set(SDK_NAME appletvos) + if(NOT ARCHS) + set(ARCHS arm64) + set(APPLE_TARGET_TRIPLE_INT aarch64-apple-tvos) + endif() +elseif (PLATFORM_INT STREQUAL "TVOSCOMBINED") + set(SDK_NAME appletvos) + if(MODERN_CMAKE) + if(NOT ARCHS) + set(ARCHS arm64 x86_64) + set(APPLE_TARGET_TRIPLE_INT aarch64-x86_64-apple-tvos) + endif() + else() + message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the TVOSCOMBINED setting work") + endif() +elseif(PLATFORM_INT STREQUAL "SIMULATOR_TVOS") + set(SDK_NAME appletvsimulator) + if(NOT ARCHS) + set(ARCHS x86_64) + set(APPLE_TARGET_TRIPLE_INT x86_64-apple-tvos) + endif() +elseif(PLATFORM_INT STREQUAL "WATCHOS") + set(SDK_NAME watchos) + if(NOT ARCHS) + if (XCODE_VERSION VERSION_GREATER 10.0) + set(ARCHS armv7k arm64_32) + set(APPLE_TARGET_TRIPLE_INT aarch64_32-apple-watchos) + else() + set(ARCHS armv7k) + set(APPLE_TARGET_TRIPLE_INT arm-apple-watchos) + endif() + endif() +elseif(PLATFORM_INT STREQUAL "WATCHOSCOMBINED") + set(SDK_NAME watchos) + if(MODERN_CMAKE) + if(NOT ARCHS) + if (XCODE_VERSION VERSION_GREATER 10.0) + set(ARCHS armv7k arm64_32 i386) + set(APPLE_TARGET_TRIPLE_INT aarch64_32-i386-apple-watchos) + else() + set(ARCHS armv7k i386) + set(APPLE_TARGET_TRIPLE_INT arm-i386-apple-watchos) + endif() + endif() + else() + message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the WATCHOSCOMBINED setting work") + endif() +elseif(PLATFORM_INT STREQUAL "SIMULATOR_WATCHOS") + set(SDK_NAME watchsimulator) + if(NOT ARCHS) + set(ARCHS i386) + set(APPLE_TARGET_TRIPLE_INT i386-apple-watchos) + endif() +else() + message(FATAL_ERROR "Invalid PLATFORM: ${PLATFORM_INT}") +endif() + +if(MODERN_CMAKE AND PLATFORM_INT MATCHES ".*COMBINED" AND NOT USED_CMAKE_GENERATOR MATCHES "Xcode") + message(FATAL_ERROR "The COMBINED options only work with Xcode generator, -G Xcode") +endif() + +# If user did not specify the SDK root to use, then query xcodebuild for it. +execute_process(COMMAND xcodebuild -version -sdk ${SDK_NAME} Path + OUTPUT_VARIABLE CMAKE_OSX_SYSROOT_INT + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +if (NOT DEFINED CMAKE_OSX_SYSROOT_INT AND NOT DEFINED CMAKE_OSX_SYSROOT) + message(SEND_ERROR "Please make sure that Xcode is installed and that the toolchain" + "is pointing to the correct path. Please run:" + "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" + "and see if that fixes the problem for you.") + message(FATAL_ERROR "Invalid CMAKE_OSX_SYSROOT: ${CMAKE_OSX_SYSROOT} " + "does not exist.") +elseif(DEFINED CMAKE_OSX_SYSROOT_INT) + set(CMAKE_OSX_SYSROOT "${CMAKE_OSX_SYSROOT_INT}" CACHE INTERNAL "") +endif() + +# Set Xcode property for SDKROOT as well if Xcode generator is used +if(USED_CMAKE_GENERATOR MATCHES "Xcode") + set(CMAKE_OSX_SYSROOT "${SDK_NAME}" CACHE INTERNAL "") + if(NOT DEFINED CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM) + set(CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM "123456789A" CACHE INTERNAL "") + endif() +endif() + +# Specify minimum version of deployment target. +if(NOT DEFINED DEPLOYMENT_TARGET) + if (PLATFORM_INT STREQUAL "WATCHOS" OR PLATFORM_INT STREQUAL "SIMULATOR_WATCHOS") + # Unless specified, SDK version 2.0 is used by default as minimum target version (watchOS). + set(DEPLOYMENT_TARGET "2.0" + CACHE STRING "Minimum SDK version to build for." ) + else() + # Unless specified, SDK version 9.0 is used by default as minimum target version (iOS, tvOS). + set(DEPLOYMENT_TARGET "9.0" + CACHE STRING "Minimum SDK version to build for." ) + endif() + message(STATUS "Using the default min-version since DEPLOYMENT_TARGET not provided!") +endif() + +# Use bitcode or not +if(NOT DEFINED ENABLE_BITCODE AND NOT ARCHS MATCHES "((^|;|, )(i386|x86_64))+") + # Unless specified, enable bitcode support by default + message(STATUS "Enabling bitcode support by default. ENABLE_BITCODE not provided!") + set(ENABLE_BITCODE TRUE) +elseif(NOT DEFINED ENABLE_BITCODE) + message(STATUS "Disabling bitcode support by default on simulators. ENABLE_BITCODE not provided for override!") + set(ENABLE_BITCODE FALSE) +endif() +set(ENABLE_BITCODE_INT ${ENABLE_BITCODE} CACHE BOOL "Whether or not to enable bitcode" ${FORCE_CACHE}) +# Use ARC or not +if(NOT DEFINED ENABLE_ARC) + # Unless specified, enable ARC support by default + set(ENABLE_ARC TRUE) + message(STATUS "Enabling ARC support by default. ENABLE_ARC not provided!") +endif() +set(ENABLE_ARC_INT ${ENABLE_ARC} CACHE BOOL "Whether or not to enable ARC" ${FORCE_CACHE}) +# Use hidden visibility or not +if(NOT DEFINED ENABLE_VISIBILITY) + # Unless specified, disable symbols visibility by default + set(ENABLE_VISIBILITY FALSE) + message(STATUS "Hiding symbols visibility by default. ENABLE_VISIBILITY not provided!") +endif() +set(ENABLE_VISIBILITY_INT ${ENABLE_VISIBILITY} CACHE BOOL "Whether or not to hide symbols (-fvisibility=hidden)" ${FORCE_CACHE}) +# Set strict compiler checks or not +if(NOT DEFINED ENABLE_STRICT_TRY_COMPILE) + # Unless specified, disable strict try_compile() + set(ENABLE_STRICT_TRY_COMPILE FALSE) + message(STATUS "Using NON-strict compiler checks by default. ENABLE_STRICT_TRY_COMPILE not provided!") +endif() +set(ENABLE_STRICT_TRY_COMPILE_INT ${ENABLE_STRICT_TRY_COMPILE} CACHE BOOL "Whether or not to use strict compiler checks" ${FORCE_CACHE}) +# Get the SDK version information. +execute_process(COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion + OUTPUT_VARIABLE SDK_VERSION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + +# Find the Developer root for the specific iOS platform being compiled for +# from CMAKE_OSX_SYSROOT. Should be ../../ from SDK specified in +# CMAKE_OSX_SYSROOT. There does not appear to be a direct way to obtain +# this information from xcrun or xcodebuild. +if (NOT DEFINED CMAKE_DEVELOPER_ROOT AND NOT USED_CMAKE_GENERATOR MATCHES "Xcode") + get_filename_component(PLATFORM_SDK_DIR ${CMAKE_OSX_SYSROOT} PATH) + get_filename_component(CMAKE_DEVELOPER_ROOT ${PLATFORM_SDK_DIR} PATH) + if (NOT DEFINED CMAKE_DEVELOPER_ROOT) + message(FATAL_ERROR "Invalid CMAKE_DEVELOPER_ROOT: " + "${CMAKE_DEVELOPER_ROOT} does not exist.") + endif() +endif() +# Find the C & C++ compilers for the specified SDK. +if(NOT CMAKE_C_COMPILER) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang + OUTPUT_VARIABLE CMAKE_C_COMPILER + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + message(STATUS "Using C compiler: ${CMAKE_C_COMPILER}") +endif() +if(NOT CMAKE_CXX_COMPILER) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang++ + OUTPUT_VARIABLE CMAKE_CXX_COMPILER + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + message(STATUS "Using CXX compiler: ${CMAKE_CXX_COMPILER}") +endif() +# Find (Apple's) libtool. +execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find libtool + OUTPUT_VARIABLE BUILD_LIBTOOL + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +message(STATUS "Using libtool: ${BUILD_LIBTOOL}") +# Configure libtool to be used instead of ar + ranlib to build static libraries. +# This is required on Xcode 7+, but should also work on previous versions of +# Xcode. +set(CMAKE_C_CREATE_STATIC_LIBRARY + "${BUILD_LIBTOOL} -static -o ") +set(CMAKE_CXX_CREATE_STATIC_LIBRARY + "${BUILD_LIBTOOL} -static -o ") +# Find the toolchain's provided install_name_tool if none is found on the host +if(NOT CMAKE_INSTALL_NAME_TOOL) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find install_name_tool + OUTPUT_VARIABLE CMAKE_INSTALL_NAME_TOOL_INT + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + set(CMAKE_INSTALL_NAME_TOOL ${CMAKE_INSTALL_NAME_TOOL_INT} CACHE STRING "" ${FORCE_CACHE}) +endif() +# Get the version of Darwin (OS X) of the host. +execute_process(COMMAND uname -r + OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +if(SDK_NAME MATCHES "iphone") + set(CMAKE_SYSTEM_NAME iOS CACHE INTERNAL "" ${FORCE_CACHE}) +endif() +# CMake 3.14+ support building for iOS, watchOS and tvOS out of the box. +if(MODERN_CMAKE) + if(SDK_NAME MATCHES "appletv") + set(CMAKE_SYSTEM_NAME tvOS CACHE INTERNAL "" ${FORCE_CACHE}) + elseif(SDK_NAME MATCHES "watch") + set(CMAKE_SYSTEM_NAME watchOS CACHE INTERNAL "" ${FORCE_CACHE}) + endif() + # Provide flags for a combined FAT library build on newer CMake versions + if(PLATFORM_INT MATCHES ".*COMBINED") + set(CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH "NO" CACHE INTERNAL "" ${FORCE_CACHE}) + set(CMAKE_IOS_INSTALL_COMBINED YES CACHE INTERNAL "" ${FORCE_CACHE}) + message(STATUS "Will combine built (static) artifacts into FAT lib...") + endif() +elseif(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.10") + # Legacy code path prior to CMake 3.14 or fallback if no SDK_NAME specified + set(CMAKE_SYSTEM_NAME iOS CACHE INTERNAL "" ${FORCE_CACHE}) +else() + # Legacy code path prior to CMake 3.14 or fallback if no SDK_NAME specified + set(CMAKE_SYSTEM_NAME Darwin CACHE INTERNAL "" ${FORCE_CACHE}) +endif() +# Standard settings. +set(CMAKE_SYSTEM_VERSION ${SDK_VERSION} CACHE INTERNAL "") +set(UNIX TRUE CACHE BOOL "") +set(APPLE TRUE CACHE BOOL "") +set(IOS TRUE CACHE BOOL "") +set(CMAKE_AR ar CACHE FILEPATH "" FORCE) +set(CMAKE_RANLIB ranlib CACHE FILEPATH "" FORCE) +set(CMAKE_STRIP strip CACHE FILEPATH "" FORCE) +# Set the architectures for which to build. +set(CMAKE_OSX_ARCHITECTURES ${ARCHS} CACHE STRING "Build architecture for iOS") +# Change the type of target generated for try_compile() so it'll work when cross-compiling, weak compiler checks +if(ENABLE_STRICT_TRY_COMPILE_INT) + message(STATUS "Using strict compiler checks (default in CMake).") +else() + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) +endif() +# All iOS/Darwin specific settings - some may be redundant. +set(CMAKE_MACOSX_BUNDLE YES) +set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO") +set(CMAKE_SHARED_LIBRARY_PREFIX "lib") +set(CMAKE_SHARED_LIBRARY_SUFFIX ".dylib") +set(CMAKE_SHARED_MODULE_PREFIX "lib") +set(CMAKE_SHARED_MODULE_SUFFIX ".so") +set(CMAKE_C_COMPILER_ABI ELF) +set(CMAKE_CXX_COMPILER_ABI ELF) +set(CMAKE_C_HAS_ISYSROOT 1) +set(CMAKE_CXX_HAS_ISYSROOT 1) +set(CMAKE_MODULE_EXISTS 1) +set(CMAKE_DL_LIBS "") +set(CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ") +set(CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ") +set(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}") +set(CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}") + +if(ARCHS MATCHES "((^|;|, )(arm64|arm64e|x86_64))+") + set(CMAKE_C_SIZEOF_DATA_PTR 8) + set(CMAKE_CXX_SIZEOF_DATA_PTR 8) + if(ARCHS MATCHES "((^|;|, )(arm64|arm64e))+") + set(CMAKE_SYSTEM_PROCESSOR "aarch64") + else() + set(CMAKE_SYSTEM_PROCESSOR "x86_64") + endif() +else() + set(CMAKE_C_SIZEOF_DATA_PTR 4) + set(CMAKE_CXX_SIZEOF_DATA_PTR 4) + set(CMAKE_SYSTEM_PROCESSOR "arm") +endif() + +# Note that only Xcode 7+ supports the newer more specific: +# -m${SDK_NAME}-version-min flags, older versions of Xcode use: +# -m(ios/ios-simulator)-version-min instead. +if(${CMAKE_VERSION} VERSION_LESS "3.11") + if(PLATFORM_INT STREQUAL "OS" OR PLATFORM_INT STREQUAL "OS64") + if(XCODE_VERSION VERSION_LESS 7.0) + set(SDK_NAME_VERSION_FLAGS + "-mios-version-min=${DEPLOYMENT_TARGET}") + else() + # Xcode 7.0+ uses flags we can build directly from SDK_NAME. + set(SDK_NAME_VERSION_FLAGS + "-m${SDK_NAME}-version-min=${DEPLOYMENT_TARGET}") + endif() + elseif(PLATFORM_INT STREQUAL "TVOS") + set(SDK_NAME_VERSION_FLAGS + "-mtvos-version-min=${DEPLOYMENT_TARGET}") + elseif(PLATFORM_INT STREQUAL "SIMULATOR_TVOS") + set(SDK_NAME_VERSION_FLAGS + "-mtvos-simulator-version-min=${DEPLOYMENT_TARGET}") + elseif(PLATFORM_INT STREQUAL "WATCHOS") + set(SDK_NAME_VERSION_FLAGS + "-mwatchos-version-min=${DEPLOYMENT_TARGET}") + elseif(PLATFORM_INT STREQUAL "SIMULATOR_WATCHOS") + set(SDK_NAME_VERSION_FLAGS + "-mwatchos-simulator-version-min=${DEPLOYMENT_TARGET}") + else() + # SIMULATOR or SIMULATOR64 both use -mios-simulator-version-min. + set(SDK_NAME_VERSION_FLAGS + "-mios-simulator-version-min=${DEPLOYMENT_TARGET}") + endif() +else() + # Newer versions of CMake sets the version min flags correctly + set(CMAKE_OSX_DEPLOYMENT_TARGET ${DEPLOYMENT_TARGET} CACHE STRING + "Set CMake deployment target" ${FORCE_CACHE}) +endif() + +if(DEFINED APPLE_TARGET_TRIPLE_INT) + set(APPLE_TARGET_TRIPLE ${APPLE_TARGET_TRIPLE_INT} CACHE STRING + "Autoconf target triple compatible variable" ${FORCE_CACHE}) +endif() + +if(ENABLE_BITCODE_INT) + set(BITCODE "-fembed-bitcode") + set(CMAKE_XCODE_ATTRIBUTE_BITCODE_GENERATION_MODE "bitcode" CACHE INTERNAL "") + set(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE "YES" CACHE INTERNAL "") +else() + set(BITCODE "") + set(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE "NO" CACHE INTERNAL "") +endif() + +if(ENABLE_ARC_INT) + set(FOBJC_ARC "-fobjc-arc") + set(CMAKE_XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC "YES" CACHE INTERNAL "") +else() + set(FOBJC_ARC "-fno-objc-arc") + set(CMAKE_XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC "NO" CACHE INTERNAL "") +endif() + +if(NOT ENABLE_VISIBILITY_INT) + set(VISIBILITY "-fvisibility=hidden") + set(CMAKE_XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN "YES" CACHE INTERNAL "") +else() + set(VISIBILITY "") + set(CMAKE_XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN "NO" CACHE INTERNAL "") +endif() + +if(NOT IOS_TOOLCHAIN_HAS_RUN) + #Check if Xcode generator is used, since that will handle these flags automagically + if(USED_CMAKE_GENERATOR MATCHES "Xcode") + message(STATUS "Not setting any manual command-line buildflags, since Xcode is selected as generator.") + else() + set(CMAKE_C_FLAGS + "${SDK_NAME_VERSION_FLAGS} ${BITCODE} -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_C_FLAGS}") + # Hidden visibilty is required for C++ on iOS. + set(CMAKE_CXX_FLAGS + "${SDK_NAME_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} -fvisibility-inlines-hidden -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_CXX_FLAGS}") + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS} -O0 -g ${CMAKE_CXX_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS} -DNDEBUG -Os -ffast-math ${CMAKE_CXX_FLAGS_MINSIZEREL}") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS} -DNDEBUG -O2 -g -ffast-math ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -DNDEBUG -O3 -ffast-math ${CMAKE_CXX_FLAGS_RELEASE}") + set(CMAKE_C_LINK_FLAGS "${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}") + set(CMAKE_CXX_LINK_FLAGS "${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}") + set(CMAKE_ASM_FLAGS "${CFLAGS} -x assembler-with-cpp") + + # In order to ensure that the updated compiler flags are used in try_compile() + # tests, we have to forcibly set them in the CMake cache, not merely set them + # in the local scope. + set(VARS_TO_FORCE_IN_CACHE + CMAKE_C_FLAGS + CMAKE_CXX_FLAGS + CMAKE_CXX_FLAGS_DEBUG + CMAKE_CXX_FLAGS_RELWITHDEBINFO + CMAKE_CXX_FLAGS_MINSIZEREL + CMAKE_CXX_FLAGS_RELEASE + CMAKE_C_LINK_FLAGS + CMAKE_CXX_LINK_FLAGS) + foreach(VAR_TO_FORCE ${VARS_TO_FORCE_IN_CACHE}) + set(${VAR_TO_FORCE} "${${VAR_TO_FORCE}}" CACHE STRING "" ${FORCE_CACHE}) + endforeach() + endif() + + ## Print status messages to inform of the current state + message(STATUS "Configuring ${SDK_NAME} build for platform: ${PLATFORM_INT}, architecture(s): ${ARCHS}") + message(STATUS "Using SDK: ${CMAKE_OSX_SYSROOT_INT}") + if(DEFINED APPLE_TARGET_TRIPLE) + message(STATUS "Autoconf target triple: ${APPLE_TARGET_TRIPLE}") + endif() + message(STATUS "Using minimum deployment version: ${DEPLOYMENT_TARGET}" + " (SDK version: ${SDK_VERSION})") + if(MODERN_CMAKE) + message(STATUS "Merging integrated CMake 3.14+ iOS,tvOS,watchOS,macOS toolchain(s) with this toolchain!") + endif() + if(USED_CMAKE_GENERATOR MATCHES "Xcode") + message(STATUS "Using Xcode version: ${XCODE_VERSION}") + endif() + if(DEFINED SDK_NAME_VERSION_FLAGS) + message(STATUS "Using version flags: ${SDK_NAME_VERSION_FLAGS}") + endif() + message(STATUS "Using a data_ptr size of: ${CMAKE_CXX_SIZEOF_DATA_PTR}") + message(STATUS "Using install_name_tool: ${CMAKE_INSTALL_NAME_TOOL}") + if(ENABLE_BITCODE_INT) + message(STATUS "Enabling bitcode support.") + else() + message(STATUS "Disabling bitcode support.") + endif() + + if(ENABLE_ARC_INT) + message(STATUS "Enabling ARC support.") + else() + message(STATUS "Disabling ARC support.") + endif() + + if(NOT ENABLE_VISIBILITY_INT) + message(STATUS "Hiding symbols (-fvisibility=hidden).") + endif() +endif() + +set(CMAKE_PLATFORM_HAS_INSTALLNAME 1) +set(CMAKE_SHARED_LINKER_FLAGS "-rpath @executable_path/Frameworks -rpath @loader_path/Frameworks") +set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -Wl,-headerpad_max_install_names") +set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -Wl,-headerpad_max_install_names") +set(CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,") +set(CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,") +set(CMAKE_FIND_LIBRARY_SUFFIXES ".tbd" ".dylib" ".so" ".a") +set(CMAKE_SHARED_LIBRARY_SONAME_C_FLAG "-install_name") + +# Set the find root to the iOS developer roots and to user defined paths. +set(CMAKE_FIND_ROOT_PATH ${CMAKE_OSX_SYSROOT_INT} ${CMAKE_PREFIX_PATH} CACHE STRING "Root path that will be prepended + to all search paths") +# Default to searching for frameworks first. +set(CMAKE_FIND_FRAMEWORK FIRST) +# Set up the default search directories for frameworks. +set(CMAKE_FRAMEWORK_PATH + ${CMAKE_DEVELOPER_ROOT}/Library/PrivateFrameworks + ${CMAKE_OSX_SYSROOT_INT}/System/Library/Frameworks + ${CMAKE_FRAMEWORK_PATH} CACHE STRING "Frameworks search paths" ${FORCE_CACHE}) + +set(IOS_TOOLCHAIN_HAS_RUN TRUE CACHE BOOL "Has the CMake toolchain run already?" ${FORCE_CACHE}) + +# By default, search both the specified iOS SDK and the remainder of the host filesystem. +if(NOT CMAKE_FIND_ROOT_PATH_MODE_PROGRAM) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH CACHE STRING "" ${FORCE_CACHE}) +endif() +if(NOT CMAKE_FIND_ROOT_PATH_MODE_LIBRARY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH CACHE STRING "" ${FORCE_CACHE}) +endif() +if(NOT CMAKE_FIND_ROOT_PATH_MODE_INCLUDE) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH CACHE STRING "" ${FORCE_CACHE}) +endif() +if(NOT CMAKE_FIND_ROOT_PATH_MODE_PACKAGE) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH CACHE STRING "" ${FORCE_CACHE}) +endif() + +# +# Some helper-macros below to simplify and beautify the CMakeFile +# + +# This little macro lets you set any Xcode specific property. +macro(set_xcode_property TARGET XCODE_PROPERTY XCODE_VALUE XCODE_RELVERSION) + set(XCODE_RELVERSION_I "${XCODE_RELVERSION}") + if(XCODE_RELVERSION_I STREQUAL "All") + set_property(TARGET ${TARGET} PROPERTY + XCODE_ATTRIBUTE_${XCODE_PROPERTY} "${XCODE_VALUE}") + else() + set_property(TARGET ${TARGET} PROPERTY + XCODE_ATTRIBUTE_${XCODE_PROPERTY}[variant=${XCODE_RELVERSION_I}] "${XCODE_VALUE}") + endif() +endmacro(set_xcode_property) + +# This macro lets you find executable programs on the host system. +macro(find_host_package) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE NEVER) + set(IOS FALSE) + find_package(${ARGN}) + set(IOS TRUE) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH) +endmacro(find_host_package) \ No newline at end of file