# Copyright (c) 2010-2011, Ethan Rublee

# Copyright (c) 2011-2014, Andrey Kamaev

# 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.

# ------------------------------------------------------------------------------

#  Android CMake toolchain file, for use with the Android NDK r5-r10d

#  Requires cmake 2.6.3 or newer (2.8.9 or newer is recommended).

#  See home page: https://github.com/taka-no-me/android-cmake

#

#  Usage Linux:

#   $ export ANDROID_NDK=/absolute/path/to/the/android-ndk

#   $ mkdir build && cd build

#   $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake ..

#   $ make -j8

#

#  Usage Windows:

#     You need native port of make to build your project.

#     Android NDK r7 (and newer) already has make.exe on board.

#     For older NDK you have to install it separately.

#     For example, this one: http://gnuwin32.sourceforge.net/packages/make.htm

#

#   $ SET ANDROID_NDK=C:\absolute\path\to\the\android-ndk

#   $ mkdir build && cd build

#   $ cmake.exe -G"MinGW Makefiles"

#       -DCMAKE_TOOLCHAIN_FILE=path\to\the\android.toolchain.cmake

#       -DCMAKE_MAKE_PROGRAM="%ANDROID_NDK%\prebuilt\windows\bin\make.exe" ..

#   $ cmake.exe --build .

#

#

#  Options (can be set as cmake parameters: -D<option_name>=<value>):

#    ANDROID_NDK=/opt/android-ndk - path to the NDK root.

#      Can be set as environment variable. Can be set only at first cmake run.

#

#    ANDROID_ABI=armeabi-v7a - specifies the target Application Binary

#      Interface (ABI). This option nearly matches to the APP_ABI variable

#      used by ndk-build tool from Android NDK.

#

#      Possible targets are:

#        "armeabi" - ARMv5TE based CPU with software floating point operations

#        "armeabi-v7a" - ARMv7 based devices with hardware FPU instructions

#            this ABI target is used by default

#        "armeabi-v7a with NEON" - same as armeabi-v7a, but

#            sets NEON as floating-point unit

#        "armeabi-v7a with VFPV3" - same as armeabi-v7a, but

#            sets VFPV3 as floating-point unit (has 32 registers instead of 16)

#        "armeabi-v6 with VFP" - tuned for ARMv6 processors having VFP

#        "x86" - IA-32 instruction set

#        "mips" - MIPS32 instruction set

#

#      64-bit ABIs for NDK r10 and newer:

#        "arm64-v8a" - ARMv8 AArch64 instruction set

#        "x86_64" - Intel64 instruction set (r1)

#        "mips64" - MIPS64 instruction set (r6)

#

#    ANDROID_NATIVE_API_LEVEL=android-8 - level of Android API compile for.

#      Option is read-only when standalone toolchain is used.

#      Note: building for "android-L" requires explicit configuration.

#

#    ANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.9 - the name of compiler

#      toolchain to be used. The list of possible values depends on the NDK

#      version. For NDK r10c the possible values are:

#

#        * aarch64-linux-android-4.9

#        * aarch64-linux-android-clang3.4

#        * aarch64-linux-android-clang3.5

#        * arm-linux-androideabi-4.6

#        * arm-linux-androideabi-4.8

#        * arm-linux-androideabi-4.9 (default)

#        * arm-linux-androideabi-clang3.4

#        * arm-linux-androideabi-clang3.5

#        * mips64el-linux-android-4.9

#        * mips64el-linux-android-clang3.4

#        * mips64el-linux-android-clang3.5

#        * mipsel-linux-android-4.6

#        * mipsel-linux-android-4.8

#        * mipsel-linux-android-4.9

#        * mipsel-linux-android-clang3.4

#        * mipsel-linux-android-clang3.5

#        * x86-4.6

#        * x86-4.8

#        * x86-4.9

#        * x86-clang3.4

#        * x86-clang3.5

#        * x86_64-4.9

#        * x86_64-clang3.4

#        * x86_64-clang3.5

#

#    ANDROID_FORCE_ARM_BUILD=OFF - set ON to generate 32-bit ARM instructions

#      instead of Thumb. Is not available for "armeabi-v6 with VFP"

#      (is forced to be ON) ABI.

#

#    ANDROID_NO_UNDEFINED=ON - set ON to show all undefined symbols as linker

#      errors even if they are not used.

#

#    ANDROID_SO_UNDEFINED=OFF - set ON to allow undefined symbols in shared

#      libraries. Automatically turned for NDK r5x and r6x due to GLESv2

#      problems.

#

#    ANDROID_STL=gnustl_static - specify the runtime to use.

#

#      Possible values are:

#        none           -> Do not configure the runtime.

#        system         -> Use the default minimal system C++ runtime library.

#                          Implies -fno-rtti -fno-exceptions.

#                          Is not available for standalone toolchain.

#        system_re      -> Use the default minimal system C++ runtime library.

#                          Implies -frtti -fexceptions.

#                          Is not available for standalone toolchain.

#        gabi++_static  -> Use the GAbi++ runtime as a static library.

#                          Implies -frtti -fno-exceptions.

#                          Available for NDK r7 and newer.

#                          Is not available for standalone toolchain.

#        gabi++_shared  -> Use the GAbi++ runtime as a shared library.

#                          Implies -frtti -fno-exceptions.

#                          Available for NDK r7 and newer.

#                          Is not available for standalone toolchain.

