# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file LICENSE.rst or https://cmake.org/licensing for details.


# This module is used by the Makefile generator to determine the following variables:
# CMAKE_SYSTEM_NAME - on unix this is uname -s, for windows it is Windows
# CMAKE_SYSTEM_VERSION - on unix this is uname -r, for windows it is empty
# CMAKE_SYSTEM - ${CMAKE_SYSTEM}-${CMAKE_SYSTEM_VERSION}, for windows: ${CMAKE_SYSTEM}

# find out on which system cmake runs
if(CMAKE_HOST_UNIX)
  find_program(CMAKE_UNAME NAMES uname PATHS /bin /usr/bin /usr/local/bin)
  if(CMAKE_UNAME)
    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "AIX")
      execute_process(COMMAND ${CMAKE_UNAME} -v
        OUTPUT_VARIABLE _CMAKE_HOST_SYSTEM_MAJOR_VERSION
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_QUIET)
      execute_process(COMMAND ${CMAKE_UNAME} -r
        OUTPUT_VARIABLE _CMAKE_HOST_SYSTEM_MINOR_VERSION
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_QUIET)
      set(CMAKE_HOST_SYSTEM_VERSION "${_CMAKE_HOST_SYSTEM_MAJOR_VERSION}.${_CMAKE_HOST_SYSTEM_MINOR_VERSION}")
      unset(_CMAKE_HOST_SYSTEM_MAJOR_VERSION)
      unset(_CMAKE_HOST_SYSTEM_MINOR_VERSION)
    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Android")
      execute_process(COMMAND getprop ro.build.version.sdk
        OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_QUIET)

      if(NOT DEFINED CMAKE_SYSTEM_VERSION)
        set(_ANDROID_API_LEVEL_H $ENV{PREFIX}/include/android/api-level.h)
        set(_ANDROID_API_REGEX "#define __ANDROID_API__ ([0-9]+)")
        file(READ ${_ANDROID_API_LEVEL_H} _ANDROID_API_LEVEL_H_CONTENT)
        string(REGEX MATCH ${_ANDROID_API_REGEX} _ANDROID_API_LINE "${_ANDROID_API_LEVEL_H_CONTENT}")
        string(REGEX REPLACE ${_ANDROID_API_REGEX} "\\1" _ANDROID_API "${_ANDROID_API_LINE}")
        if(_ANDROID_API)
          set(CMAKE_SYSTEM_VERSION "${_ANDROID_API}")
        endif()

        unset(_ANDROID_API_LEVEL_H)
        unset(_ANDROID_API_LEVEL_H_CONTENT)
        unset(_ANDROID_API_REGEX)
        unset(_ANDROID_API_LINE)
        unset(_ANDROID_API)
      endif()
    else()
      execute_process(COMMAND ${CMAKE_UNAME} -r
        OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_QUIET)
    endif()
    if(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux|CYGWIN.*|MSYS.*|^GNU$|Android")
      execute_process(COMMAND ${CMAKE_UNAME} -m
        OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
        RESULT_VARIABLE val
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_QUIET)
    elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
      # If we are running on Apple Silicon, honor CMAKE_APPLE_SILICON_PROCESSOR.
      if(DEFINED CMAKE_APPLE_SILICON_PROCESSOR)
        set(_CMAKE_APPLE_SILICON_PROCESSOR "${CMAKE_APPLE_SILICON_PROCESSOR}")
      elseif(DEFINED ENV{CMAKE_APPLE_SILICON_PROCESSOR})
        set(_CMAKE_APPLE_SILICON_PROCESSOR "$ENV{CMAKE_APPLE_SILICON_PROCESSOR}")
      else()
        set(_CMAKE_APPLE_SILICON_PROCESSOR "")
      endif()
      if(_CMAKE_APPLE_SILICON_PROCESSOR)
        if(";${_CMAKE_APPLE_SILICON_PROCESSOR};" MATCHES "^;(arm64|x86_64);$")
          execute_process(COMMAND sysctl -q hw.optional.arm64
            OUTPUT_VARIABLE _sysctl_stdout
            ERROR_VARIABLE _sysctl_stderr
            RESULT_VARIABLE _sysctl_result
            )
          if(NOT _sysctl_result EQUAL 0 OR NOT _sysctl_stdout MATCHES "hw.optional.arm64: 1")
            set(_CMAKE_APPLE_SILICON_PROCESSOR "")
          endif()
          unset(_sysctl_result)
          unset(_sysctl_stderr)
          unset(_sysctl_stdout)
        endif()
      endif()
      if(_CMAKE_APPLE_SILICON_PROCESSOR)
        set(CMAKE_HOST_SYSTEM_PROCESSOR "${_CMAKE_APPLE_SILICON_PROCESSOR}")
      else()
        execute_process(COMMAND ${CMAKE_UNAME} -m
          OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
          RESULT_VARIABLE val
          OUTPUT_STRIP_TRAILING_WHITESPACE
          ERROR_QUIET)
      endif()
      unset(_CMAKE_APPLE_SILICON_PROCESSOR)
      if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "Power Macintosh")
        # OS X ppc 'uname -m' may report 'Power Macintosh' instead of 'powerpc'
        set(CMAKE_HOST_SYSTEM_PROCESSOR "powerpc")
      endif()
    elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "OpenBSD")
      execute_process(COMMAND arch -s
        OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
        RESULT_VARIABLE val
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_QUIET)
    else()
      execute_process(COMMAND ${CMAKE_UNAME} -p
        OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
        RESULT_VARIABLE val
        OUTPUT_STRIP_TRAILING_WHITESPACE
        ERROR_QUIET)
      if("${val}" GREATER 0)
        execute_process(COMMAND ${CMAKE_UNAME} -m
          OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
          RESULT_VARIABLE val
          OUTPUT_STRIP_TRAILING_WHITESPACE
          ERROR_QUIET)
      endif()
    endif()
    # check the return of the last uname -m or -p
    if("${val}" GREATER 0)
        set(CMAKE_HOST_SYSTEM_PROCESSOR "unknown")
    endif()
    set(CMAKE_UNAME ${CMAKE_UNAME} CACHE INTERNAL "uname command")
    # processor may have double quote in the name, and that needs to be removed
    string(REPLACE "\"" "" CMAKE_HOST_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
    string(REPLACE "/" "_" CMAKE_HOST_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
  endif()
else()
  if(CMAKE_HOST_WIN32)
    if (DEFINED ENV{PROCESSOR_ARCHITEW6432})
      set (CMAKE_HOST_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITEW6432}")
    else()
      set (CMAKE_HOST_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}")
    endif()
  endif()
endif()

# if a toolchain file is used, the user wants to cross compile.
# in this case read the toolchain file and keep the CMAKE_HOST_SYSTEM_*
# variables around so they can be used in CMakeLists.txt.
# In all other cases, the host and target platform are the same.
if(CMAKE_TOOLCHAIN_FILE)
  if(IS_ABSOLUTE "${CMAKE_TOOLCHAIN_FILE}" AND EXISTS "${CMAKE_TOOLCHAIN_FILE}")
    # Normalize the absolute path.
    set(CMAKE_TOOLCHAIN_FILE "${CMAKE_TOOLCHAIN_FILE}" CACHE FILEPATH "The CMake toolchain file" FORCE)
    set(CMAKE_TOOLCHAIN_FILE "$CACHE{CMAKE_TOOLCHAIN_FILE}")
    include("${CMAKE_TOOLCHAIN_FILE}" OPTIONAL RESULT_VARIABLE _INCLUDED_TOOLCHAIN_FILE)
  else()
    # at first try to load it as path relative to the directory from which cmake has been run
    include("${CMAKE_BINARY_DIR}/${CMAKE_TOOLCHAIN_FILE}" OPTIONAL RESULT_VARIABLE _INCLUDED_TOOLCHAIN_FILE)
    if(NOT _INCLUDED_TOOLCHAIN_FILE)
      # if the file isn't found there, check the default locations
      include("${CMAKE_TOOLCHAIN_FILE}" OPTIONAL RESULT_VARIABLE _INCLUDED_TOOLCHAIN_FILE)
    endif()
    if(_INCLUDED_TOOLCHAIN_FILE)
      set(CMAKE_TOOLCHAIN_FILE "${_INCLUDED_TOOLCHAIN_FILE}" CACHE FILEPATH "The CMake toolchain file" FORCE)
    endif()
  endif()
  if(NOT _INCLUDED_TOOLCHAIN_FILE)
    message(FATAL_ERROR "Could not find toolchain file:\n \"${CMAKE_TOOLCHAIN_FILE}\"")
  endif()
endif()

if(CMAKE_SYSTEM_NAME)
  # CMAKE_SYSTEM_NAME was set by a toolchain file or on the command line.
  # Assume it set CMAKE_SYSTEM_VERSION and CMAKE_SYSTEM_PROCESSOR too.
  if(NOT DEFINED CMAKE_CROSSCOMPILING)
    set(CMAKE_CROSSCOMPILING TRUE)
  endif()
elseif(CMAKE_VS_WINCE_VERSION)
  set(CMAKE_SYSTEM_NAME      "WindowsCE")
  set(CMAKE_SYSTEM_VERSION   "${CMAKE_VS_WINCE_VERSION}")
  set(CMAKE_SYSTEM_PROCESSOR "${MSVC_C_ARCHITECTURE_ID}")
  set(CMAKE_CROSSCOMPILING TRUE)
else()
  # Build for the host platform and architecture by default.
  set(CMAKE_SYSTEM_NAME      "${CMAKE_HOST_SYSTEM_NAME}")
  if(NOT DEFINED CMAKE_SYSTEM_VERSION)
    set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}")
  endif()
  set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
  if(CMAKE_CROSSCOMPILING)
    message(AUTHOR_WARNING
      "CMAKE_CROSSCOMPILING has been set by the project, toolchain file, or user.  "
      "CMake is resetting it to false because CMAKE_SYSTEM_NAME was not set.  "
      "To indicate cross compilation, only CMAKE_SYSTEM_NAME needs to be set."
      )
  endif()
  set(CMAKE_CROSSCOMPILING FALSE)
endif()

include(Platform/${CMAKE_SYSTEM_NAME}-Determine OPTIONAL)

set(CMAKE_SYSTEM ${CMAKE_SYSTEM_NAME})
if(CMAKE_SYSTEM_VERSION)
  string(APPEND CMAKE_SYSTEM -${CMAKE_SYSTEM_VERSION})
endif()
set(CMAKE_HOST_SYSTEM ${CMAKE_HOST_SYSTEM_NAME})
if(CMAKE_HOST_SYSTEM_VERSION)
  string(APPEND CMAKE_HOST_SYSTEM -${CMAKE_HOST_SYSTEM_VERSION})
endif()

# this file is also executed from cpack, then we don't need to generate these files
# in this case there is no CMAKE_BINARY_DIR
if(CMAKE_BINARY_DIR)
  # write entry to the log file
  if(CMAKE_CROSSCOMPILING)
    message(CONFIGURE_LOG
      "The target system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n"
      "The host system is: ${CMAKE_HOST_SYSTEM_NAME} - ${CMAKE_HOST_SYSTEM_VERSION} - ${CMAKE_HOST_SYSTEM_PROCESSOR}\n"
      )
  else()
    message(CONFIGURE_LOG
      "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n"
      )
  endif()

  # if a toolchain file is used, it needs to be included in the configured file,
  # so settings done there are also available if they don't go in the cache and in try_compile()
  set(INCLUDE_CMAKE_TOOLCHAIN_FILE_IF_REQUIRED)
  if(CMAKE_TOOLCHAIN_FILE)
    set(INCLUDE_CMAKE_TOOLCHAIN_FILE_IF_REQUIRED "include(\"${CMAKE_TOOLCHAIN_FILE}\")")
  endif()

  # configure variables set in this file for fast reload, the template file is defined at the top of this file
  configure_file(${CMAKE_ROOT}/Modules/CMakeSystem.cmake.in
                ${CMAKE_PLATFORM_INFO_DIR}/CMakeSystem.cmake
                @ONLY)

endif()