1 # ----------------------------------------------------------------------------
2 # Android CMake toolchain file, for use with the ndk r5,r6
3 # See home page: http://code.google.com/p/android-cmake/
6 # $ export ANDROID_NDK=/<absolute path to NDK>
7 # $ cmake -DCMAKE_TOOLCHAIN_FILE=<path to this file>/android.toolchain.cmake ..
10 # Usage Linux (using standalone toolchain):
11 # $ export ANDROID_NDK_TOOLCHAIN_ROOT=/<absolute path to standalone toolchain>
12 # $ cmake -DCMAKE_TOOLCHAIN_FILE=<path to this file>/android.toolchain.cmake ..
16 # You need native port of make to build your project.
17 # For example this one: http://gnuwin32.sourceforge.net/packages/make.htm
19 # $ SET ANDROID_NDK=C:\<absolute path to NDK>\android-ndk-r6
20 # $ cmake.exe -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=<path to this file>\android.toolchain.cmake -DCMAKE_MAKE_PROGRAM=C:\<absolute path to make>\make.exe ..
21 # $ C:\<absolute path to make>\make.exe
24 # Toolchain options (can be set as cmake parameters: -D<option_name>=<value>):
25 # ANDROID_NDK=/opt/android-ndk-r6 - path to NDK root.
26 # Can be set as environment variable.
28 # ANDROID_NDK_TOOLCHAIN_ROOT=/opt/android-toolchain - path to standalone toolchain.
29 # Option is not used if full NDK is found. Can be set as environment variable.
31 # ANDROID_API_LEVEL=android-8 - level of android API to use.
32 # Option is ignored when build uses stanalone toolchain.
34 # ARM_TARGET=armeabi-v7a - type of floating point support.
35 # Other possible values are: "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3"
37 # FORCE_ARM=false - set true to generate 32-bit ARM instructions instead of Thumb-1.
39 # NO_UNDEFINED=true - set true to show all undefined symbols will as linker errors even if they are not used.
42 # Toolcahin will search for NDK/toolchain in following order:
43 # ANDROID_NDK - cmake parameter
44 # ANDROID_NDK - environment variable
45 # ANDROID_NDK - default location
46 # ANDROID_NDK_TOOLCHAIN_ROOT - cmake parameter
47 # ANDROID_NDK_TOOLCHAIN_ROOT - environment variable
48 # ANDROID_NDK_TOOLCHAIN_ROOT - default location
52 # Make sure to do the following in your scripts:
53 # SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}")
54 # SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${my_cxx_flags}")
55 # The flags will be prepopulated with critical flags, so don't loose them.
57 # ANDROID and BUILD_ANDROID will be set to true, you may test these
58 # variables to make necessary changes.
60 # Also ARMEABI and ARMEABI_V7A will be set true, mutually exclusive. V7A is
61 # for floating point. NEON option will be set true if fpu is set to neon.
63 # LIBRARY_OUTPUT_PATH_ROOT should be set in cache to determine where android
64 # libraries will be installed.
65 # default is ${CMAKE_SOURCE_DIR} , and the android libs will always be
66 # under ${LIBRARY_OUTPUT_PATH_ROOT}/libs/armeabi* depending on target.
67 # this will be convenient for android linking
69 # Base system is Linux, but you may need to change things
70 # for android compatibility.
73 # - initial version December 2010 Ethan Rublee ethan.ruble@gmail.com
74 # - modified April 2011 Andrey Kamaev andrey.kamaev@itseez.com
75 # [+] added possibility to build with NDK (without standalone toolchain)
76 # [+] support croos compilation on Windows (native, no cygwin support)
77 # [+] added compiler option to force "char" type to be signed
78 # [+] added toolchain option to compile to 32-bit ARM instructions
79 # [+] added toolchain option to disable SWIG search
80 # [+] added platform "armeabi-v7a with VFPV3"
81 # [~] ARM_TARGETS renamed to ARM_TARGET
82 # - modified April 2011 Andrey Kamaev andrey.kamaev@itseez.com
83 # [+] EXECUTABLE_OUTPUT_PATH is set by toolchain (required on Windows)
84 # [~] Fixed bug with ANDROID_API_LEVEL variable
85 # [~] turn off SWIG search if it is not found first time
86 # - modified May 2011 Andrey Kamaev andrey.kamaev@itseez.com
87 # [~] ANDROID_LEVEL is renamed to ANDROID_API_LEVEL
88 # [+] ANDROID_API_LEVEL is detected by toolchain if not specified
89 # [~] added guard to prevent changing of output directories on first cmake pass
90 # [~] toolchain exits with error if ARM_TARGET is not recognized
91 # - modified June 2011 Andrey Kamaev andrey.kamaev@itseez.com
92 # [~] default NDK path is updated for version r5c
93 # [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET
94 # [~] toolchain install directory is added to linker paths
95 # [-] removed SWIG-related stuff from toolchain
96 # [+] added macro find_host_package, find_host_program to search packages/programs on host system
97 # [~] fixed path to STL library
98 # - modified July 2011 Andrey Kamaev andrey.kamaev@itseez.com
99 # [~] fixed options caching
100 # [~] search for all supported NDK versions
101 # [~] allowed spaces in NDK path
102 # ----------------------------------------------------------------------------
104 # this one is important
105 set( CMAKE_SYSTEM_NAME Linux )
106 #this one not so much
107 set( CMAKE_SYSTEM_VERSION 1 )
109 set( ANDROID_NDK_DEFAULT_SEARCH_PATH /opt/android-ndk )
110 set( ANDROID_NDK_SUPPORTED_VERSIONS -r6 -r5c -r5b -r5 "")
111 set( ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH /opt/android-toolchain )
112 set( TOOL_OS_SUFFIX "" )
114 macro( __TOOLCHAIN_DETECT_API_LEVEL _path )
115 SET( _expected ${ARGV1} )
116 if( NOT EXISTS ${_path} )
117 message( FATAL_ERROR "Could not verify Android API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." )
119 SET( API_LEVEL_REGEX "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*$" )
120 FILE( STRINGS ${_path} API_FILE_CONTENT REGEX "${API_LEVEL_REGEX}")
121 if( NOT API_FILE_CONTENT )
122 message( FATAL_ERROR "Could not verify Android API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." )
124 string( REGEX REPLACE "${API_LEVEL_REGEX}" "\\1" ANDROID_LEVEL_FOUND "${API_FILE_CONTENT}" )
125 if( DEFINED _expected )
126 if( NOT ${ANDROID_LEVEL_FOUND} EQUAL ${_expected} )
127 message( FATAL_ERROR "Specified Android API level does not match level found. Probably your copy of NDK/toolchain is broken." )
130 set( ANDROID_API_LEVEL ${ANDROID_LEVEL_FOUND} CACHE STRING "android API level" FORCE )
133 if( NOT DEFINED ANDROID_NDK )
134 set( ANDROID_NDK $ENV{ANDROID_NDK} )
137 if( NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT )
138 set( ANDROID_NDK_TOOLCHAIN_ROOT $ENV{ANDROID_NDK_TOOLCHAIN_ROOT} )
141 #set path for android NDK -- look
142 if( NOT EXISTS "${ANDROID_NDK}" AND NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT )
143 foreach(ndk_version ${ANDROID_NDK_SUPPORTED_VERSIONS})
144 if( EXISTS ${ANDROID_NDK_DEFAULT_SEARCH_PATH}${ndk_version} )
145 set ( ANDROID_NDK ${ANDROID_NDK_DEFAULT_SEARCH_PATH}${ndk_version} )
146 message( STATUS "Using default path for android NDK ${ANDROID_NDK}" )
147 message( STATUS " If you prefer to use a different location, please define the variable: ANDROID_NDK" )
153 if( EXISTS "${ANDROID_NDK}" )
154 set( ANDROID_NDK "${ANDROID_NDK}" CACHE PATH "root of the android ndk" FORCE )
157 set( NDKSYSTEM "darwin-x86" )
159 set( NDKSYSTEM "windows" )
160 set( TOOL_OS_SUFFIX ".exe" )
162 set( NDKSYSTEM "linux-x86" )
164 message( FATAL_ERROR "Your platform is not supported" )
167 set( ANDROID_API_LEVEL $ENV{ANDROID_API_LEVEL} )
168 string( REGEX REPLACE "[\t ]*android-([0-9]+)[\t ]*" "\\1" ANDROID_API_LEVEL "${ANDROID_API_LEVEL}" )
169 string( REGEX REPLACE "[\t ]*([0-9]+)[\t ]*" "\\1" ANDROID_API_LEVEL "${ANDROID_API_LEVEL}" )
171 set( PossibleAndroidLevels "3;4;5;8;9" )
172 set( ANDROID_API_LEVEL ${ANDROID_API_LEVEL} CACHE STRING "android API level" )
173 set_property( CACHE ANDROID_API_LEVEL PROPERTY STRINGS ${PossibleAndroidLevels} )
175 if( NOT ANDROID_API_LEVEL GREATER 2 )
176 set( ANDROID_API_LEVEL 8)
177 message( STATUS "Using default android API level android-${ANDROID_API_LEVEL}" )
178 message( STATUS " If you prefer to use a different API level, please define the variable: ANDROID_API_LEVEL" )
181 set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/arm-linux-androideabi-4.4.3/prebuilt/${NDKSYSTEM}" )
182 set( ANDROID_NDK_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_API_LEVEL}/arch-arm" )
184 __TOOLCHAIN_DETECT_API_LEVEL( "${ANDROID_NDK_SYSROOT}/usr/include/android/api-level.h" ${ANDROID_API_LEVEL} )
186 #message( STATUS "Using android NDK from ${ANDROID_NDK}" )
187 set( BUILD_WITH_ANDROID_NDK True )
189 #try to find toolchain
190 if( NOT EXISTS "${ANDROID_NDK_TOOLCHAIN_ROOT}" )
191 set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH}" )
192 message( STATUS "Using default path for toolchain ${ANDROID_NDK_TOOLCHAIN_ROOT}" )
193 message( STATUS " If you prefer to use a different location, please define the variable: ANDROID_NDK_TOOLCHAIN_ROOT" )
196 set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAIN_ROOT}" CACHE PATH "root of the Android NDK standalone toolchain" FORCE )
197 set( ANDROID_NDK_SYSROOT "${ANDROID_NDK_TOOLCHAIN_ROOT}/sysroot" )
199 if( NOT EXISTS "${ANDROID_NDK_TOOLCHAIN_ROOT}" )
200 message( FATAL_ERROR "neither ${ANDROID_NDK} nor ${ANDROID_NDK_TOOLCHAIN_ROOT} does not exist!
201 You should either set an environment variable:
202 export ANDROID_NDK=~/my-android-ndk
204 export ANDROID_NDK_TOOLCHAIN_ROOT=~/my-android-toolchain
205 or put the toolchain or NDK in the default path:
206 sudo ln -s ~/my-android-ndk ${ANDROID_NDK_DEFAULT_SEARCH_PATH}
207 sudo ln -s ~/my-android-toolchain ${ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH}" )
210 __TOOLCHAIN_DETECT_API_LEVEL( "${ANDROID_NDK_SYSROOT}/usr/include/android/api-level.h" )
212 #message( STATUS "Using android NDK standalone toolchain from ${ANDROID_NDK_TOOLCHAIN_ROOT}" )
213 set( BUILD_WITH_ANDROID_NDK_TOOLCHAIN True )
216 # specify the cross compiler
217 set( CMAKE_C_COMPILER "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-gcc${TOOL_OS_SUFFIX}" CACHE PATH "gcc" FORCE )
218 set( CMAKE_CXX_COMPILER "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-g++${TOOL_OS_SUFFIX}" CACHE PATH "g++" FORCE )
219 #there may be a way to make cmake deduce these TODO deduce the rest of the tools
220 set( CMAKE_AR "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ar${TOOL_OS_SUFFIX}" CACHE PATH "archive" FORCE )
221 set( CMAKE_LINKER "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ld${TOOL_OS_SUFFIX}" CACHE PATH "linker" FORCE )
222 set( CMAKE_NM "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-nm${TOOL_OS_SUFFIX}" CACHE PATH "nm" FORCE )
223 set( CMAKE_OBJCOPY "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objcopy${TOOL_OS_SUFFIX}" CACHE PATH "objcopy" FORCE )
224 set( CMAKE_OBJDUMP "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objdump${TOOL_OS_SUFFIX}" CACHE PATH "objdump" FORCE )
225 set( CMAKE_STRIP "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-strip${TOOL_OS_SUFFIX}" CACHE PATH "strip" FORCE )
226 set( CMAKE_RANLIB "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ranlib${TOOL_OS_SUFFIX}" CACHE PATH "ranlib" FORCE )
228 #setup build targets, mutually exclusive
229 set( PossibleArmTargets "armeabi;armeabi-v7a;armeabi-v7a with NEON;armeabi-v7a with VFPV3" )
230 #compatibility junk for previous version of toolchain
231 if( DEFINED ARM_TARGETS AND NOT DEFINED ARM_TARGET )
232 set( ARM_TARGET "${ARM_TARGETS}" )
235 set( ARM_TARGET armeabi-v7a )
237 set( ARM_TARGET "${ARM_TARGET}" CACHE INTERNAL "the arm target for android, recommend armeabi-v7a for floating point support and NEON." )
238 set_property( CACHE ARM_TARGET PROPERTY STRINGS ${PossibleArmTargets} )
240 #set these flags for client use
241 if( ARM_TARGET STREQUAL "armeabi" )
243 set( ARMEABI_NDK_NAME "armeabi" )
245 set( CMAKE_SYSTEM_PROCESSOR "armv5te" )
247 if( ARM_TARGET STREQUAL "armeabi-v7a with NEON" )
250 elseif( ARM_TARGET STREQUAL "armeabi-v7a with VFPV3" )
252 elseif( NOT ARM_TARGET STREQUAL "armeabi-v7a")
253 message( FATAL_ERROR "Unsupported ARM_TARGET=${ARM_TARGET} is specified.
254 Supported values are: \"armeabi\", \"armeabi-v7a\", \"armeabi-v7a with NEON\", \"armeabi-v7a with VFPV3\"
257 set( ARMEABI_V7A true )
258 set( ARMEABI_NDK_NAME "armeabi-v7a" )
259 set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
262 #setup output directories
263 set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
265 SET( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS OFF CACHE BOOL "")
266 if( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS )
267 if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
268 set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ARMEABI_NDK_NAME}" CACHE PATH "Output directory for applications")
270 set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications")
272 set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ARMEABI_NDK_NAME}" CACHE PATH "path for android libs")
273 set( CMAKE_INSTALL_PREFIX "${ANDROID_NDK_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
275 SET( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS ON CACHE INTERNAL "" FORCE)
277 # where is the target environment
278 set( CMAKE_FIND_ROOT_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin" "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi" "${ANDROID_NDK_SYSROOT}" "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_PREFIX}/share" )
280 if( BUILD_WITH_ANDROID_NDK )
281 set( STL_PATH "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++" )
282 set( STL_LIBRARIES_PATH "${STL_PATH}/libs/${ARMEABI_NDK_NAME}" )
283 include_directories(SYSTEM "${STL_PATH}/include" "${STL_LIBRARIES_PATH}/include" )
284 # if ( NOT ARMEABI AND NOT FORCE_ARM )
285 # set( STL_LIBRARIES_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" )
289 if( BUILD_WITH_ANDROID_NDK_TOOLCHAIN )
290 set( STL_LIBRARIES_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/lib" )
292 set( STL_LIBRARIES_PATH "${STL_LIBRARIES_PATH}/${CMAKE_SYSTEM_PROCESSOR}" )
295 set( STL_LIBRARIES_PATH "${STL_LIBRARIES_PATH}/thumb" )
297 #for some reason this is needed? TODO figure out why...
298 include_directories(SYSTEM "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/include/c++/4.4.3/arm-linux-androideabi" )
301 # only search for libraries and includes in the ndk toolchain
302 set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
303 set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
304 set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
306 set( CMAKE_CXX_FLAGS "-fPIC -DANDROID -Wno-psabi -fsigned-char" )
307 set( CMAKE_C_FLAGS "-fPIC -DANDROID -Wno-psabi -fsigned-char" )
309 set( FORCE_ARM OFF CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" )
311 #It is recommended to use the -mthumb compiler flag to force the generation
312 #of 16-bit Thumb-1 instructions (the default being 32-bit ARM ones).
313 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mthumb" )
314 set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mthumb" )
316 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -marm" )
317 set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -marm" )
320 if( BUILD_WITH_ANDROID_NDK )
321 set( CMAKE_CXX_FLAGS "--sysroot=\"${ANDROID_NDK_SYSROOT}\" ${CMAKE_CXX_FLAGS}" )
322 set( CMAKE_C_FLAGS "--sysroot=\"${ANDROID_NDK_SYSROOT}\" ${CMAKE_C_FLAGS}" )
324 # workaround for ugly cmake bug - compiler identification replaces all spaces (and somethimes " !!!) in compiler flags with ; symbol
325 # as result identification fails if ANDROID_NDK_SYSROOT contain spaces
326 include(CMakeForceCompiler)
327 CMAKE_FORCE_C_COMPILER("${CMAKE_C_COMPILER}" GNU)
328 CMAKE_FORCE_CXX_COMPILER("${CMAKE_CXX_COMPILER}" GNU)
332 #these are required flags for android armv7-a
333 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv7-a -mfloat-abi=softfp" )
334 set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a -mfloat-abi=softfp" )
336 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon" )
337 set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon" )
339 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=vfpv3" )
340 set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=vfpv3" )
344 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags" )
345 set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags" )
347 #-Wl,-L${LIBCPP_LINK_DIR},-lstdc++,-lsupc++
348 #-L${LIBCPP_LINK_DIR} -lstdc++ -lsupc++
349 #Also, this is *required* to use the following linker flags that routes around
350 #a CPU bug in some Cortex-A8 implementations:
351 set( LINKER_FLAGS "-Wl,--fix-cortex-a8 -L\"${STL_LIBRARIES_PATH}\" -L\"${CMAKE_INSTALL_PREFIX}/libs/${ARMEABI_NDK_NAME}\" -lstdc++ -lsupc++ " )
353 set( NO_UNDEFINED ON CACHE BOOL "Don't all undefined symbols" )
355 set( LINKER_FLAGS "-Wl,--no-undefined ${LINKER_FLAGS}" )
358 set( CMAKE_SHARED_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE )
359 set( CMAKE_MODULE_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE )
360 set( CMAKE_EXE_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE )
362 #set these global flags for cmake client scripts to change behavior
364 set( BUILD_ANDROID True )
366 #macro to find packages on the host OS
367 macro(find_host_package)
368 set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
369 set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER )
370 set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER )
371 if( CMAKE_HOST_WIN32 )
374 elseif( CMAKE_HOST_APPLE )
378 find_package( ${ARGN} )
382 set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
383 set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
384 set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
386 #macro to find programs on the host OS
387 macro(find_host_program)
388 set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
389 set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER )
390 set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER )
391 if( CMAKE_HOST_WIN32 )
394 elseif( CMAKE_HOST_APPLE )
398 find_program( ${ARGN} )
402 set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
403 set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
404 set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
407 MARK_AS_ADVANCED(FORCE_ARM NO_UNDEFINED)