#        stlport_static -> Use the STLport runtime as a static library.

#                          Implies -fno-rtti -fno-exceptions for NDK before r7.

#                          Implies -frtti -fno-exceptions for NDK r7 and newer.

#                          Is not available for standalone toolchain.

#        stlport_shared -> Use the STLport runtime as a shared library.

#                          Implies -fno-rtti -fno-exceptions for NDK before r7.

#                          Implies -frtti -fno-exceptions for NDK r7 and newer.

#                          Is not available for standalone toolchain.

#        gnustl_static  -> Use the GNU STL as a static library.

#                          Implies -frtti -fexceptions.

#        gnustl_shared  -> Use the GNU STL as a shared library.

#                          Implies -frtti -fno-exceptions.

#                          Available for NDK r7b and newer.

#                          Silently degrades to gnustl_static if not available.

#

#    ANDROID_STL_FORCE_FEATURES=ON - turn rtti and exceptions support based on

#      chosen runtime. If disabled, then the user is responsible for settings

#      these options.

#

#  What?:

#    android-cmake toolchain searches for NDK/toolchain in the following order:

#      ANDROID_NDK - cmake parameter

#      ANDROID_NDK - environment variable

#      ANDROID_STANDALONE_TOOLCHAIN - cmake parameter

#      ANDROID_STANDALONE_TOOLCHAIN - environment variable

#      ANDROID_NDK - default locations

#      ANDROID_STANDALONE_TOOLCHAIN - default locations

#

#    Make sure to do the following in your scripts:

#      SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}" )

#      SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${my_cxx_flags}" )

#    The flags will be prepopulated with critical flags, so don't loose them.

#    Also be aware that toolchain also sets configuration-specific compiler

#    flags and linker flags.

#

#    ANDROID and BUILD_ANDROID will be set to true, you may test any of these

#    variables to make necessary Android-specific configuration changes.

#

#    Also ARMEABI or ARMEABI_V7A or X86 or MIPS or ARM64_V8A or X86_64 or MIPS64

#    will be set true, mutually exclusive. NEON option will be set true

#    if VFP is set to NEON.

#

# ------------------------------------------------------------------------------

cmake_minimum_required( VERSION 2.6.3 )

if( DEFINED CMAKE_CROSSCOMPILING )

 # subsequent toolchain loading is not really needed

 return()

endif()

if( CMAKE_TOOLCHAIN_FILE )

 # touch toolchain variable to suppress "unused variable" warning

endif()

# inherit settings in recursive loads

get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )

if( _CMAKE_IN_TRY_COMPILE )

 include( "${CMAKE_CURRENT_SOURCE_DIR}/../android.toolchain.config.cmake" OPTIONAL )

endif()

# this one is important

if( CMAKE_VERSION VERSION_GREATER "3.0.99" )

 set( CMAKE_SYSTEM_NAME Android )

else()

 set( CMAKE_SYSTEM_NAME Linux )

endif()

# this one not so much

set( CMAKE_SYSTEM_VERSION 1 )

# rpath makes low sense for Android

set( CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "" )

set( CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries." )

# NDK search paths

set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r10d -r10c -r10b -r10 -r9d -r9c -r9b -r9 -r8e -r8d -r8c -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )

if( NOT DEFINED ANDROID_NDK_SEARCH_PATHS )

 if( CMAKE_HOST_WIN32 )

  file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATHS )

  set( ANDROID_NDK_SEARCH_PATHS "${ANDROID_NDK_SEARCH_PATHS}" "$ENV{SystemDrive}/NVPACK" )

 else()

  file( TO_CMAKE_PATH "$ENV{HOME}" ANDROID_NDK_SEARCH_PATHS )

  set( ANDROID_NDK_SEARCH_PATHS /opt "${ANDROID_NDK_SEARCH_PATHS}/NVPACK" )

 endif()

endif()

if( NOT DEFINED ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH )

 set( ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH /opt/android-toolchain )

endif()

# known ABIs

set( ANDROID_SUPPORTED_ABIS_arm "armeabi-v7a;armeabi;armeabi-v7a with NEON;armeabi-v7a with VFPV3;armeabi-v6 with VFP" )

set( ANDROID_SUPPORTED_ABIS_arm64 "arm64-v8a" )

set( ANDROID_SUPPORTED_ABIS_x86 "x86" )

set( ANDROID_SUPPORTED_ABIS_x86_64 "x86_64" )

set( ANDROID_SUPPORTED_ABIS_mips "mips" )

set( ANDROID_SUPPORTED_ABIS_mips64 "mips64" )

# API level defaults

set( ANDROID_DEFAULT_NDK_API_LEVEL 8 )

set( ANDROID_DEFAULT_NDK_API_LEVEL_arm64 21 )

set( ANDROID_DEFAULT_NDK_API_LEVEL_x86 9 )

set( ANDROID_DEFAULT_NDK_API_LEVEL_x86_64 21 )

set( ANDROID_DEFAULT_NDK_API_LEVEL_mips 9 )

set( ANDROID_DEFAULT_NDK_API_LEVEL_mips64 21 )

macro( __LIST_FILTER listvar regex )

  if( ${listvar} )

    foreach( __val ${${listvar}} )

      if( __val MATCHES "${regex}" )

        list( REMOVE_ITEM ${listvar} "${__val}" )

      endif()

    endforeach()

  endif()

endmacro()

