Deukhoofd/Angelscript
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Deukhoofd
2021-04-12 20:25:02 +02:00
commit 3d7202a915
806 changed files with 194211 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
angelscript/projects/cmake/Angelscript/AngelscriptConfig.cmake Normal file
View File

@@ -0,0 +1,2 @@
include("${CMAKE_CURRENT_LIST_DIR}/AngelscriptTargets.cmake")

37
angelscript/projects/cmake/Angelscript/AngelscriptConfigVersion.cmake Normal file
View File

@@ -0,0 +1,37 @@
# This is a basic version file for the Config-mode of find_package().
# It is used by write_basic_package_version_file() as input file for configure_file()
# to create a version-file which can be installed along a config.cmake file.
#
# The created file sets PACKAGE_VERSION_EXACT if the current version string and
# the requested version string are exactly the same and it sets
# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version.
# The variable CVF_VERSION must be set before calling configure_file().
set(PACKAGE_VERSION "2.34.0")
if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
set(PACKAGE_VERSION_COMPATIBLE FALSE)
else()
set(PACKAGE_VERSION_COMPATIBLE TRUE)
if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
set(PACKAGE_VERSION_EXACT TRUE)
endif()
endif()
# if the installed project requested no architecture check, don't perform the check
if("FALSE")
return()
endif()
# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
return()
endif()
# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
math(EXPR installedBits "8 * 8")
set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
set(PACKAGE_VERSION_UNSUITABLE TRUE)
endif()

63
angelscript/projects/cmake/Angelscript/AngelscriptTargets.cmake Normal file
View File