macro( __INIT_VARIABLE var_name )

  set( __test_path 0 )

  foreach( __var ${ARGN} )

    if( __var STREQUAL "PATH" )

      set( __test_path 1 )

      break()

    endif()

  endforeach()

  if( __test_path AND NOT EXISTS "${${var_name}}" )

    unset( ${var_name} CACHE )

  endif()

  if( " ${${var_name}}" STREQUAL " " )

    set( __values 0 )

    foreach( __var ${ARGN} )

      if( __var STREQUAL "VALUES" )

        set( __values 1 )

      elseif( NOT __var STREQUAL "PATH" )

        if( __var MATCHES "^ENV_.*$" )

          string( REPLACE "ENV_" "" __var "${__var}" )

          set( __value "$ENV{${__var}}" )

        elseif( DEFINED ${__var} )

          set( __value "${${__var}}" )

        elseif( __values )

          set( __value "${__var}" )

        else()

          set( __value "" )

        endif()

        if( NOT " ${__value}" STREQUAL " " AND (NOT __test_path OR EXISTS "${__value}") )

          set( ${var_name} "${__value}" )

          break()

        endif()

      endif()

    endforeach()

    unset( __value )

    unset( __values )

  endif()

  if( __test_path )

    file( TO_CMAKE_PATH "${${var_name}}" ${var_name} )

  endif()

  unset( __test_path )

endmacro()

macro( __DETECT_NATIVE_API_LEVEL _var _path )

  set( __ndkApiLevelRegex "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*.*$" )

  file( STRINGS ${_path} __apiFileContent REGEX "${__ndkApiLevelRegex}" )

  if( NOT __apiFileContent )

    message( SEND_ERROR "Could not get Android native API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." )

  endif()

  string( REGEX REPLACE "${__ndkApiLevelRegex}" "\\1" ${_var} "${__apiFileContent}" )

  unset( __apiFileContent )

  unset( __ndkApiLevelRegex )

endmacro()

macro( __DETECT_TOOLCHAIN_MACHINE_NAME _var _root )

 if( EXISTS "${_root}" )

    file( GLOB __gccExePath RELATIVE "${_root}/bin/" "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" )

    __LIST_FILTER( __gccExePath "^[.].*" )

    list( LENGTH __gccExePath __gccExePathsCount )

    if( NOT __gccExePathsCount EQUAL 1  AND NOT _CMAKE_IN_TRY_COMPILE )

      message( WARNING "Could not determine machine name for compiler from ${_root}" )

      set( ${_var} "" )

    else()

      get_filename_component( __gccExeName "${__gccExePath}" NAME_WE )

      string( REPLACE "-gcc" "" ${_var} "${__gccExeName}" )

    endif()

    unset( __gccExePath )

    unset( __gccExePathsCount )

    unset( __gccExeName )

  else()

    set( ${_var} "" )

  endif()

endmacro()

# fight against cygwin

set( ANDROID_FORBID_SYGWIN TRUE CACHE BOOL "Prevent cmake from working under cygwin and using cygwin tools")

mark_as_advanced( ANDROID_FORBID_SYGWIN )

if( ANDROID_FORBID_SYGWIN )

 if( CYGWIN )

  message( FATAL_ERROR "Android NDK and android-cmake toolchain are not welcome Cygwin. It is unlikely that this cmake toolchain will work under cygwin. But if you want to try then you can set cmake variable ANDROID_FORBID_SYGWIN to FALSE and rerun cmake." )

 endif()

 if( CMAKE_HOST_WIN32 )

  # remove cygwin from PATH

  set( __new_path "$ENV{PATH}")

  __LIST_FILTER( __new_path "cygwin" )

  set(ENV{PATH} "${__new_path}")

  unset(__new_path)

 endif()

endif()

# detect current host platform

if( NOT DEFINED ANDROID_NDK_HOST_X64 AND (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64" OR CMAKE_HOST_APPLE) )

 set( ANDROID_NDK_HOST_X64 1 CACHE BOOL "Try to use 64-bit compiler toolchain" )

 mark_as_advanced( ANDROID_NDK_HOST_X64 )

endif()

set( TOOL_OS_SUFFIX "" )

if( CMAKE_HOST_APPLE )

 set( ANDROID_NDK_HOST_SYSTEM_NAME "darwin-x86_64" )

 set( ANDROID_NDK_HOST_SYSTEM_NAME2 "darwin-x86" )

elseif( CMAKE_HOST_WIN32 )

 set( ANDROID_NDK_HOST_SYSTEM_NAME "windows-x86_64" )

 set( ANDROID_NDK_HOST_SYSTEM_NAME2 "windows" )

 set( TOOL_OS_SUFFIX ".exe" )

elseif( CMAKE_HOST_UNIX )

 set( ANDROID_NDK_HOST_SYSTEM_NAME "linux-x86_64" )

 set( ANDROID_NDK_HOST_SYSTEM_NAME2 "linux-x86" )

else()

 message( FATAL_ERROR "Cross-compilation on your platform is not supported by this cmake toolchain" )

endif()

if( NOT ANDROID_NDK_HOST_X64 )

 set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} )

endif()

# see if we have path to Android NDK

if( NOT ANDROID_NDK AND NOT ANDROID_STANDALONE_TOOLCHAIN )

  __INIT_VARIABLE( ANDROID_NDK PATH ENV_ANDROID_NDK )

endif()

if( NOT ANDROID_NDK )

 # see if we have path to Android standalone toolchain

 __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ENV_ANDROID_STANDALONE_TOOLCHAIN )

 if( NOT ANDROID_STANDALONE_TOOLCHAIN )

  #try to find Android NDK in one of the the default locations

  set( __ndkSearchPaths )

  foreach( __ndkSearchPath ${ANDROID_NDK_SEARCH_PATHS} )

   foreach( suffix ${ANDROID_SUPPORTED_NDK_VERSIONS} )

    list( APPEND __ndkSearchPaths "${__ndkSearchPath}/android-ndk${suffix}" )

   endforeach()

  endforeach()

  __INIT_VARIABLE( ANDROID_NDK PATH VALUES ${__ndkSearchPaths} )

  unset( __ndkSearchPaths )

  if( ANDROID_NDK )

   message( STATUS "Using default path for Android NDK: ${ANDROID_NDK}" )

   message( STATUS "  If you prefer to use a different location, please define a cmake or environment variable: ANDROID_NDK" )

  else()

   #try to find Android standalone toolchain in one of the the default locations

   __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH )

   if( ANDROID_STANDALONE_TOOLCHAIN )

    message( STATUS "Using default path for standalone toolchain ${ANDROID_STANDALONE_TOOLCHAIN}" )

    message( STATUS "  If you prefer to use a different location, please define the variable: ANDROID_STANDALONE_TOOLCHAIN" )

   endif( ANDROID_STANDALONE_TOOLCHAIN )

  endif( ANDROID_NDK )

 endif( NOT ANDROID_STANDALONE_TOOLCHAIN )

endif( NOT ANDROID_NDK )

# remember found paths

if( ANDROID_NDK )

 get_filename_component( ANDROID_NDK "${ANDROID_NDK}" ABSOLUTE )

 set( ANDROID_NDK "${ANDROID_NDK}" CACHE INTERNAL "Path of the Android NDK" FORCE )

 set( BUILD_WITH_ANDROID_NDK True )

 if( EXISTS "${ANDROID_NDK}/RELEASE.TXT" )

  file( STRINGS "${ANDROID_NDK}/RELEASE.TXT" ANDROID_NDK_RELEASE_FULL LIMIT_COUNT 1 REGEX "r[0-9]+[a-z]?" )

  string( REGEX MATCH "r([0-9]+)([a-z]?)" ANDROID_NDK_RELEASE "${ANDROID_NDK_RELEASE_FULL}" )

 else()

  set( ANDROID_NDK_RELEASE "r1x" )

  set( ANDROID_NDK_RELEASE_FULL "unreleased" )

 endif()

 string( REGEX REPLACE "r([0-9]+)([a-z]?)" "\\1*1000" ANDROID_NDK_RELEASE_NUM "${ANDROID_NDK_RELEASE}" )

 string( FIND " abcdefghijklmnopqastuvwxyz" "${CMAKE_MATCH_2}" __ndkReleaseLetterNum )

 math( EXPR ANDROID_NDK_RELEASE_NUM "${ANDROID_NDK_RELEASE_NUM}+${__ndkReleaseLetterNum}" )