@@ -0,0 +1,63 @@
# Generated by CMake
if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5)
message(FATAL_ERROR "CMake >= 2.6.0 required")
endif()
cmake_policy(PUSH)
cmake_policy(VERSION 2.6)
#----------------------------------------------------------------
# Generated CMake target import file.
#----------------------------------------------------------------
# Commands may need to know the format version.
set(CMAKE_IMPORT_FILE_VERSION 1)
# Protect against multiple inclusion, which would fail when already imported targets are added once more.
set(_targetsDefined)
set(_targetsNotDefined)
set(_expectedTargets)
foreach(_expectedTarget Angelscript::angelscript)
list(APPEND _expectedTargets ${_expectedTarget})
if(NOT TARGET ${_expectedTarget})
list(APPEND _targetsNotDefined ${_expectedTarget})
endif()
if(TARGET ${_expectedTarget})
list(APPEND _targetsDefined ${_expectedTarget})
endif()
endforeach()
if("${_targetsDefined}" STREQUAL "${_expectedTargets}")
unset(_targetsDefined)
unset(_targetsNotDefined)
unset(_expectedTargets)
set(CMAKE_IMPORT_FILE_VERSION)
cmake_policy(POP)
return()
endif()
if(NOT "${_targetsDefined}" STREQUAL "")
message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n")
endif()
unset(_targetsDefined)
unset(_targetsNotDefined)
unset(_expectedTargets)
# Create imported target Angelscript::angelscript
add_library(Angelscript::angelscript STATIC IMPORTED)
set_target_properties(Angelscript::angelscript PROPERTIES
INTERFACE_LINK_LIBRARIES "Threads::Threads"
)
# Import target "Angelscript::angelscript" for configuration "Debug"
set_property(TARGET Angelscript::angelscript APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
set_target_properties(Angelscript::angelscript PROPERTIES
IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX"
IMPORTED_LOCATION_DEBUG "/home/nathan/Projects/Angelscript/angelscript/projects/cmake/libangelscript.a"
)
# This file does not depend on other imported targets which have
# been exported from the same project but in a separate export set.
# Commands beyond this point should not need to know the version.
set(CMAKE_IMPORT_FILE_VERSION)
cmake_policy(POP)

239
angelscript/projects/cmake/CMakeLists.txt Normal file
View File

@@ -0,0 +1,239 @@
cmake_minimum_required(VERSION 3.16)
include(CheckIPOSupported)
project(angelscript)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
option(BUILD_SHARED_LIBS "Build shared library" OFF)
option(LINK_STD_STATICALLY "Build shared library" OFF)
option(AS_NO_EXCEPTIONS "Disable exception handling in script context" OFF)
if(MSVC)
option(MSVC_COMPILE_FLAGS "Compiler flags to use with MSVC" "/MP")
endif()
if(APPLE)
option(BUILD_FRAMEWORK "Build Framework bundle for OSX" OFF)
endif()
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
add_link_options(-fuse-ld=lld)
endif ()
file(READ ../../include/angelscript.h ANGELSCRIPT_H)
string(REGEX MATCH "#define ANGELSCRIPT_VERSION_STRING \"([0-9]*).([0-9]*).([0-9]*)" ANGELSCRIPT_VERSION_REGEX ${ANGELSCRIPT_H})
set(ANGELSCRIPT_VERSION_MAJOR ${CMAKE_MATCH_1})
set(ANGELSCRIPT_VERSION_MINOR ${CMAKE_MATCH_2})
set(ANGELSCRIPT_VERSION_PATCH ${CMAKE_MATCH_3})
set(PROJECT_VERSION ${ANGELSCRIPT_VERSION_MAJOR}.${ANGELSCRIPT_VERSION_MINOR}.${ANGELSCRIPT_VERSION_PATCH})
message(STATUS "Configuring angelscript ${PROJECT_VERSION}")
set(ANGELSCRIPT_HEADERS
../../include/angelscript.h
../../source/as_array.h
../../source/as_builder.h
../../source/as_bytecode.h
../../source/as_callfunc.h
../../source/as_compiler.h
../../source/as_config.h
../../source/as_configgroup.h
../../source/as_context.h
../../source/as_criticalsection.h
../../source/as_datatype.h
../../source/as_debug.h
../../source/as_generic.h
../../source/as_map.h
../../source/as_memory.h
../../source/as_module.h
../../source/as_objecttype.h
../../source/as_outputbuffer.h
../../source/as_parser.h
../../source/as_property.h
../../source/as_restore.h
../../source/as_scriptcode.h
../../source/as_scriptengine.h
../../source/as_scriptfunction.h
../../source/as_scriptnode.h
../../source/as_scriptobject.h
../../source/as_string.h
../../source/as_string_util.h
../../source/as_texts.h
../../source/as_thread.h
../../source/as_tokendef.h
../../source/as_tokenizer.h
../../source/as_typeinfo.h
../../source/as_variablescope.h
)
set(ANGELSCRIPT_SOURCE
../../source/as_atomic.cpp
../../source/as_builder.cpp
../../source/as_bytecode.cpp
../../source/as_callfunc.cpp
../../source/as_callfunc_mips.cpp
../../source/as_callfunc_x86.cpp
../../source/as_callfunc_x64_gcc.cpp
../../source/as_callfunc_x64_msvc.cpp
../../source/as_callfunc_x64_mingw.cpp
../../source/as_compiler.cpp
../../source/as_configgroup.cpp
../../source/as_context.cpp
../../source/as_datatype.cpp
../../source/as_gc.cpp
../../source/as_generic.cpp
../../source/as_globalproperty.cpp
../../source/as_memory.cpp
../../source/as_module.cpp
../../source/as_objecttype.cpp
../../source/as_outputbuffer.cpp
../../source/as_parser.cpp
../../source/as_restore.cpp
../../source/as_scriptcode.cpp
../../source/as_scriptengine.cpp
../../source/as_scriptfunction.cpp
../../source/as_scriptnode.cpp
../../source/as_scriptobject.cpp
../../source/as_string.cpp
../../source/as_string_util.cpp
../../source/as_thread.cpp
../../source/as_tokenizer.cpp
../../source/as_typeinfo.cpp
../../source/as_variablescope.cpp
)
if(MSVC AND CMAKE_CL_64)
enable_language(ASM_MASM)
if(CMAKE_ASM_MASM_COMPILER_WORKS)
set(ANGELSCRIPT_SOURCE ${ANGELSCRIPT_SOURCE} ../../source/as_callfunc_x64_msvc_asm.asm)
else()
message(FATAL ERROR "MSVC x86_64 target requires a working assembler")
endif()
endif()
if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "^arm")
enable_language(ASM)
if(CMAKE_ASM_COMPILER_WORKS)
set(ANGELSCRIPT_SOURCE ${ANGELSCRIPT_SOURCE} ../../source/as_callfunc_arm.cpp ../../source/as_callfunc_arm_gcc.S)
set_property(SOURCE ../../source/as_callfunc_arm_gcc.S APPEND PROPERTY COMPILE_FLAGS " -Wa,-mimplicit-it=always")
else()
message(FATAL ERROR "ARM target requires a working assembler")
endif()
endif()
if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "^aarch64")
enable_language(ASM)
if(CMAKE_ASM_COMPILER_WORKS)
set(ANGELSCRIPT_SOURCE ${ANGELSCRIPT_SOURCE} ../../source/as_callfunc_arm64.cpp ../../source/as_callfunc_arm64_gcc.S)
#set_property(SOURCE ../../source/as_callfunc_arm64_gcc.S APPEND PROPERTY COMPILE_FLAGS " -Wa")
else()
message(FATAL ERROR "ARM target requires a working assembler")
endif()
endif()
if(MSVC)
set(CMAKE_DEBUG_POSTFIX "d")
endif()
if(NOT BUILD_FRAMEWORK)
set(ANGELSCRIPT_LIBRARY_NAME angelscript)
else()
set(ANGELSCRIPT_LIBRARY_NAME Angelscript) # OS X frameworks should have capitalized name
set(BUILD_SHARED_LIBS TRUE)
endif()
set(ANGELSCRIPT_LIBRARY_NAME ${ANGELSCRIPT_LIBRARY_NAME} CACHE STRING "" FORCE)
add_library(${ANGELSCRIPT_LIBRARY_NAME} ${ANGELSCRIPT_SOURCE} ${ANGELSCRIPT_HEADERS})
target_include_directories(${ANGELSCRIPT_LIBRARY_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../include)
if(MSVC)
target_compile_definitions(${ANGELSCRIPT_LIBRARY_NAME} PRIVATE -D_CRT_SECURE_NO_WARNINGS)
endif()
target_compile_definitions(${ANGELSCRIPT_LIBRARY_NAME} PRIVATE -DANGELSCRIPT_EXPORT -D_LIB)
if(AS_NO_EXCEPTIONS)
target_compile_definitions(${ANGELSCRIPT_LIBRARY_NAME} PRIVATE AS_NO_EXCEPTIONS)
endif()
# Don't override the default library output path to avoid conflicts when building for multiple target platforms
#set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/../../lib)
if (LINK_STD_STATICALLY)
message(STATUS "Linking std libraries statically")
set (CMAKE_SHARED_LINKER_FLAGS "-Wl,--as-needed")
target_link_libraries(${ANGELSCRIPT_LIBRARY_NAME} -lpthread -static-libgcc -static-libstdc++ -Wl,-Bstatic -lstdc++ )
else()
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
target_link_libraries(${ANGELSCRIPT_LIBRARY_NAME} -lpthread)
endif()
set_target_properties(${ANGELSCRIPT_LIBRARY_NAME} PROPERTIES VERSION ${PROJECT_VERSION})
if(BUILD_FRAMEWORK)
set_target_properties(${ANGELSCRIPT_LIBRARY_NAME} PROPERTIES
FRAMEWORK TRUE
FRAMEWORK_VERSION ${PROJECT_VERSION}
MACOSX_FRAMEWORK_IDENTIFIER com.angelcode.Angelscript
MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${PROJECT_VERSION}
MACOSX_FRAMEWORK_BUNDLE_VERSION ${PROJECT_VERSION}
XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
PUBLIC_HEADER ../../include/angelscript.h
)
endif()
if(MSVC AND MSVC_COMPILE_FLAGS)
target_compile_options(${ANGELSCRIPT_LIBRARY_NAME} PRIVATE "${MSVC_COMPILE_FLAGS}")
endif()
# Don't override the default runtime output path to avoid conflicts when building for multiple target platforms
#set(RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/../../bin)
#See https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#creating-packages for a detailed explanation about this part
install(TARGETS ${ANGELSCRIPT_LIBRARY_NAME} EXPORT AngelscriptTargets
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
INCLUDES DESTINATION include
)
install(FILES
${CMAKE_CURRENT_SOURCE_DIR}/../../include/angelscript.h
DESTINATION include
COMPONENT Devel
)
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/Angelscript/AngelscriptConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
export(EXPORT AngelscriptTargets
FILE "${CMAKE_CURRENT_BINARY_DIR}/Angelscript/AngelscriptTargets.cmake"
NAMESPACE Angelscript::
)
configure_file(cmake/AngelscriptConfig.cmake
"${CMAKE_CURRENT_BINARY_DIR}/Angelscript/AngelscriptConfig.cmake"
COPYONLY
)
set(ConfigPackageLocation lib/cmake/Angelscript)
install(EXPORT AngelscriptTargets
FILE AngelscriptTargets.cmake
NAMESPACE Angelscript::
DESTINATION ${ConfigPackageLocation}
)
install(
FILES
cmake/AngelscriptConfig.cmake
"${CMAKE_CURRENT_BINARY_DIR}/Angelscript/AngelscriptConfigVersion.cmake"
DESTINATION ${ConfigPackageLocation}
COMPONENT Devel
)

2
angelscript/projects/cmake/cmake/AngelscriptConfig.cmake Normal file
View File

@@ -0,0 +1,2 @@
include("${CMAKE_CURRENT_LIST_DIR}/AngelscriptTargets.cmake")

15
angelscript/projects/cmake/conan.lock Normal file
View File

@@ -0,0 +1,15 @@
{
"graph_lock": {
"nodes": {
"0": {
"ref": "AngelScript/2.35",
"options": "link_std_statically=True\nshared=True",
"path": "conanfile.py",
"context": "host"
}
},
"revisions_enabled": false
},
"version": "0.4",
"profile_host": "[settings]\narch=x86_64\narch_build=x86_64\nbuild_type=Release\ncompiler=clang\ncompiler.libcxx=libstdc++11\ncompiler.version=11\nos=Linux\nos_build=Linux\n[options]\nlink_std_statically=True\nshared=True\n[build_requires]\n[env]\n"
}

675
angelscript/projects/cmake/conanbuildinfo.cmake Normal file
View File

@@ -0,0 +1,675 @@
include(CMakeParseArguments)
macro(conan_find_apple_frameworks FRAMEWORKS_FOUND FRAMEWORKS SUFFIX BUILD_TYPE)
if(APPLE)
if(CMAKE_BUILD_TYPE)
set(_BTYPE ${CMAKE_BUILD_TYPE})
elseif(NOT BUILD_TYPE STREQUAL "")
set(_BTYPE ${BUILD_TYPE})
endif()
if(_BTYPE)
if(${_BTYPE} MATCHES "Debug|_DEBUG")
set(CONAN_FRAMEWORKS${SUFFIX} ${CONAN_FRAMEWORKS${SUFFIX}_DEBUG} ${CONAN_FRAMEWORKS${SUFFIX}})
set(CONAN_FRAMEWORK_DIRS${SUFFIX} ${CONAN_FRAMEWORK_DIRS${SUFFIX}_DEBUG} ${CONAN_FRAMEWORK_DIRS${SUFFIX}})
elseif(${_BTYPE} MATCHES "Release|_RELEASE")
set(CONAN_FRAMEWORKS${SUFFIX} ${CONAN_FRAMEWORKS${SUFFIX}_RELEASE} ${CONAN_FRAMEWORKS${SUFFIX}})
set(CONAN_FRAMEWORK_DIRS${SUFFIX} ${CONAN_FRAMEWORK_DIRS${SUFFIX}_RELEASE} ${CONAN_FRAMEWORK_DIRS${SUFFIX}})
elseif(${_BTYPE} MATCHES "RelWithDebInfo|_RELWITHDEBINFO")
set(CONAN_FRAMEWORKS${SUFFIX} ${CONAN_FRAMEWORKS${SUFFIX}_RELWITHDEBINFO} ${CONAN_FRAMEWORKS${SUFFIX}})
set(CONAN_FRAMEWORK_DIRS${SUFFIX} ${CONAN_FRAMEWORK_DIRS${SUFFIX}_RELWITHDEBINFO} ${CONAN_FRAMEWORK_DIRS${SUFFIX}})
elseif(${_BTYPE} MATCHES "MinSizeRel|_MINSIZEREL")
set(CONAN_FRAMEWORKS${SUFFIX} ${CONAN_FRAMEWORKS${SUFFIX}_MINSIZEREL} ${CONAN_FRAMEWORKS${SUFFIX}})
set(CONAN_FRAMEWORK_DIRS${SUFFIX} ${CONAN_FRAMEWORK_DIRS${SUFFIX}_MINSIZEREL} ${CONAN_FRAMEWORK_DIRS${SUFFIX}})
endif()
endif()
foreach(_FRAMEWORK ${FRAMEWORKS})
# https://cmake.org/pipermail/cmake-developers/2017-August/030199.html
find_library(CONAN_FRAMEWORK_${_FRAMEWORK}_FOUND NAME ${_FRAMEWORK} PATHS ${CONAN_FRAMEWORK_DIRS${SUFFIX}} CMAKE_FIND_ROOT_PATH_BOTH)
if(CONAN_FRAMEWORK_${_FRAMEWORK}_FOUND)
list(APPEND ${FRAMEWORKS_FOUND} ${CONAN_FRAMEWORK_${_FRAMEWORK}_FOUND})
else()
message(FATAL_ERROR "Framework library ${_FRAMEWORK} not found in paths: ${CONAN_FRAMEWORK_DIRS${SUFFIX}}")
endif()
endforeach()
endif()
endmacro()
### Definition of global aggregated variables ###
set(CONAN_PACKAGE_NAME AngelScript)
set(CONAN_PACKAGE_VERSION 2.35)
set(CONAN_SETTINGS_ARCH "x86_64")
set(CONAN_SETTINGS_BUILD_TYPE "Release")
set(CONAN_SETTINGS_COMPILER "clang")
set(CONAN_SETTINGS_COMPILER_LIBCXX "libstdc++11")
set(CONAN_SETTINGS_COMPILER_VERSION "11")
set(CONAN_SETTINGS_OS "Linux")
set(CONAN_DEPENDENCIES )
# Storing original command line args (CMake helper) flags
set(CONAN_CMD_CXX_FLAGS ${CONAN_CXX_FLAGS})
set(CONAN_CMD_SHARED_LINKER_FLAGS ${CONAN_SHARED_LINKER_FLAGS})
set(CONAN_CMD_C_FLAGS ${CONAN_C_FLAGS})
# Defining accumulated conan variables for all deps
set(CONAN_INCLUDE_DIRS ${CONAN_INCLUDE_DIRS})
set(CONAN_LIB_DIRS ${CONAN_LIB_DIRS})
set(CONAN_BIN_DIRS ${CONAN_BIN_DIRS})
set(CONAN_RES_DIRS ${CONAN_RES_DIRS})
set(CONAN_FRAMEWORK_DIRS ${CONAN_FRAMEWORK_DIRS})
set(CONAN_LIBS ${CONAN_LIBS})
set(CONAN_PKG_LIBS ${CONAN_PKG_LIBS})
set(CONAN_SYSTEM_LIBS ${CONAN_SYSTEM_LIBS})
set(CONAN_FRAMEWORKS ${CONAN_FRAMEWORKS})
set(CONAN_FRAMEWORKS_FOUND "") # Will be filled later
set(CONAN_DEFINES ${CONAN_DEFINES})
set(CONAN_BUILD_MODULES_PATHS ${CONAN_BUILD_MODULES_PATHS})
set(CONAN_CMAKE_MODULE_PATH ${CONAN_CMAKE_MODULE_PATH})
set(CONAN_CXX_FLAGS " ${CONAN_CXX_FLAGS}")
set(CONAN_SHARED_LINKER_FLAGS " ${CONAN_SHARED_LINKER_FLAGS}")
set(CONAN_EXE_LINKER_FLAGS " ${CONAN_EXE_LINKER_FLAGS}")
set(CONAN_C_FLAGS " ${CONAN_C_FLAGS}")
# Apple Frameworks
conan_find_apple_frameworks(CONAN_FRAMEWORKS_FOUND "${CONAN_FRAMEWORKS}" "" "")
# Append to aggregated values variable: Use CONAN_LIBS instead of CONAN_PKG_LIBS to include user appended vars
set(CONAN_LIBS ${CONAN_LIBS} ${CONAN_SYSTEM_LIBS} ${CONAN_FRAMEWORKS_FOUND})
### Definition of macros and functions ###
macro(conan_define_targets)
if(${CMAKE_VERSION} VERSION_LESS "3.1.2")
message(FATAL_ERROR "TARGETS not supported by your CMake version!")
endif() # CMAKE > 3.x
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CONAN_CMD_CXX_FLAGS}")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CONAN_CMD_C_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CONAN_CMD_SHARED_LINKER_FLAGS}")
set(CONAN_TARGETS )
endmacro()
macro(conan_basic_setup)
set(options TARGETS NO_OUTPUT_DIRS SKIP_RPATH KEEP_RPATHS SKIP_STD SKIP_FPIC)
cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
if(CONAN_EXPORTED)
conan_message(STATUS "Conan: called by CMake conan helper")
endif()
if(CONAN_IN_LOCAL_CACHE)
conan_message(STATUS "Conan: called inside local cache")
endif()
if(NOT ARGUMENTS_NO_OUTPUT_DIRS)
conan_message(STATUS "Conan: Adjusting output directories")
conan_output_dirs_setup()
endif()
if(NOT ARGUMENTS_TARGETS)
conan_message(STATUS "Conan: Using cmake global configuration")
conan_global_flags()
else()
conan_message(STATUS "Conan: Using cmake targets configuration")
conan_define_targets()
endif()
if(ARGUMENTS_SKIP_RPATH)
# Change by "DEPRECATION" or "SEND_ERROR" when we are ready
conan_message(WARNING "Conan: SKIP_RPATH is deprecated, it has been renamed to KEEP_RPATHS")
endif()
if(NOT ARGUMENTS_SKIP_RPATH AND NOT ARGUMENTS_KEEP_RPATHS)
# Parameter has renamed, but we keep the compatibility with old SKIP_RPATH
conan_set_rpath()
endif()
if(NOT ARGUMENTS_SKIP_STD)
conan_set_std()
endif()
if(NOT ARGUMENTS_SKIP_FPIC)
conan_set_fpic()
endif()
conan_check_compiler()
conan_set_libcxx()
conan_set_vs_runtime()
conan_set_find_paths()
conan_include_build_modules()
conan_set_find_library_paths()
endmacro()
macro(conan_set_find_paths)
# CMAKE_MODULE_PATH does not have Debug/Release config, but there are variables
# CONAN_CMAKE_MODULE_PATH_DEBUG to be used by the consumer
# CMake can find findXXX.cmake files in the root of packages
set(CMAKE_MODULE_PATH ${CONAN_CMAKE_MODULE_PATH} ${CMAKE_MODULE_PATH})
# Make find_package() to work
set(CMAKE_PREFIX_PATH ${CONAN_CMAKE_MODULE_PATH} ${CMAKE_PREFIX_PATH})
# Set the find root path (cross build)
set(CMAKE_FIND_ROOT_PATH ${CONAN_CMAKE_FIND_ROOT_PATH} ${CMAKE_FIND_ROOT_PATH})
if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_PROGRAM})
endif()
if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_LIBRARY})
endif()
if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_INCLUDE})
endif()
endmacro()
macro(conan_set_find_library_paths)
# CMAKE_INCLUDE_PATH, CMAKE_LIBRARY_PATH does not have Debug/Release config, but there are variables
# CONAN_INCLUDE_DIRS_DEBUG/RELEASE CONAN_LIB_DIRS_DEBUG/RELEASE to be used by the consumer
# For find_library
set(CMAKE_INCLUDE_PATH ${CONAN_INCLUDE_DIRS} ${CMAKE_INCLUDE_PATH})
set(CMAKE_LIBRARY_PATH ${CONAN_LIB_DIRS} ${CMAKE_LIBRARY_PATH})
endmacro()
macro(conan_set_vs_runtime)
if(CONAN_LINK_RUNTIME)
conan_get_policy(CMP0091 policy_0091)
if(policy_0091 STREQUAL "NEW")
if(CONAN_LINK_RUNTIME MATCHES "MTd")
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreadedDebug")
elseif(CONAN_LINK_RUNTIME MATCHES "MDd")
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreadedDebugDLL")
elseif(CONAN_LINK_RUNTIME MATCHES "MT")
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
elseif(CONAN_LINK_RUNTIME MATCHES "MD")
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
endif()
else()
foreach(flag CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE
CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS_RELWITHDEBINFO
CMAKE_C_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_MINSIZEREL)
if(DEFINED ${flag})
string(REPLACE "/MD" ${CONAN_LINK_RUNTIME} ${flag} "${${flag}}")
endif()
endforeach()
foreach(flag CMAKE_C_FLAGS_DEBUG CMAKE_CXX_FLAGS_DEBUG)
if(DEFINED ${flag})
string(REPLACE "/MDd" ${CONAN_LINK_RUNTIME} ${flag} "${${flag}}")
endif()
endforeach()
endif()
endif()
endmacro()
macro(conan_flags_setup)
# Macro maintained for backwards compatibility
conan_set_find_library_paths()
conan_global_flags()
conan_set_rpath()
conan_set_vs_runtime()
conan_set_libcxx()
endmacro()
function(conan_message MESSAGE_OUTPUT)
if(NOT CONAN_CMAKE_SILENT_OUTPUT)
message(${ARGV${0}})
endif()
endfunction()
function(conan_get_policy policy_id policy)
if(POLICY "${policy_id}")
cmake_policy(GET "${policy_id}" _policy)
set(${policy} "${_policy}" PARENT_SCOPE)
else()
set(${policy} "" PARENT_SCOPE)
endif()
endfunction()
function(conan_find_libraries_abs_path libraries package_libdir libraries_abs_path)
foreach(_LIBRARY_NAME ${libraries})
find_library(CONAN_FOUND_LIBRARY NAME ${_LIBRARY_NAME} PATHS ${package_libdir}
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
if(CONAN_FOUND_LIBRARY)
conan_message(STATUS "Library ${_LIBRARY_NAME} found ${CONAN_FOUND_LIBRARY}")
set(CONAN_FULLPATH_LIBS ${CONAN_FULLPATH_LIBS} ${CONAN_FOUND_LIBRARY})
else()
conan_message(STATUS "Library ${_LIBRARY_NAME} not found in package, might be system one")
set(CONAN_FULLPATH_LIBS ${CONAN_FULLPATH_LIBS} ${_LIBRARY_NAME})
endif()
unset(CONAN_FOUND_LIBRARY CACHE)
endforeach()
set(${libraries_abs_path} ${CONAN_FULLPATH_LIBS} PARENT_SCOPE)
endfunction()
function(conan_package_library_targets libraries package_libdir libraries_abs_path deps build_type package_name)
unset(_CONAN_ACTUAL_TARGETS CACHE)
unset(_CONAN_FOUND_SYSTEM_LIBS CACHE)
foreach(_LIBRARY_NAME ${libraries})
find_library(CONAN_FOUND_LIBRARY NAME ${_LIBRARY_NAME} PATHS ${package_libdir}
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
if(CONAN_FOUND_LIBRARY)
conan_message(STATUS "Library ${_LIBRARY_NAME} found ${CONAN_FOUND_LIBRARY}")
set(_LIB_NAME CONAN_LIB::${package_name}_${_LIBRARY_NAME}${build_type})
add_library(${_LIB_NAME} UNKNOWN IMPORTED)
set_target_properties(${_LIB_NAME} PROPERTIES IMPORTED_LOCATION ${CONAN_FOUND_LIBRARY})
set(CONAN_FULLPATH_LIBS ${CONAN_FULLPATH_LIBS} ${_LIB_NAME})
set(_CONAN_ACTUAL_TARGETS ${_CONAN_ACTUAL_TARGETS} ${_LIB_NAME})
else()
conan_message(STATUS "Library ${_LIBRARY_NAME} not found in package, might be system one")
set(CONAN_FULLPATH_LIBS ${CONAN_FULLPATH_LIBS} ${_LIBRARY_NAME})
set(_CONAN_FOUND_SYSTEM_LIBS "${_CONAN_FOUND_SYSTEM_LIBS};${_LIBRARY_NAME}")
endif()
unset(CONAN_FOUND_LIBRARY CACHE)
endforeach()
# Add all dependencies to all targets
string(REPLACE " " ";" deps_list "${deps}")
foreach(_CONAN_ACTUAL_TARGET ${_CONAN_ACTUAL_TARGETS})
set_property(TARGET ${_CONAN_ACTUAL_TARGET} PROPERTY INTERFACE_LINK_LIBRARIES "${_CONAN_FOUND_SYSTEM_LIBS};${deps_list}")
endforeach()
set(${libraries_abs_path} ${CONAN_FULLPATH_LIBS} PARENT_SCOPE)
endfunction()
macro(conan_set_libcxx)
if(DEFINED CONAN_LIBCXX)
conan_message(STATUS "Conan: C++ stdlib: ${CONAN_LIBCXX}")
if(CONAN_COMPILER STREQUAL "clang" OR CONAN_COMPILER STREQUAL "apple-clang")
if(CONAN_LIBCXX STREQUAL "libstdc++" OR CONAN_LIBCXX STREQUAL "libstdc++11" )
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libstdc++")
elseif(CONAN_LIBCXX STREQUAL "libc++")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
endif()
endif()
if(CONAN_COMPILER STREQUAL "sun-cc")
if(CONAN_LIBCXX STREQUAL "libCstd")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -library=Cstd")
elseif(CONAN_LIBCXX STREQUAL "libstdcxx")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -library=stdcxx4")
elseif(CONAN_LIBCXX STREQUAL "libstlport")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -library=stlport4")
elseif(CONAN_LIBCXX STREQUAL "libstdc++")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -library=stdcpp")
endif()
endif()
if(CONAN_LIBCXX STREQUAL "libstdc++11")
add_definitions(-D_GLIBCXX_USE_CXX11_ABI=1)
elseif(CONAN_LIBCXX STREQUAL "libstdc++")
add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0)
endif()
endif()
endmacro()
macro(conan_set_std)
conan_message(STATUS "Conan: Adjusting language standard")
# Do not warn "Manually-specified variables were not used by the project"
set(ignorevar "${CONAN_STD_CXX_FLAG}${CONAN_CMAKE_CXX_STANDARD}${CONAN_CMAKE_CXX_EXTENSIONS}")
if (CMAKE_VERSION VERSION_LESS "3.1" OR
(CMAKE_VERSION VERSION_LESS "3.12" AND ("${CONAN_CMAKE_CXX_STANDARD}" STREQUAL "20" OR "${CONAN_CMAKE_CXX_STANDARD}" STREQUAL "gnu20")))
if(CONAN_STD_CXX_FLAG)
conan_message(STATUS "Conan setting CXX_FLAGS flags: ${CONAN_STD_CXX_FLAG}")
set(CMAKE_CXX_FLAGS "${CONAN_STD_CXX_FLAG} ${CMAKE_CXX_FLAGS}")
endif()
else()
if(CONAN_CMAKE_CXX_STANDARD)
conan_message(STATUS "Conan setting CPP STANDARD: ${CONAN_CMAKE_CXX_STANDARD} WITH EXTENSIONS ${CONAN_CMAKE_CXX_EXTENSIONS}")
set(CMAKE_CXX_STANDARD ${CONAN_CMAKE_CXX_STANDARD})
set(CMAKE_CXX_EXTENSIONS ${CONAN_CMAKE_CXX_EXTENSIONS})
endif()
endif()
endmacro()
macro(conan_set_rpath)
conan_message(STATUS "Conan: Adjusting default RPATHs Conan policies")
if(APPLE)
# https://cmake.org/Wiki/CMake_RPATH_handling
# CONAN GUIDE: All generated libraries should have the id and dependencies to other
# dylibs without path, just the name, EX:
# libMyLib1.dylib:
# libMyLib1.dylib (compatibility version 0.0.0, current version 0.0.0)
# libMyLib0.dylib (compatibility version 0.0.0, current version 0.0.0)
# /usr/lib/libc++.1.dylib (compatibility version 1.0.0, current version 120.0.0)
# /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1197.1.1)
# AVOID RPATH FOR *.dylib, ALL LIBS BETWEEN THEM AND THE EXE
# SHOULD BE ON THE LINKER RESOLVER PATH (./ IS ONE OF THEM)
set(CMAKE_SKIP_RPATH 1 CACHE BOOL "rpaths" FORCE)
# Policy CMP0068
# We want the old behavior, in CMake >= 3.9 CMAKE_SKIP_RPATH won't affect the install_name in OSX
set(CMAKE_INSTALL_NAME_DIR "")
endif()
endmacro()
macro(conan_set_fpic)
if(DEFINED CONAN_CMAKE_POSITION_INDEPENDENT_CODE)
conan_message(STATUS "Conan: Adjusting fPIC flag (${CONAN_CMAKE_POSITION_INDEPENDENT_CODE})")
set(CMAKE_POSITION_INDEPENDENT_CODE ${CONAN_CMAKE_POSITION_INDEPENDENT_CODE})
endif()
endmacro()
macro(conan_output_dirs_setup)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
endmacro()
macro(conan_split_version VERSION_STRING MAJOR MINOR)
#make a list from the version string
string(REPLACE "." ";" VERSION_LIST "${VERSION_STRING}")
#write output values
list(LENGTH VERSION_LIST _version_len)
list(GET VERSION_LIST 0 ${MAJOR})
if(${_version_len} GREATER 1)
list(GET VERSION_LIST 1 ${MINOR})
endif()
endmacro()
macro(conan_error_compiler_version)
message(FATAL_ERROR "Detected a mismatch for the compiler version between your conan profile settings and CMake: \n"
"Compiler version specified in your conan profile: ${CONAN_COMPILER_VERSION}\n"
"Compiler version detected in CMake: ${VERSION_MAJOR}.${VERSION_MINOR}\n"
"Please check your conan profile settings (conan profile show [default|your_profile_name])\n"
"P.S. You may set CONAN_DISABLE_CHECK_COMPILER CMake variable in order to disable this check."
)
endmacro()
set(_CONAN_CURRENT_DIR ${CMAKE_CURRENT_LIST_DIR})
function(conan_get_compiler CONAN_INFO_COMPILER CONAN_INFO_COMPILER_VERSION)
conan_message(STATUS "Current conanbuildinfo.cmake directory: " ${_CONAN_CURRENT_DIR})
if(NOT EXISTS ${_CONAN_CURRENT_DIR}/conaninfo.txt)
conan_message(STATUS "WARN: conaninfo.txt not found")
return()
endif()
file (READ "${_CONAN_CURRENT_DIR}/conaninfo.txt" CONANINFO)
# MATCHALL will match all, including the last one, which is the full_settings one
string(REGEX MATCH "full_settings.*" _FULL_SETTINGS_MATCHED ${CONANINFO})
string(REGEX MATCH "compiler=([-A-Za-z0-9_ ]+)" _MATCHED ${_FULL_SETTINGS_MATCHED})
if(DEFINED CMAKE_MATCH_1)
string(STRIP "${CMAKE_MATCH_1}" _CONAN_INFO_COMPILER)
set(${CONAN_INFO_COMPILER} ${_CONAN_INFO_COMPILER} PARENT_SCOPE)
endif()
string(REGEX MATCH "compiler.version=([-A-Za-z0-9_.]+)" _MATCHED ${_FULL_SETTINGS_MATCHED})
if(DEFINED CMAKE_MATCH_1)
string(STRIP "${CMAKE_MATCH_1}" _CONAN_INFO_COMPILER_VERSION)
set(${CONAN_INFO_COMPILER_VERSION} ${_CONAN_INFO_COMPILER_VERSION} PARENT_SCOPE)
endif()
endfunction()
function(check_compiler_version)
conan_split_version(${CMAKE_CXX_COMPILER_VERSION} VERSION_MAJOR VERSION_MINOR)
if(DEFINED CONAN_SETTINGS_COMPILER_TOOLSET)
conan_message(STATUS "Conan: Skipping compiler check: Declared 'compiler.toolset'")
return()
endif()
if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
# MSVC_VERSION is defined since 2.8.2 at least
# https://cmake.org/cmake/help/v2.8.2/cmake.html#variable:MSVC_VERSION
# https://cmake.org/cmake/help/v3.14/variable/MSVC_VERSION.html
if(
# 1920-1929 = VS 16.0 (v142 toolset)
(CONAN_COMPILER_VERSION STREQUAL "16" AND NOT((MSVC_VERSION GREATER 1919) AND (MSVC_VERSION LESS 1930))) OR
# 1910-1919 = VS 15.0 (v141 toolset)
(CONAN_COMPILER_VERSION STREQUAL "15" AND NOT((MSVC_VERSION GREATER 1909) AND (MSVC_VERSION LESS 1920))) OR
# 1900 = VS 14.0 (v140 toolset)
(CONAN_COMPILER_VERSION STREQUAL "14" AND NOT(MSVC_VERSION EQUAL 1900)) OR
# 1800 = VS 12.0 (v120 toolset)
(CONAN_COMPILER_VERSION STREQUAL "12" AND NOT VERSION_MAJOR STREQUAL "18") OR
# 1700 = VS 11.0 (v110 toolset)
(CONAN_COMPILER_VERSION STREQUAL "11" AND NOT VERSION_MAJOR STREQUAL "17") OR
# 1600 = VS 10.0 (v100 toolset)
(CONAN_COMPILER_VERSION STREQUAL "10" AND NOT VERSION_MAJOR STREQUAL "16") OR
# 1500 = VS 9.0 (v90 toolset)
(CONAN_COMPILER_VERSION STREQUAL "9" AND NOT VERSION_MAJOR STREQUAL "15") OR
# 1400 = VS 8.0 (v80 toolset)
(CONAN_COMPILER_VERSION STREQUAL "8" AND NOT VERSION_MAJOR STREQUAL "14") OR
# 1310 = VS 7.1, 1300 = VS 7.0
(CONAN_COMPILER_VERSION STREQUAL "7" AND NOT VERSION_MAJOR STREQUAL "13") OR
# 1200 = VS 6.0
(CONAN_COMPILER_VERSION STREQUAL "6" AND NOT VERSION_MAJOR STREQUAL "12") )
conan_error_compiler_version()
endif()
elseif(CONAN_COMPILER STREQUAL "gcc")
conan_split_version(${CONAN_COMPILER_VERSION} CONAN_COMPILER_MAJOR CONAN_COMPILER_MINOR)
set(_CHECK_VERSION ${VERSION_MAJOR}.${VERSION_MINOR})
set(_CONAN_VERSION ${CONAN_COMPILER_MAJOR}.${CONAN_COMPILER_MINOR})
if(NOT ${CONAN_COMPILER_VERSION} VERSION_LESS 5.0)
conan_message(STATUS "Conan: Compiler GCC>=5, checking major version ${CONAN_COMPILER_VERSION}")
conan_split_version(${CONAN_COMPILER_VERSION} CONAN_COMPILER_MAJOR CONAN_COMPILER_MINOR)
if("${CONAN_COMPILER_MINOR}" STREQUAL "")
set(_CHECK_VERSION ${VERSION_MAJOR})
set(_CONAN_VERSION ${CONAN_COMPILER_MAJOR})
endif()
endif()
conan_message(STATUS "Conan: Checking correct version: ${_CHECK_VERSION}")
if(NOT ${_CHECK_VERSION} VERSION_EQUAL ${_CONAN_VERSION})
conan_error_compiler_version()
endif()
elseif(CONAN_COMPILER STREQUAL "clang")
conan_split_version(${CONAN_COMPILER_VERSION} CONAN_COMPILER_MAJOR CONAN_COMPILER_MINOR)
set(_CHECK_VERSION ${VERSION_MAJOR}.${VERSION_MINOR})
set(_CONAN_VERSION ${CONAN_COMPILER_MAJOR}.${CONAN_COMPILER_MINOR})
if(NOT ${CONAN_COMPILER_VERSION} VERSION_LESS 8.0)
conan_message(STATUS "Conan: Compiler Clang>=8, checking major version ${CONAN_COMPILER_VERSION}")
if("${CONAN_COMPILER_MINOR}" STREQUAL "")
set(_CHECK_VERSION ${VERSION_MAJOR})
set(_CONAN_VERSION ${CONAN_COMPILER_MAJOR})
endif()
endif()
conan_message(STATUS "Conan: Checking correct version: ${_CHECK_VERSION}")
if(NOT ${_CHECK_VERSION} VERSION_EQUAL ${_CONAN_VERSION})
conan_error_compiler_version()
endif()
elseif(CONAN_COMPILER STREQUAL "apple-clang" OR CONAN_COMPILER STREQUAL "sun-cc" OR CONAN_COMPILER STREQUAL "mcst-lcc")
conan_split_version(${CONAN_COMPILER_VERSION} CONAN_COMPILER_MAJOR CONAN_COMPILER_MINOR)
if(NOT ${VERSION_MAJOR}.${VERSION_MINOR} VERSION_EQUAL ${CONAN_COMPILER_MAJOR}.${CONAN_COMPILER_MINOR})
conan_error_compiler_version()
endif()
elseif(CONAN_COMPILER STREQUAL "intel")
conan_split_version(${CONAN_COMPILER_VERSION} CONAN_COMPILER_MAJOR CONAN_COMPILER_MINOR)
if(NOT ${CONAN_COMPILER_VERSION} VERSION_LESS 19.1)
if(NOT ${VERSION_MAJOR}.${VERSION_MINOR} VERSION_EQUAL ${CONAN_COMPILER_MAJOR}.${CONAN_COMPILER_MINOR})
conan_error_compiler_version()
endif()
else()
if(NOT ${VERSION_MAJOR} VERSION_EQUAL ${CONAN_COMPILER_MAJOR})
conan_error_compiler_version()
endif()
endif()
else()
conan_message(STATUS "WARN: Unknown compiler '${CONAN_COMPILER}', skipping the version check...")
endif()
endfunction()
function(conan_check_compiler)
if(CONAN_DISABLE_CHECK_COMPILER)
conan_message(STATUS "WARN: Disabled conan compiler checks")
return()
endif()
if(NOT DEFINED CMAKE_CXX_COMPILER_ID)
if(DEFINED CMAKE_C_COMPILER_ID)
conan_message(STATUS "This project seems to be plain C, using '${CMAKE_C_COMPILER_ID}' compiler")
set(CMAKE_CXX_COMPILER_ID ${CMAKE_C_COMPILER_ID})
set(CMAKE_CXX_COMPILER_VERSION ${CMAKE_C_COMPILER_VERSION})
else()
message(FATAL_ERROR "This project seems to be plain C, but no compiler defined")
endif()
endif()
if(NOT CMAKE_CXX_COMPILER_ID AND NOT CMAKE_C_COMPILER_ID)
# This use case happens when compiler is not identified by CMake, but the compilers are there and work
conan_message(STATUS "*** WARN: CMake was not able to identify a C or C++ compiler ***")
conan_message(STATUS "*** WARN: Disabling compiler checks. Please make sure your settings match your environment ***")
return()
endif()
if(NOT DEFINED CONAN_COMPILER)
conan_get_compiler(CONAN_COMPILER CONAN_COMPILER_VERSION)
if(NOT DEFINED CONAN_COMPILER)
conan_message(STATUS "WARN: CONAN_COMPILER variable not set, please make sure yourself that "
"your compiler and version matches your declared settings")
return()
endif()
endif()
if(NOT CMAKE_HOST_SYSTEM_NAME STREQUAL ${CMAKE_SYSTEM_NAME})
set(CROSS_BUILDING 1)
endif()
# If using VS, verify toolset
if (CONAN_COMPILER STREQUAL "Visual Studio")
if (CONAN_SETTINGS_COMPILER_TOOLSET MATCHES "LLVM" OR
CONAN_SETTINGS_COMPILER_TOOLSET MATCHES "llvm" OR
CONAN_SETTINGS_COMPILER_TOOLSET MATCHES "clang" OR
CONAN_SETTINGS_COMPILER_TOOLSET MATCHES "Clang")
set(EXPECTED_CMAKE_CXX_COMPILER_ID "Clang")
elseif (CONAN_SETTINGS_COMPILER_TOOLSET MATCHES "Intel")
set(EXPECTED_CMAKE_CXX_COMPILER_ID "Intel")
else()
set(EXPECTED_CMAKE_CXX_COMPILER_ID "MSVC")
endif()
if (NOT CMAKE_CXX_COMPILER_ID MATCHES ${EXPECTED_CMAKE_CXX_COMPILER_ID})
message(FATAL_ERROR "Incorrect '${CONAN_COMPILER}'. Toolset specifies compiler as '${EXPECTED_CMAKE_CXX_COMPILER_ID}' "
"but CMake detected '${CMAKE_CXX_COMPILER_ID}'")
endif()
# Avoid checks when cross compiling, apple-clang crashes because its APPLE but not apple-clang
# Actually CMake is detecting "clang" when you are using apple-clang, only if CMP0025 is set to NEW will detect apple-clang
elseif((CONAN_COMPILER STREQUAL "gcc" AND NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR
(CONAN_COMPILER STREQUAL "apple-clang" AND NOT CROSS_BUILDING AND (NOT APPLE OR NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")) OR
(CONAN_COMPILER STREQUAL "clang" AND NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang") OR
(CONAN_COMPILER STREQUAL "sun-cc" AND NOT CMAKE_CXX_COMPILER_ID MATCHES "SunPro") )
message(FATAL_ERROR "Incorrect '${CONAN_COMPILER}', is not the one detected by CMake: '${CMAKE_CXX_COMPILER_ID}'")
endif()
if(NOT DEFINED CONAN_COMPILER_VERSION)
conan_message(STATUS "WARN: CONAN_COMPILER_VERSION variable not set, please make sure yourself "
"that your compiler version matches your declared settings")
return()
endif()
check_compiler_version()
endfunction()
macro(conan_set_flags build_type)
set(CMAKE_CXX_FLAGS${build_type} "${CMAKE_CXX_FLAGS${build_type}} ${CONAN_CXX_FLAGS${build_type}}")
set(CMAKE_C_FLAGS${build_type} "${CMAKE_C_FLAGS${build_type}} ${CONAN_C_FLAGS${build_type}}")
set(CMAKE_SHARED_LINKER_FLAGS${build_type} "${CMAKE_SHARED_LINKER_FLAGS${build_type}} ${CONAN_SHARED_LINKER_FLAGS${build_type}}")
set(CMAKE_EXE_LINKER_FLAGS${build_type} "${CMAKE_EXE_LINKER_FLAGS${build_type}} ${CONAN_EXE_LINKER_FLAGS${build_type}}")
endmacro()
macro(conan_global_flags)
if(CONAN_SYSTEM_INCLUDES)
include_directories(SYSTEM ${CONAN_INCLUDE_DIRS}
"$<$<CONFIG:Release>:${CONAN_INCLUDE_DIRS_RELEASE}>"
"$<$<CONFIG:RelWithDebInfo>:${CONAN_INCLUDE_DIRS_RELWITHDEBINFO}>"
"$<$<CONFIG:MinSizeRel>:${CONAN_INCLUDE_DIRS_MINSIZEREL}>"
"$<$<CONFIG:Debug>:${CONAN_INCLUDE_DIRS_DEBUG}>")
else()
include_directories(${CONAN_INCLUDE_DIRS}
"$<$<CONFIG:Release>:${CONAN_INCLUDE_DIRS_RELEASE}>"
"$<$<CONFIG:RelWithDebInfo>:${CONAN_INCLUDE_DIRS_RELWITHDEBINFO}>"
"$<$<CONFIG:MinSizeRel>:${CONAN_INCLUDE_DIRS_MINSIZEREL}>"
"$<$<CONFIG:Debug>:${CONAN_INCLUDE_DIRS_DEBUG}>")
endif()
link_directories(${CONAN_LIB_DIRS})
conan_find_libraries_abs_path("${CONAN_LIBS_DEBUG}" "${CONAN_LIB_DIRS_DEBUG}"
CONAN_LIBS_DEBUG)
conan_find_libraries_abs_path("${CONAN_LIBS_RELEASE}" "${CONAN_LIB_DIRS_RELEASE}"
CONAN_LIBS_RELEASE)
conan_find_libraries_abs_path("${CONAN_LIBS_RELWITHDEBINFO}" "${CONAN_LIB_DIRS_RELWITHDEBINFO}"
CONAN_LIBS_RELWITHDEBINFO)
conan_find_libraries_abs_path("${CONAN_LIBS_MINSIZEREL}" "${CONAN_LIB_DIRS_MINSIZEREL}"
CONAN_LIBS_MINSIZEREL)
add_compile_options(${CONAN_DEFINES}
"$<$<CONFIG:Debug>:${CONAN_DEFINES_DEBUG}>"
"$<$<CONFIG:Release>:${CONAN_DEFINES_RELEASE}>"
"$<$<CONFIG:RelWithDebInfo>:${CONAN_DEFINES_RELWITHDEBINFO}>"
"$<$<CONFIG:MinSizeRel>:${CONAN_DEFINES_MINSIZEREL}>")
conan_set_flags("")
conan_set_flags("_RELEASE")
conan_set_flags("_DEBUG")
endmacro()
macro(conan_target_link_libraries target)
if(CONAN_TARGETS)
target_link_libraries(${target} ${CONAN_TARGETS})
else()
target_link_libraries(${target} ${CONAN_LIBS})
foreach(_LIB ${CONAN_LIBS_RELEASE})
target_link_libraries(${target} optimized ${_LIB})
endforeach()
foreach(_LIB ${CONAN_LIBS_DEBUG})
target_link_libraries(${target} debug ${_LIB})
endforeach()
endif()
endmacro()
macro(conan_include_build_modules)
if(CMAKE_BUILD_TYPE)
if(${CMAKE_BUILD_TYPE} MATCHES "Debug")
set(CONAN_BUILD_MODULES_PATHS ${CONAN_BUILD_MODULES_PATHS_DEBUG} ${CONAN_BUILD_MODULES_PATHS})
elseif(${CMAKE_BUILD_TYPE} MATCHES "Release")
set(CONAN_BUILD_MODULES_PATHS ${CONAN_BUILD_MODULES_PATHS_RELEASE} ${CONAN_BUILD_MODULES_PATHS})
elseif(${CMAKE_BUILD_TYPE} MATCHES "RelWithDebInfo")
set(CONAN_BUILD_MODULES_PATHS ${CONAN_BUILD_MODULES_PATHS_RELWITHDEBINFO} ${CONAN_BUILD_MODULES_PATHS})
elseif(${CMAKE_BUILD_TYPE} MATCHES "MinSizeRel")
set(CONAN_BUILD_MODULES_PATHS ${CONAN_BUILD_MODULES_PATHS_MINSIZEREL} ${CONAN_BUILD_MODULES_PATHS})
endif()
endif()
foreach(_BUILD_MODULE_PATH ${CONAN_BUILD_MODULES_PATHS})
include(${_BUILD_MODULE_PATH})
endforeach()
endmacro()
### Definition of user declared vars (user_info) ###

49
angelscript/projects/cmake/conanbuildinfo.txt Normal file
View File

@@ -0,0 +1,49 @@
[includedirs]
[libdirs]
[bindirs]
[resdirs]
[builddirs]
[libs]
[system_libs]
[defines]
[cppflags]
[cxxflags]
[cflags]
[sharedlinkflags]
[exelinkflags]
[sysroot]
[frameworks]
[frameworkdirs]

42
angelscript/projects/cmake/conanfile.py Normal file
View File

@@ -0,0 +1,42 @@
from conans import ConanFile, CMake, tools
import os
class AngelScriptConan(ConanFile):
name = "AngelScript"
version = "2.35"
license = "<Put the package license here>"
url = "<Package recipe repository url here, for issues about the package>"
description = "<Description of Hello here>"
settings = "os", "compiler", "build_type", "arch"
options = {"shared": [True, False], "link_std_statically": [True, False]}
default_options = {"shared": False, "link_std_statically": True}
generators = "cmake"
exports_sources = "../../*"
def build(self):
cmake = CMake(self)
if (self.options.shared):
self.output.info("Building shared lib.")
cmake.definitions["BUILD_SHARED_LIBS"] = 1
else:
self.output.info("Building static lib.")
if (self.options.link_std_statically):
cmake.definitions["LINK_STD_STATICALLY"] = 1
cmake.configure(build_dir="./build", source_dir="../projects/cmake")
cmake.build()
def package(self):
os.chdir(os.path.dirname(__file__))
print(os.getcwd())
self.copy("include/angelscript.h", dst="include", keep_path=False)
self.copy("*.dll", dst="bin", keep_path=False)
self.copy("*.so", dst="lib", keep_path=False)
self.copy("*.so.*", dst="lib", keep_path=False)
self.copy("*.dylib", dst="lib", keep_path=False)
self.copy("*.a", dst="lib", keep_path=False)
def package_info(self):
self.cpp_info.libs = ["angelscript"]

35
angelscript/projects/cmake/conaninfo.txt Normal file
View File

@@ -0,0 +1,35 @@
[settings]
arch=x86_64
build_type=Release
compiler=clang
compiler.libcxx=libstdc++11
compiler.version=11
os=Linux
[requires]
[options]
link_std_statically=True
shared=True
[full_settings]
arch=x86_64
build_type=Release
compiler=clang
compiler.libcxx=libstdc++11
compiler.version=11
os=Linux
[full_requires]
[full_options]
link_std_statically=True
shared=True
[recipe_hash]
[env]

18
angelscript/projects/cmake/graph_info.json Normal file
View File

@@ -0,0 +1,18 @@
{
"options": [
[
"link_std_statically",
"True"
],
[
"shared",
"True"
]
],
"root": {
"name": "AngelScript",
"version": "2.35",
"user": null,
"channel": null
}
}