elseif( ANDROID_STANDALONE_TOOLCHAIN )

 get_filename_component( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" ABSOLUTE )

 # try to detect change

 if( CMAKE_AR )

  string( LENGTH "${ANDROID_STANDALONE_TOOLCHAIN}" __length )

  string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidStandaloneToolchainPreviousPath )

  if( NOT __androidStandaloneToolchainPreviousPath STREQUAL ANDROID_STANDALONE_TOOLCHAIN )

   message( FATAL_ERROR "It is not possible to change path to the Android standalone toolchain on subsequent run." )

  endif()

  unset( __androidStandaloneToolchainPreviousPath )

  unset( __length )

 endif()

 set( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" CACHE INTERNAL "Path of the Android standalone toolchain" FORCE )

 set( BUILD_WITH_STANDALONE_TOOLCHAIN True )

else()

 list(GET ANDROID_NDK_SEARCH_PATHS 0 ANDROID_NDK_SEARCH_PATH)

 message( FATAL_ERROR "Could not find neither Android NDK nor Android standalone toolchain.

    You should either set an environment variable:

      export ANDROID_NDK=~/my-android-ndk

    or

      export ANDROID_STANDALONE_TOOLCHAIN=~/my-android-toolchain

    or put the toolchain or NDK in the default path:

      sudo ln -s ~/my-android-ndk ${ANDROID_NDK_SEARCH_PATH}/android-ndk

      sudo ln -s ~/my-android-toolchain ${ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH}" )

endif()

# android NDK layout

if( BUILD_WITH_ANDROID_NDK )

 if( NOT DEFINED ANDROID_NDK_LAYOUT )

  # try to automatically detect the layout

  if( EXISTS "${ANDROID_NDK}/RELEASE.TXT")

   set( ANDROID_NDK_LAYOUT "RELEASE" )

  elseif( EXISTS "${ANDROID_NDK}/../../linux-x86/toolchain/" )

   set( ANDROID_NDK_LAYOUT "LINARO" )

  elseif( EXISTS "${ANDROID_NDK}/../../gcc/" )

   set( ANDROID_NDK_LAYOUT "ANDROID" )

  endif()

 endif()

 set( ANDROID_NDK_LAYOUT "${ANDROID_NDK_LAYOUT}" CACHE STRING "The inner layout of NDK" )

 mark_as_advanced( ANDROID_NDK_LAYOUT )

 if( ANDROID_NDK_LAYOUT STREQUAL "LINARO" )

  set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) # only 32-bit at the moment

  set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/../../${ANDROID_NDK_HOST_SYSTEM_NAME}/toolchain" )

  set( ANDROID_NDK_TOOLCHAINS_SUBPATH  "" )

  set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "" )

 elseif( ANDROID_NDK_LAYOUT STREQUAL "ANDROID" )

  set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) # only 32-bit at the moment

  set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/../../gcc/${ANDROID_NDK_HOST_SYSTEM_NAME}/arm" )

  set( ANDROID_NDK_TOOLCHAINS_SUBPATH  "" )

  set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "" )

 else() # ANDROID_NDK_LAYOUT STREQUAL "RELEASE"

  set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/toolchains" )

  set( ANDROID_NDK_TOOLCHAINS_SUBPATH  "/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )

  set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME2}" )

 endif()

 get_filename_component( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK_TOOLCHAINS_PATH}" ABSOLUTE )

 # try to detect change of NDK

 if( CMAKE_AR )

  string( LENGTH "${ANDROID_NDK_TOOLCHAINS_PATH}" __length )

  string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidNdkPreviousPath )

  if( NOT __androidNdkPreviousPath STREQUAL ANDROID_NDK_TOOLCHAINS_PATH )

   message( FATAL_ERROR "It is not possible to change the path to the NDK on subsequent CMake run. You must remove all generated files from your build folder first.

   " )

  endif()

  unset( __androidNdkPreviousPath )

  unset( __length )

 endif()

endif()

# get all the details about standalone toolchain

if( BUILD_WITH_STANDALONE_TOOLCHAIN )

 __DETECT_NATIVE_API_LEVEL( ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h" )

 set( ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )

 set( __availableToolchains "standalone" )

 __DETECT_TOOLCHAIN_MACHINE_NAME( __availableToolchainMachines "${ANDROID_STANDALONE_TOOLCHAIN}" )

 if( NOT __availableToolchainMachines )

  message( FATAL_ERROR "Could not determine machine name of your toolchain. Probably your Android standalone toolchain is broken." )

 endif()

 if( __availableToolchainMachines MATCHES x86_64 )

  set( __availableToolchainArchs "x86_64" )

 elseif( __availableToolchainMachines MATCHES i686 )

  set( __availableToolchainArchs "x86" )

 elseif( __availableToolchainMachines MATCHES aarch64 )

  set( __availableToolchainArchs "arm64" )

 elseif( __availableToolchainMachines MATCHES arm )

  set( __availableToolchainArchs "arm" )

 elseif( __availableToolchainMachines MATCHES mips64el )

  set( __availableToolchainArchs "mips64" )

 elseif( __availableToolchainMachines MATCHES mipsel )

  set( __availableToolchainArchs "mips" )

 endif()

 execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" -dumpversion

                  OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE )

 string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" )

 if( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/bin/clang${TOOL_OS_SUFFIX}" )

  list( APPEND __availableToolchains "standalone-clang" )

  list( APPEND __availableToolchainMachines ${__availableToolchainMachines} )

  list( APPEND __availableToolchainArchs ${__availableToolchainArchs} )

  list( APPEND __availableToolchainCompilerVersions ${__availableToolchainCompilerVersions} )

 endif()

endif()

macro( __GLOB_NDK_TOOLCHAINS __availableToolchainsVar __availableToolchainsLst __toolchain_subpath )

 foreach( __toolchain ${${__availableToolchainsLst}} )

  if( "${__toolchain}" MATCHES "-clang3[.][0-9]$" AND NOT EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/${__toolchain}${__toolchain_subpath}" )

   SET( __toolchainVersionRegex "^TOOLCHAIN_VERSION[\t ]+:=[\t ]+(.*)$" )

   FILE( STRINGS "${ANDROID_NDK_TOOLCHAINS_PATH}/${__toolchain}/setup.mk" __toolchainVersionStr REGEX "${__toolchainVersionRegex}" )

   if( __toolchainVersionStr )

    string( REGEX REPLACE "${__toolchainVersionRegex}" "\\1" __toolchainVersionStr "${__toolchainVersionStr}" )

    string( REGEX REPLACE "-clang3[.][0-9]$" "-${__toolchainVersionStr}" __gcc_toolchain "${__toolchain}" )

   else()

    string( REGEX REPLACE "-clang3[.][0-9]$" "-4.6" __gcc_toolchain "${__toolchain}" )

   endif()

   unset( __toolchainVersionStr )

   unset( __toolchainVersionRegex )

  else()

   set( __gcc_toolchain "${__toolchain}" )

  endif()

  __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK_TOOLCHAINS_PATH}/${__gcc_toolchain}${__toolchain_subpath}" )

  if( __machine )

   string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9x]+)?$" __version "${__gcc_toolchain}" )

   if( __machine MATCHES x86_64 )

    set( __arch "x86_64" )

   elseif( __machine MATCHES i686 )

    set( __arch "x86" )

   elseif( __machine MATCHES aarch64 )

    set( __arch "arm64" )

   elseif( __machine MATCHES arm )

    set( __arch "arm" )

   elseif( __machine MATCHES mips64el )

    set( __arch "mips64" )

   elseif( __machine MATCHES mipsel )

    set( __arch "mips" )

   else()

    set( __arch "" )

   endif()

   #message("machine: !${__machine}!\narch: !${__arch}!\nversion: !${__version}!\ntoolchain: !${__toolchain}!\n")

   if (__arch)

    list( APPEND __availableToolchainMachines "${__machine}" )

    list( APPEND __availableToolchainArchs "${__arch}" )

    list( APPEND __availableToolchainCompilerVersions "${__version}" )

    list( APPEND ${__availableToolchainsVar} "${__toolchain}" )

   endif()

  endif()

  unset( __gcc_toolchain )

 endforeach()

endmacro()

# get all the details about NDK

if( BUILD_WITH_ANDROID_NDK )

 file( GLOB ANDROID_SUPPORTED_NATIVE_API_LEVELS RELATIVE "${ANDROID_NDK}/platforms" "${ANDROID_NDK}/platforms/android-*" )

 string( REPLACE "android-" "" ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" )

 set( __availableToolchains "" )

 set( __availableToolchainMachines "" )

 set( __availableToolchainArchs "" )

 set( __availableToolchainCompilerVersions "" )

 if( ANDROID_TOOLCHAIN_NAME AND EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_TOOLCHAIN_NAME}/" )

  # do not go through all toolchains if we know the name

  set( __availableToolchainsLst "${ANDROID_TOOLCHAIN_NAME}" )

  __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH}" )

  if( NOT __availableToolchains AND NOT ANDROID_NDK_TOOLCHAINS_SUBPATH STREQUAL ANDROID_NDK_TOOLCHAINS_SUBPATH2 )

   __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH2}" )

   if( __availableToolchains )

    set( ANDROID_NDK_TOOLCHAINS_SUBPATH ${ANDROID_NDK_TOOLCHAINS_SUBPATH2} )

   endif()

  endif()

 endif()

 if( NOT __availableToolchains )

  file( GLOB __availableToolchainsLst RELATIVE "${ANDROID_NDK_TOOLCHAINS_PATH}" "${ANDROID_NDK_TOOLCHAINS_PATH}/*" )

  if( __availableToolchainsLst )

   list(SORT __availableToolchainsLst) # we need clang to go after gcc

  endif()

  __LIST_FILTER( __availableToolchainsLst "^[.]" )

  __LIST_FILTER( __availableToolchainsLst "llvm" )

  __LIST_FILTER( __availableToolchainsLst "renderscript" )

  __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH}" )

  if( NOT __availableToolchains AND NOT ANDROID_NDK_TOOLCHAINS_SUBPATH STREQUAL ANDROID_NDK_TOOLCHAINS_SUBPATH2 )

   __GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH2}" )

   if( __availableToolchains )

    set( ANDROID_NDK_TOOLCHAINS_SUBPATH ${ANDROID_NDK_TOOLCHAINS_SUBPATH2} )

   endif()

  endif()

 endif()

 if( NOT __availableToolchains )

  message( FATAL_ERROR "Could not find any working toolchain in the NDK. Probably your Android NDK is broken." )

 endif()

endif()

# build list of available ABIs

set( ANDROID_SUPPORTED_ABIS "" )

set( __uniqToolchainArchNames ${__availableToolchainArchs} )

list( REMOVE_DUPLICATES __uniqToolchainArchNames )

list( SORT __uniqToolchainArchNames )

foreach( __arch ${__uniqToolchainArchNames} )

 list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} )

endforeach()

unset( __uniqToolchainArchNames )

if( NOT ANDROID_SUPPORTED_ABIS )

 message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." )

endif()

# choose target ABI

__INIT_VARIABLE( ANDROID_ABI VALUES ${ANDROID_SUPPORTED_ABIS} )

# verify that target ABI is supported

list( FIND ANDROID_SUPPORTED_ABIS "${ANDROID_ABI}" __androidAbiIdx )

if( __androidAbiIdx EQUAL -1 )

 string( REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_ABIS  "${ANDROID_SUPPORTED_ABIS}" )

 message( FATAL_ERROR "Specified ANDROID_ABI = \"${ANDROID_ABI}\" is not supported by this cmake toolchain or your NDK/toolchain.

   Supported values are: \"${PRINTABLE_ANDROID_SUPPORTED_ABIS}\"

   " )

endif()

unset( __androidAbiIdx )

# set target ABI options

if( ANDROID_ABI STREQUAL "x86" )

 set( X86 true )

 set( ANDROID_NDK_ABI_NAME "x86" )

 set( ANDROID_ARCH_NAME "x86" )

 set( ANDROID_LLVM_TRIPLE "i686-none-linux-android" )

 set( CMAKE_SYSTEM_PROCESSOR "i686" )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS false )

elseif( ANDROID_ABI STREQUAL "x86_64" )

 set( X86 true )

 set( X86_64 true )

 set( ANDROID_NDK_ABI_NAME "x86_64" )

 set( ANDROID_ARCH_NAME "x86_64" )

 set( CMAKE_SYSTEM_PROCESSOR "x86_64" )

 set( ANDROID_LLVM_TRIPLE "x86_64-none-linux-android" )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS true )

elseif( ANDROID_ABI STREQUAL "mips64" )

 set( MIPS64 true )

 set( ANDROID_NDK_ABI_NAME "mips64" )

 set( ANDROID_ARCH_NAME "mips64" )

 set( ANDROID_LLVM_TRIPLE "mips64el-none-linux-android" )

 set( CMAKE_SYSTEM_PROCESSOR "mips64" )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS true )

elseif( ANDROID_ABI STREQUAL "mips" )

 set( MIPS true )

 set( ANDROID_NDK_ABI_NAME "mips" )

 set( ANDROID_ARCH_NAME "mips" )

 set( ANDROID_LLVM_TRIPLE "mipsel-none-linux-android" )

 set( CMAKE_SYSTEM_PROCESSOR "mips" )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS false )

elseif( ANDROID_ABI STREQUAL "arm64-v8a" )

 set( ARM64_V8A true )

 set( ANDROID_NDK_ABI_NAME "arm64-v8a" )

 set( ANDROID_ARCH_NAME "arm64" )

 set( ANDROID_LLVM_TRIPLE "aarch64-none-linux-android" )

 set( CMAKE_SYSTEM_PROCESSOR "aarch64" )

 set( VFPV3 true )

 set( NEON true )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS false )

elseif( ANDROID_ABI STREQUAL "armeabi" )

 set( ARMEABI true )

 set( ANDROID_NDK_ABI_NAME "armeabi" )

 set( ANDROID_ARCH_NAME "arm" )

 set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )

 set( CMAKE_SYSTEM_PROCESSOR "armv5te" )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS false )

elseif( ANDROID_ABI STREQUAL "armeabi-v6 with VFP" )

 set( ARMEABI_V6 true )

 set( ANDROID_NDK_ABI_NAME "armeabi" )

 set( ANDROID_ARCH_NAME "arm" )

 set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )

 set( CMAKE_SYSTEM_PROCESSOR "armv6" )

 # need always fallback to older platform

 set( ARMEABI true )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS false )

elseif( ANDROID_ABI STREQUAL "armeabi-v7a")

 set( ARMEABI_V7A true )

 set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )

 set( ANDROID_ARCH_NAME "arm" )

 set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )

 set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS false )

elseif( ANDROID_ABI STREQUAL "armeabi-v7a with VFPV3" )

 set( ARMEABI_V7A true )

 set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )

 set( ANDROID_ARCH_NAME "arm" )

 set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )

 set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )

 set( VFPV3 true )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS false )

elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" )

 set( ARMEABI_V7A true )

 set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )

 set( ANDROID_ARCH_NAME "arm" )

 set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )

 set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )

 set( VFPV3 true )

 set( NEON true )

 set( ANDROID_LIBRARY_USE_LIB64_PATHS false )

else()

 message( SEND_ERROR "Unknown ANDROID_ABI=\"${ANDROID_ABI}\" is specified." )

endif()

if( CMAKE_BINARY_DIR AND EXISTS "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" )

 # really dirty hack

 # it is not possible to change CMAKE_SYSTEM_PROCESSOR after the first run...

 file( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" "SET(CMAKE_SYSTEM_PROCESSOR \"${CMAKE_SYSTEM_PROCESSOR}\")\n" )

endif()

if( ANDROID_ARCH_NAME STREQUAL "arm" AND NOT ARMEABI_V6 )

 __INIT_VARIABLE( ANDROID_FORCE_ARM_BUILD VALUES OFF )

 set( ANDROID_FORCE_ARM_BUILD ${ANDROID_FORCE_ARM_BUILD} CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" FORCE )

 mark_as_advanced( ANDROID_FORCE_ARM_BUILD )

else()

 unset( ANDROID_FORCE_ARM_BUILD CACHE )

endif()

# choose toolchain

if( ANDROID_TOOLCHAIN_NAME )

 list( FIND __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" __toolchainIdx )

 if( __toolchainIdx EQUAL -1 )

  list( SORT __availableToolchains )

  string( REPLACE ";" "\n  * " toolchains_list "${__availableToolchains}" )

  set( toolchains_list "  * ${toolchains_list}")

  message( FATAL_ERROR "Specified toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing in your NDK or broken. Please verify that your NDK is working or select another compiler toolchain.

To configure the toolchain set CMake variable ANDROID_TOOLCHAIN_NAME to one of the following values:\n${toolchains_list}\n" )

 endif()

 list( GET __availableToolchainArchs ${__toolchainIdx} __toolchainArch )

 if( NOT __toolchainArch STREQUAL ANDROID_ARCH_NAME )

  message( SEND_ERROR "Selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." )

 endif()

else()

 set( __toolchainIdx -1 )

 set( __applicableToolchains "" )

 set( __toolchainMaxVersion "0.0.0" )

 list( LENGTH __availableToolchains __availableToolchainsCount )

 math( EXPR __availableToolchainsCount "${__availableToolchainsCount}-1" )

 foreach( __idx RANGE ${__availableToolchainsCount} )

  list( GET __availableToolchainArchs ${__idx} __toolchainArch )

  if( __toolchainArch STREQUAL ANDROID_ARCH_NAME )

   list( GET __availableToolchainCompilerVersions ${__idx} __toolchainVersion )

   string( REPLACE "x" "99" __toolchainVersion "${__toolchainVersion}")

   if( __toolchainVersion VERSION_GREATER __toolchainMaxVersion )

    set( __toolchainMaxVersion "${__toolchainVersion}" )

    set( __toolchainIdx ${__idx} )

   endif()

  endif()

 endforeach()

 unset( __availableToolchainsCount )

 unset( __toolchainMaxVersion )

 unset( __toolchainVersion )

endif()

unset( __toolchainArch )

if( __toolchainIdx EQUAL -1 )

 message( FATAL_ERROR "No one of available compiler toolchains is able to compile for ${ANDROID_ARCH_NAME} platform." )

endif()

list( GET __availableToolchains ${__toolchainIdx} ANDROID_TOOLCHAIN_NAME )

list( GET __availableToolchainMachines ${__toolchainIdx} ANDROID_TOOLCHAIN_MACHINE_NAME )

list( GET __availableToolchainCompilerVersions ${__toolchainIdx} ANDROID_COMPILER_VERSION )

unset( __toolchainIdx )

unset( __availableToolchains )

unset( __availableToolchainMachines )

unset( __availableToolchainArchs )

unset( __availableToolchainCompilerVersions )

# choose native API level

__INIT_VARIABLE( ANDROID_NATIVE_API_LEVEL ENV_ANDROID_NATIVE_API_LEVEL ANDROID_API_LEVEL ENV_ANDROID_API_LEVEL ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME} ANDROID_DEFAULT_NDK_API_LEVEL )

string( REPLACE "android-" "" ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" )

string( STRIP "${ANDROID_NATIVE_API_LEVEL}" ANDROID_NATIVE_API_LEVEL )

# adjust API level

set( __real_api_level ${ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME}} )

foreach( __level ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )

 if( (__level LESS ANDROID_NATIVE_API_LEVEL OR __level STREQUAL ANDROID_NATIVE_API_LEVEL) AND NOT __level LESS __real_api_level )

  set( __real_api_level ${__level} )

 endif()

endforeach()

if( __real_api_level AND NOT ANDROID_NATIVE_API_LEVEL STREQUAL __real_api_level )

 message( STATUS "Adjusting Android API level 'android-${ANDROID_NATIVE_API_LEVEL}' to 'android-${__real_api_level}'")

 set( ANDROID_NATIVE_API_LEVEL ${__real_api_level} )

endif()

unset(__real_api_level)

# validate

list( FIND ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_NATIVE_API_LEVEL}" __levelIdx )

if( __levelIdx EQUAL -1 )

 message( SEND_ERROR "Specified Android native API level 'android-${ANDROID_NATIVE_API_LEVEL}' is not supported by your NDK/toolchain." )

else()

 if( BUILD_WITH_ANDROID_NDK )

  __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" )

  if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL AND NOT __realApiLevel GREATER 9000 )

   message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." )

  endif()

  unset( __realApiLevel )

 endif()

 set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE )

 set( CMAKE_ANDROID_API ${ANDROID_NATIVE_API_LEVEL} )

 if( CMAKE_VERSION VERSION_GREATER "2.8" )

  list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS )

  set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )

 endif()

endif()

unset( __levelIdx )

# remember target ABI

set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE )

if( CMAKE_VERSION VERSION_GREATER "2.8" )

 list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME} )

 set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME}} )

endif()

# runtime choice (STL, rtti, exceptions)

if( NOT ANDROID_STL )

  set( ANDROID_STL gnustl_static )

endif()

set( ANDROID_STL "${ANDROID_STL}" CACHE STRING "C++ runtime" )

set( ANDROID_STL_FORCE_FEATURES ON CACHE BOOL "automatically configure rtti and exceptions support based on C++ runtime" )

mark_as_advanced( ANDROID_STL ANDROID_STL_FORCE_FEATURES )

if( BUILD_WITH_ANDROID_NDK )

 if( NOT "${ANDROID_STL}" MATCHES "^(none|system|system_re|gabi\\+\\+_static|gabi\\+\\+_shared|stlport_static|stlport_shared|gnustl_static|gnustl_shared)$")

  message( FATAL_ERROR "ANDROID_STL is set to invalid value \"${ANDROID_STL}\".

The possible values are:

  none           -> Do not configure the runtime.

  system         -> Use the default minimal system C++ runtime library.

  system_re      -> Same as system but with rtti and exceptions.

  gabi++_static  -> Use the GAbi++ runtime as a static library.

  gabi++_shared  -> Use the GAbi++ runtime as a shared library.

  stlport_static -> Use the STLport runtime as a static library.

  stlport_shared -> Use the STLport runtime as a shared library.

  gnustl_static  -> (default) Use the GNU STL as a static library.

  gnustl_shared  -> Use the GNU STL as a shared library.

" )

 endif()

elseif( BUILD_WITH_STANDALONE_TOOLCHAIN )

 if( NOT "${ANDROID_STL}" MATCHES "^(none|gnustl_static|gnustl_shared)$")

  message( FATAL_ERROR "ANDROID_STL is set to invalid value \"${ANDROID_STL}\".

The possible values are:

  none           -> Do not configure the runtime.

  gnustl_static  -> (default) Use the GNU STL as a static library.

  gnustl_shared  -> Use the GNU STL as a shared library.

" )

 endif()

endif()

unset( ANDROID_RTTI )

unset( ANDROID_EXCEPTIONS )

unset( ANDROID_STL_INCLUDE_DIRS )

unset( __libstl )

unset( __libsupcxx )

if( NOT _CMAKE_IN_TRY_COMPILE AND ANDROID_NDK_RELEASE STREQUAL "r7b" AND ARMEABI_V7A AND NOT VFPV3 AND ANDROID_STL MATCHES "gnustl" )

 message( WARNING  "The GNU STL armeabi-v7a binaries from NDK r7b can crash non-NEON devices. The files provided with NDK r7b were not configured properly, resulting in crashes on Tegra2-based devices and others when trying to use certain floating-point functions (e.g., cosf, sinf, expf).

You are strongly recommended to switch to another NDK release.

" )