gfwleak/pxz-hos-client-cpp-module
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

✨feat(hos_client_create, hos_client_destory): 多次调用destory不会导致重复释放

Browse Source
This commit is contained in:
彭宣正
2020-12-14 17:24:58 +08:00
parent 505d529c32
commit 10b370e486
55976 changed files with 8544395 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

298
support/aws-sdk-cpp-master/cmake/AWSSDKConfig.cmake Normal file
View File

@@ -0,0 +1,298 @@
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0.
#
# When using AWSSDK package, users need to tell the installation root dir
# by setting up variable as set(AWSSDK_ROOT_DIR, "<path/to/dir>")
# In Windows the dir is like C:/Progra~1/AWSSDK/
# In Unix like system the dir is like /usr/local/
# if AWSSDK_ROOT_DIR doesn't appear, this module will identify it automatically
# By default:
# The cmake files will all be in <prefix>/lib/cmake dir
# The headers will all be in <prefix>/include dir
# The libraries will all be in <prefix>/lib/<platform_prefix> dir
# The binaries will all be in <prefix>/bin/<platform_prefix> dir
# The archives will all be in <prefix>/lib/<platform_prefix> dir if target is shared,
# otherwise will be in <prefix>/bin/<platform_prefix> dir.
# Platfrom_prefix is determined on compile time nbu option SIMPLE_INSTALL
# such as "<linux/intel64>"
if(AWSSDK_FOUND)
return()
endif()
include(${CMAKE_CURRENT_LIST_DIR}/AWSSDKConfigVersion.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/sdksCommon.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/platformDeps.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/compiler_settings.cmake)
if (NOT AWSSDK_INSTALL_LIBDIR)
set(AWSSDK_INSTALL_LIBDIR "lib")
endif()
if (NOT AWSSDK_INSTALL_BINDIR)
set(AWSSDK_INSTALL_BINDIR "bin")
endif()
if (NOT AWSSDK_INSTALL_INCLUDEDIR)
set(AWSSDK_INSTALL_INCLUDEDIR "include")
endif()
# On Windows, dlls are treated as runtime target and installed in bindir
if (WIN32 AND AWSSDK_INSTALL_AS_SHARED_LIBS)
set(AWSSDK_INSTALL_LIBDIR "${AWSSDK_INSTALL_BINDIR}")
# If installed CMake scripts are associated with dll library, define USE_IMPORT_EXPORT for customers
add_definitions(-DUSE_IMPORT_EXPORT)
endif()
# Compute the default installation root relative to this file.
# from prefix/lib/cmake/AWSSDK/xx.cmake to prefix
get_filename_component(AWSSDK_DEFAULT_ROOT_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
get_filename_component(AWSSDK_DEFAULT_ROOT_DIR "${AWSSDK_DEFAULT_ROOT_DIR}" PATH)
get_filename_component(AWSSDK_DEFAULT_ROOT_DIR "${AWSSDK_DEFAULT_ROOT_DIR}" PATH)
get_filename_component(AWSSDK_DEFAULT_ROOT_DIR "${AWSSDK_DEFAULT_ROOT_DIR}" PATH)
get_filename_component(AWS_NATIVE_SDK_ROOT "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE)
set(CPP_STANDARD "11" CACHE STRING "Flag to upgrade the C++ standard used. The default is 11. The minimum is 11.")
if(AWSSDK_DEFAULT_ROOT_DIR STREQUAL "/")
set(AWSSDK_DEFAULT_ROOT_DIR "")
endif()
# currently AWSSDK_ROOT_DIR is either empty or user specified
if (AWSSDK_ROOT_DIR)
find_file(AWSSDK_CORE_HEADER_FILE Aws.h
"${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
"${AWSSDK_DEFAULT_ROOT_DIR}/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
)
else()
find_file(AWSSDK_CORE_HEADER_FILE Aws.h
"${AWSSDK_DEFAULT_ROOT_DIR}/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
"/usr/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
"/usr/local/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
"C:/Progra~1/AWSSDK/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
"C:/Program Files/AWSSDK/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
"C:/Program Files/aws-cpp-sdk-all/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
"C:/Program Files (x86)/aws-cpp-sdk-all/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
"C:/AWSSDK/${AWSSDK_INSTALL_INCLUDEDIR}/aws/core"
)
endif()
if (NOT AWSSDK_CORE_HEADER_FILE)
message(FATAL_ERROR "AWS SDK for C++ is missing, please install it first")
endif()
# based on core header file path, inspects the actual AWSSDK_ROOT_DIR
get_filename_component(AWSSDK_ROOT_DIR "${AWSSDK_CORE_HEADER_FILE}" PATH)
get_filename_component(AWSSDK_ROOT_DIR "${AWSSDK_ROOT_DIR}" PATH)
get_filename_component(AWSSDK_ROOT_DIR "${AWSSDK_ROOT_DIR}" PATH)
get_filename_component(AWSSDK_ROOT_DIR "${AWSSDK_ROOT_DIR}" PATH)
if (NOT AWSSDK_ROOT_DIR)
message(FATAL_ERROR "AWSSDK_ROOT_DIR is not set or can't be calculated from the path of core header file")
endif()
find_library(AWSSDK_CORE_LIB_FILE aws-cpp-sdk-core
"${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_LIBDIR}/${AWSSDK_PLATFORM_PREFIX}"
"${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_LIBDIR}/${AWSSDK_PLATFORM_PREFIX}/Debug"
"${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_LIBDIR}/${AWSSDK_PLATFORM_PREFIX}/DebugOpt"
"${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_LIBDIR}/${AWSSDK_PLATFORM_PREFIX}/Release"
"${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_LIBDIR}/${AWSSDK_PLATFORM_PREFIX}/RelWithDebInfo"
"${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_LIBDIR}/${AWSSDK_PLATFORM_PREFIX}/MinSizeRel"
NO_DEFAULT_PATH)
if (NOT AWSSDK_CORE_LIB_FILE)
message(FATAL_ERROR "AWS SDK for C++ headers found, but we were unable to locate the binaries. Have you deleted or moved it?
Please make sure header files and binaries are located in INSTALL_ROOT_DIR/INCLUDE_DIR/ and INSTALL_ROOT_DIR/LIB_DIR/[PLATFORM_PREFIX]/[Debug|Config|OtherConfigs]")
endif()
# based on AWSSDK_CORE_LIB_FILE path, inspects the actual AWSSDK_PLATFROM_PREFIX
get_filename_component(TEMP_PATH "${AWSSDK_CORE_LIB_FILE}" PATH)
get_filename_component(TEMP_NAME "${TEMP_PATH}" NAME)
while (NOT TEMP_NAME STREQUAL ${LIB_SEARCH_PREFIX})
set(TEMP_PLATFORM_PREFIX "${TEMP_NAME}/${TEMP_PLATFORM_PREFIX}")
get_filename_component(TEMP_PATH "${TEMP_PATH}" PATH)
get_filename_component(TEMP_NAME "${TEMP_PATH}" NAME)
endwhile()
set(AWSSDK_PLATFORM_PREFIX "${TEMP_PLATFORM_PREFIX}")
set(AWSSDK_FOUND TRUE)
set(AWSSDK_INCLUDE_DIR "${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_INCLUDEDIR}")
set(AWSSDK_CMAKE_DIR "${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_LIBDIR}/cmake")
set(AWSSDK_LIB_DIR "${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_LIBDIR}/${AWSSDK_PLATFORM_PREFIX}")
set(AWSSDK_BIN_DIR "${AWSSDK_ROOT_DIR}/${AWSSDK_INSTALL_BINDIR}/${AWSSDK_PLATFORM_PREFIX}")
if (AWSSDK_PLATFORM_DEPS_LIBS)
set(AWSSDK_PLATFORM_DEPS "${AWSSDK_PLATFORM_DEPS_LIBS}")
endif()
if (AWSSDK_CRYPTO_LIBS)
set(AWSSDK_PLATFORM_DEPS "${AWSSDK_PLATFORM_DEPS}" "${AWSSDK_CRYPTO_LIBS}")
endif()
if (AWSSDK_CLIENT_LIBS)
set(AWSSDK_PLATFORM_DEPS "${AWSSDK_PLATFORM_DEPS}" "${AWSSDK_CLIENT_LIBS}")
endif()
if (AWSSDK_ADDITIONAL_LIBS)
set(AWSSDK_PLATFORM_DEPS "${AWSSDK_PLATFORM_DEPS}" "${AWSSDK_ADDITIONAL_LIBS}")
endif()
message(STATUS "Found AWS SDK for C++, Version: ${PACKAGE_VERSION}, Install Root:${AWSSDK_ROOT_DIR}, Platform Prefix:${AWSSDK_PLATFORM_PREFIX}, Platform Dependent Libraries: ${AWSSDK_PLATFORM_DEPS}")
# copy libs of services in SERVICE_LIST and all there dependent libs to DEST_DIR
# CONFIG denote copy release or debug version
macro(AWSSDK_CPY_DYN_LIBS SERVICE_LIST CONFIG DEST_DIR)
set(ALL_SERVICES "core" ${AWSSDK_THIRD_PARTY_LIBS})
foreach(SVC IN LISTS ${SERVICE_LIST})
list(APPEND ALL_SERVICES ${SVC})
get_dependencies_for_sdk(${SVC} DEPENDENCY_LIST)
if (DEPENDENCY_LIST)
string(REPLACE "," ";" LIST_RESULT ${DEPENDENCY_LIST})
list(APPEND ALL_SERVICES ${LIST_RESULT})
endif()
unset(DEPENDENCY_LIST CACHE)
endforeach()
list(REMOVE_DUPLICATES ALL_SERVICES)
foreach(SVC IN LISTS ALL_SERVICES)
if (WIN32)
set(CMAKE_FIND_LIBRARY_SUFFIXES_TEMP ${CMAKE_FIND_LIBRARY_SUFFIXES})
set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
endif()
find_library(LIB_PATH "aws-cpp-sdk-${SVC}" "${AWSSDK_LIB_DIR}/${CONFIG}" NO_DEFAULT_PATH)
if (NOT LIB_PATH)
find_library(LIB_PATH "${SVC}" "${AWSSDK_LIB_DIR}/${CONFIG}" NO_DEFAULT_PATH)
if (NOT LIB_PATH)
message(FATAL_ERROR "Couldn't find library aws-cpp-sdk-${SVC} or ${SVC}")
endif()
endif()
file(COPY ${LIB_PATH} DESTINATION ${DEST_DIR})
unset(LIB_PATH CACHE)
if (WIN32)
set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_TEMP})
endif()
endforeach()
endmacro(AWSSDK_CPY_DYN_LIBS)
# output link libs command to OUTPUT_VAR which required by all services from SERVCE_LIST
macro(AWSSDK_DETERMINE_LIBS_TO_LINK SERVICE_LIST OUTPUT_VAR)
foreach(SVC IN LISTS ${SERVICE_LIST})
list(APPEND ALL_SERVICES ${SVC})
get_dependencies_for_sdk(${SVC} DEPENDENCY_LIST)
if (DEPENDENCY_LIST)
string(REPLACE "," ";" LIST_RESULT ${DEPENDENCY_LIST})
list(APPEND ALL_SERVICES ${LIST_RESULT})
endif()
unset(DEPENDENCY_LIST CACHE)
endforeach()
list(REMOVE_DUPLICATES ALL_SERVICES)
# Order the dependencies correctly
# Change order from e.g. "core;transfer;s3;s3-encryption;kms" to "transfer;s3-encryption;kms;s3;core".
# This is important for static linked user application.
# They way of doing this is to keep checking libs after current lib till the end, if current lib is a dependency of checking lib,
# then move current lib to the end of list, after moving, current index stay and start another round of checking. If no libs after
# current lib is a dependency of current lib, move current index to next and start anohter round of checking.
# Example: "s3;core;transfer"
#-> s3(cur);core(checking);transfer s3 is not a dependency of core
#-> s3(cur);core;transfer(checking) s3 is a dependency of transfer
#-> core(cur);transfer(checking);s3 core is a dependency of transfer
#-> transfer(cur);s3(checking);core transfer is not a dependency of s3
#-> transfer(cur);s3;core(checking) transfer is not a dependency of core
#-> transfer;s3(cur);core(checking) s3 is not a dependency of core
#-> transfer;s3;core(cur) end of checking
list(LENGTH ALL_SERVICES length)
math(EXPR length ${length}-1) # Get index of last element.
if (length GREATER 0) # If more than 1 element.
set(i 0)
while (i LESS length) # No need to process last element
list(GET ALL_SERVICES ${i} SVC)
math(EXPR j ${i}+1)
math(EXPR jEnd ${length}+1)
while (j LESS jEnd)
list(GET ALL_SERVICES ${j} NEXT_SVC)
get_dependencies_for_sdk(${NEXT_SVC} DEPENDING_SDKS)
if (DEPENDING_SDKS)
string(REPLACE "," ";" DEPENDING_SDKS ${DEPENDING_SDKS})
endif()
list(FIND DEPENDING_SDKS ${SVC} index)
if (NOT ${index} EQUAL -1) # NEXT_SVC depend on SVC
list(REMOVE_AT ALL_SERVICES ${i}) # Move SVC to end
list(APPEND ALL_SERVICES ${SVC})
math(EXPR i ${i}-1) # make index point to new element but with the same index.
break() # as long as we moved SVC to end, the inner loop can be broke.
endif()
math(EXPR j ${j}+1)
endwhile()
if (i LESS 0) #CMake with some older versions (at least 3.6.0) do not support negative numbers in math expr e.g.: math(EXPR i -1+1)
set(i 0)
else()
math(EXPR i ${i}+1)
endif()
endwhile()
endif()
set(${OUTPUT_VAR} "")
foreach(DEP IN LISTS ALL_SERVICES)
list(APPEND ${OUTPUT_VAR} "aws-cpp-sdk-${DEP}")
endforeach()
if (NOT AWSSDK_INSTALL_AS_SHARED_LIBS)
list(APPEND ${OUTPUT_VAR} ${AWSSDK_THIRD_PARTY_LIBS} ${AWSSDK_PLATFORM_DEPS})
endif()
endmacro(AWSSDK_DETERMINE_LIBS_TO_LINK)
# output high level lib dependencies such as for transfer; sqs; dynamodb etc.
macro(AWSSDK_LIB_DEPS HIGH_LEVEL_LIB_NAME OUTPUT_VAR)
get_dependencies_for_sdk(${HIGH_LEVEL_LIB_NAME} DEPENDENCY_LIST)
if (DEPENDENCY_LIST)
string(REPLACE "," ";" ${OUTPUT_VAR} ${DEPENDENCY_LIST})
list(APPEND ALL_SERVICES ${LIST_RESULT})
endif()
list(APPEND ${OUTPUT_VAR} "core")
list(REMOVE_DUPLICATES ${OUTPUT_VAR})
endmacro(AWSSDK_LIB_DEPS)
if (AWSSDK_FIND_COMPONENTS)
#AWSSDK_LINK_LIBRARIES includes all the libraries (including dependencies) used by SDK and needed by customer application when doing linking.
#It only comes with COMPONENTS when doing find_package in customer application. e.g. find_package(AWSSDK REQUIRED COMPONENT s3 ec2)
#While SDK will resolve all the dependencies for customer application by doing find_package when COMPONENTS are specified,
#there is no need to add those dependencies into AWSSDK_LINK_LIBRARIES. Dependencies in AWSSDK_LINK_LIBRARIES will also become a problem when
#customer specified CMAKE_PREFIX_PATH and set it with non-default CMake search directories for dependencies when building SDK. In this case, when building customer
#application, target_link_libraries(target ${AWSSDK_LINK_LIBRARIES}) will fail to find the dependencies even when you specify CMAKE_PREFIX_PATH to the same directories.
#See https://github.com/aws/aws-sdk-cpp/issues/1279
#Because CMAKE_PREFIX_PATH is used for find_package, find_dependency, find_library, etc, but not target_link_libraries.
#Well, you could still solve it by adding an additional target_link_directories call before target_link_libraries, whereas remove those dependencies from
#AWSSDK_LINK_LIBRARIES will be more convenient and less confusing.
AWSSDK_DETERMINE_LIBS_TO_LINK(AWSSDK_FIND_COMPONENTS AWSSDK_LINK_LIBRARIES)
message(STATUS "Components specified for AWSSDK: ${AWSSDK_FIND_COMPONENTS}, application wll be depending on libs: ${AWSSDK_LINK_LIBRARIES}")
# platform dependencies will be resolved automatically when doing find_package(aws-cpp-sdk-core).
list(REMOVE_ITEM AWSSDK_LINK_LIBRARIES ${AWSSDK_PLATFORM_DEPS})
# third_party dependencies will be resolved automatically when doing fidn_package(aws-cpp-sdk-core) as well.
list(REMOVE_ITEM AWSSDK_LINK_LIBRARIES ${AWSSDK_THIRD_PARTY_LIBS})
set(AWSSDK_TARGETS ${AWSSDK_LINK_LIBRARIES})
list(REVERSE AWSSDK_TARGETS)
foreach(TARGET IN LISTS AWSSDK_TARGETS)
message(STATUS "Try finding ${TARGET}")
find_package(${TARGET} REQUIRED)
message(STATUS "Found ${TARGET}")
endforeach()
endif()
set(AWSSDK_INCLUDE_DIRS ${AWSSDK_INCLUDE_DIR})
set(AWSSDK_LIBRARIES ${AWSSDK_LINK_LIBRARIES})

158
support/aws-sdk-cpp-master/cmake/build_external.cmake Normal file
View File

@@ -0,0 +1,158 @@
# The NDK does not provide any http or crypto functionality out of the box; we build versions of zlib, openssl, and curl to account for this.
if(BUILD_CURL OR BUILD_OPENSSL OR BUILD_ZLIB)
include(ExternalProject)
set(EXTERNAL_CXX_FLAGS "-Wno-unused-private-field")
set(EXTERNAL_C_FLAGS "")
set(BASE_SDK_DIR ${CMAKE_BINARY_DIR} CACHE STRING "Android build" FORCE)
# we patch the install process for each dependency to match what we need for 3rd party installation
set(EXTERNAL_INSTALL_DIR ${CMAKE_BINARY_DIR}/external)
# zlib
if(BUILD_ZLIB)
set(ZLIB_SOURCE_DIR ${CMAKE_BINARY_DIR}/zlib CACHE INTERNAL "zlib source dir")
set(ZLIB_INSTALL_DIR ${EXTERNAL_INSTALL_DIR}/zlib CACHE INTERNAL "zlib install dir")
set(ZLIB_INCLUDE_DIR ${ZLIB_INSTALL_DIR}/include/zlib CACHE INTERNAL "zlib include dir")
set(ZLIB_LIBRARY_DIR ${ZLIB_INSTALL_DIR}/lib CACHE INTERNAL "zlib library dir")
set( ZLIB_INCLUDE_FLAGS "-isystem ${ZLIB_INCLUDE_DIR}" CACHE INTERNAL "compiler flags to find zlib includes")
set( ZLIB_LINKER_FLAGS "-L${ZLIB_LIBRARY_DIR}" CACHE INTERNAL "linker flags to find zlib")
#zlib
#based on http://stackoverflow.com/questions/16842218/how-to-use-cmake-externalproject-add-or-alternatives-in-a-cross-platform-way
#likely, some of the things here are unnecessary
ExternalProject_Add(ZLIB
SOURCE_DIR ${ZLIB_SOURCE_DIR}
URL https://sdk.amazonaws.com/cpp/builds/zlib-1.2.11.tar.gz
URL_HASH "SHA256=c3e5e9fdd5004dcb542feda5ee4f0ff0744628baf8ed2dd5d66f8ca1197cb1a1"
PATCH_COMMAND ""
CMAKE_ARGS
-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-DCMAKE_ANDROID_NDK_TOOLCHAIN_VERSION=${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}
-DANDROID_NATIVE_API_LEVEL=${ANDROID_NATIVE_API_LEVEL}
-DANDROID_ABI=${ANDROID_ABI}
-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN}
-DANDROID_STL=${ANDROID_STL}
-DCMAKE_INSTALL_PREFIX=${ZLIB_INSTALL_DIR}
-DCMAKE_CXX_FLAGS=${EXTERNAL_CXX_FLAGS}
-DCMAKE_C_FLAGS=${EXTERNAL_C_FLAGS}
-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-DBUILD_SHARED_LIBS=0
)
if(UNIX)
set(ZLIB_NAME libz)
else()
set(ZLIB_NAME zlib)
endif()
add_library(zlib UNKNOWN IMPORTED)
set_property(TARGET zlib PROPERTY IMPORTED_LOCATION ${ZLIB_LIBRARY_DIR}/${ZLIB_NAME}.a)
set(ZLIB_LIBRARIES "${ZLIB_LIBRARY_DIR}/${ZLIB_NAME}.a")
set(CURL_ZLIB_DEPENDENCY "ZLIB")
endif()
# OpenSSL
if(BUILD_OPENSSL)
set(OPENSSL_SOURCE_DIR ${CMAKE_BINARY_DIR}/openssl-src CACHE INTERNAL "openssl source dir")
set(OPENSSL_INSTALL_DIR ${EXTERNAL_INSTALL_DIR}/openssl CACHE INTERNAL "openssl install dir")
set(OPENSSL_INCLUDE_DIR ${OPENSSL_INSTALL_DIR}/include CACHE INTERNAL "openssl include dir")
set(OPENSSL_LIBRARY_DIR ${OPENSSL_INSTALL_DIR}/lib CACHE INTERNAL "openssl library dir")
set(OPENSSL_CXX_FLAGS "${EXTERNAL_CXX_FLAGS} -fPIE" CACHE INTERNAL "openssl")
set(OPENSSL_C_FLAGS "${EXTERNAL_C_FLAGS} -fPIE" CACHE INTERNAL "openssl")
if(ANDROID_ABI STREQUAL "x86_64")
set(OPENSSL_C_FLAGS "${OPENSSL_C_FLAGS} -DOPENSSL_NO_INLINE_ASM" CACHE INTERNAL "openssl")
endif()
set(OPENSSL_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fPIE -pie" CACHE INTERNAL "openssl")
set(OPENSSL_INCLUDE_FLAGS "-isystem ${OPENSSL_INCLUDE_DIR} -isystem ${OPENSSL_INCLUDE_DIR}/openssl" CACHE INTERNAL "compiler flags to find openssl includes")
set(OPENSSL_LINKER_FLAGS "-L${OPENSSL_LIBRARY_DIR}" CACHE INTERNAL "linker flags to find openssl")
ExternalProject_Add(OPENSSL
SOURCE_DIR ${OPENSSL_SOURCE_DIR}
GIT_REPOSITORY https://github.com/openssl/openssl.git
GIT_TAG e216bf9d7ca761718f34e8b3094fcb32c7a143e4 # 1.0.2j
UPDATE_COMMAND ""
PATCH_COMMAND cd ${CMAKE_BINARY_DIR} && python ${AWS_NATIVE_SDK_ROOT}/android-build/configure_openssl_cmake.py --source ${AWS_NATIVE_SDK_ROOT} --dest ${OPENSSL_SOURCE_DIR}
CMAKE_ARGS
-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-DCMAKE_ANDROID_NDK_TOOLCHAIN_VERSION=${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}
-DANDROID_NATIVE_API_LEVEL=${ANDROID_NATIVE_API_LEVEL}
-DANDROID_ABI=${ANDROID_ABI}
-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN}
-DANDROID_STL=${ANDROID_STL}
-DCMAKE_INSTALL_PREFIX=${OPENSSL_INSTALL_DIR}
-DCMAKE_CXX_FLAGS=${OPENSSL_CXX_FLAGS}
-DCMAKE_C_FLAGS=${OPENSSL_C_FLAGS}
-DCMAKE_EXE_LINKER_FLAGS=${OPENSSL_EXE_LINKER_FLAGS}
-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-DBUILD_SHARED_LIBS=0
)
add_library(ssl UNKNOWN IMPORTED)
set_property(TARGET ssl PROPERTY IMPORTED_LOCATION ${OPENSSL_LIBRARY_DIR}/libssl.a)
add_library(crypto UNKNOWN IMPORTED)
set_property(TARGET crypto PROPERTY IMPORTED_LOCATION ${OPENSSL_LIBRARY_DIR}/libcrypto.a)
set(OPENSSL_LIBRARIES "${OPENSSL_LIBRARY_DIR}/libssl.a;${OPENSSL_LIBRARY_DIR}/libcrypto.a")
set(CURL_OPENSSL_DEPENDENCY "OPENSSL")
endif()
# curl
if(BUILD_CURL)
set(CURL_SOURCE_DIR ${CMAKE_BINARY_DIR}/curl CACHE INTERNAL "libcurl source dir")
set(CURL_INSTALL_DIR ${EXTERNAL_INSTALL_DIR}/curl CACHE INTERNAL "libcurl install dir")
set(CURL_INCLUDE_DIR ${CURL_INSTALL_DIR}/include CACHE INTERNAL "libcurl include dir")
set(CURL_LIBRARY_DIR ${CURL_INSTALL_DIR}/lib CACHE INTERNAL "libcurl library dir")
set( CURL_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS}" CACHE INTERNAL "" )
set( CURL_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}" CACHE INTERNAL "" )
set( CURL_CXX_FLAGS "${EXTERNAL_CXX_FLAGS} ${OPENSSL_INCLUDE_FLAGS} ${ZLIB_INCLUDE_FLAGS} -Wno-unused-value -fPIE ${ZLIB_LINKER_FLAGS} ${OPENSSL_LINKER_FLAGS}" CACHE INTERNAL "")
set( CURL_C_FLAGS "${EXTERNAL_C_FLAGS} ${OPENSSL_INCLUDE_FLAGS} ${ZLIB_INCLUDE_FLAGS} -Wno-unused-value -fPIE ${ZLIB_LINKER_FLAGS} ${OPENSSL_LINKER_FLAGS}" CACHE INTERNAL "")
set( CURL_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fPIE -pie ${ZLIB_LINKER_FLAGS} ${OPENSSL_LINKER_FLAGS}" CACHE INTERNAL "" )
if(ZLIB_LIBRARIES)
set(CURL_USE_ZLIB "ON")
else()
set(CURL_USE_ZLIB "OFF")
endif()
ExternalProject_Add(CURL
DEPENDS ${CURL_OPENSSL_DEPENDENCY} ${CURL_ZLIB_DEPENDENCY}
SOURCE_DIR ${CURL_SOURCE_DIR}
GIT_REPOSITORY https://github.com/bagder/curl.git
GIT_TAG 44b9b4d4f56d6f6de92c89636994c03984e9cd01 # 7.52.1
UPDATE_COMMAND ""
PATCH_COMMAND ""
CMAKE_ARGS
-C ${AWS_NATIVE_SDK_ROOT}/android-build/CurlAndroidCrossCompile.cmake
-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-DCMAKE_ANDROID_NDK_TOOLCHAIN_VERSION=${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}
-DANDROID_NATIVE_API_LEVEL=${ANDROID_NATIVE_API_LEVEL}
-DANDROID_ABI=${ANDROID_ABI}
-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN}
-DANDROID_STL=${ANDROID_STL}
-DCMAKE_INSTALL_PREFIX=${CURL_INSTALL_DIR}
-DCMAKE_CXX_FLAGS=${CURL_CXX_FLAGS}
-DCMAKE_C_FLAGS=${CURL_C_FLAGS}
-DCMAKE_STATIC_LINKER_FLAGS=${CURL_STATIC_LINKER_FLAGS}
-DCMAKE_SHARED_LINKER_FLAGS=${CURL_SHARED_LINKER_FLAGS}
-DCMAKE_EXE_LINKER_FLAGS=${CURL_EXE_LINKER_FLAGS}
-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-DOPENSSL_ROOT_DIR=${OPENSSL_SOURCE_DIR}
-DOPENSSL_INCLUDE_DIR=${OPENSSL_INCLUDE_DIR}
-DCURL_STATICLIB=ON
-DBUILD_CURL_EXE=ON
-DBUILD_CURL_TESTS=OFF
-DCURL_ZLIB=${CURL_USE_ZLIB}
)
add_library(curl UNKNOWN IMPORTED)
set_property(TARGET curl PROPERTY IMPORTED_LOCATION ${CURL_LIBRARY_DIR}/libcurl.a)
set(CURL_LIBRARIES "${CURL_LIBRARY_DIR}/libcurl.a")
endif()
endif()

165
support/aws-sdk-cpp-master/cmake/compiler_settings.cmake Normal file
View File

@@ -0,0 +1,165 @@
# Compiler recognition
set(COMPILER_MSVC 0)
set(COMPILER_GCC 0)
set(COMPILER_CLANG 0)
# ToDo: extend as necessary and remove common assumptions
if(MSVC)
set(COMPILER_MSVC 1)
else()
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(COMPILER_CLANG 1)
else()
set(COMPILER_GCC 1)
endif()
set(USE_GCC_FLAGS 1)
endif()
function(set_compiler_flags target)
if(NOT MSVC)
set_gcc_flags()
target_compile_options(${target} PRIVATE "${AWS_COMPILER_FLAGS}")
string(REPLACE ";" " " _TMP "${AWS_COMPILER_FLAGS}")
set(PKG_CONFIG_CFLAGS "${_TMP}" CACHE INTERNAL "C++ compiler flags which affect the ABI")
endif()
endfunction()
function(set_compiler_warnings target)
if(NOT MSVC)
set_gcc_warnings()
target_compile_options(${target} PRIVATE "${AWS_COMPILER_WARNINGS}")
endif()
endfunction()
macro(set_gcc_flags)
list(APPEND AWS_COMPILER_FLAGS "-fno-exceptions" "-std=c++${CPP_STANDARD}")
if(NOT BUILD_SHARED_LIBS)
list(APPEND AWS_COMPILER_FLAGS "-fPIC")
endif()
if(NOT ENABLE_RTTI)
list(APPEND AWS_COMPILER_FLAGS "-fno-rtti")
endif()
if(MINIMIZE_SIZE AND COMPILER_GCC)
list(APPEND AWS_COMPILER_FLAGS "-s")
endif()
if(NOT BUILD_SHARED_LIBS AND NOT ENABLE_VIRTUAL_OPERATIONS)
list(APPEND AWS_COMPILER_FLAGS "-ffunction-sections;-fdata-sections")
endif()
endmacro()
macro(set_gcc_warnings)
#list(APPEND AWS_COMPILER_WARNINGS "-Wall" "-Werror" "-pedantic" "-Wextra")
list(APPEND AWS_COMPILER_WARNINGS "-Wall" "-pedantic" "-Wextra")
if(COMPILER_CLANG)
if(PLATFORM_ANDROID)
# when using clang with libc and API lower than 21 we need to include Android support headers and ignore the gnu-include-next warning.
if(ANDROID_STL MATCHES "libc" AND ANDROID_NATIVE_API_LEVEL_NUM LESS "21")
# NDK lower than 12 doesn't support ignoring the gnu-include-next warning so we need to disable pedantic mode.
if(NDK_RELEASE_NUMBER LESS "12000")
string(REGEX REPLACE "-pedantic" "" AWS_COMPILER_WARNINGS "${AWS_COMPILER_WARNINGS}")
else()
list(APPEND AWS_COMPILER_WARNINGS "-Wno-gnu-include-next")
endif()
endif()
endif()
endif()
endmacro()
macro(set_msvc_flags)
if(MSVC)
# Put all runtime outputs, including DLLs, executables into one directory, so as to avoid copying DLLs.
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
# Based on the FORCE_SHARED_CRT and BUILD_SHARED_LIBS options, make sure our compile/link flags bring in the right CRT library
# modified from gtest's version; while only the else clause is actually necessary, do both for completeness/future-proofing
foreach (var
CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
if(BUILD_SHARED_LIBS OR FORCE_SHARED_CRT)
string(REPLACE "/MT" "/MD" ${var} "${${var}}")
else()
string(REPLACE "/MD" "/MT" ${var} "${${var}}")
endif()
endforeach()
# enable parallel builds
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
# some of the clients are exceeding the 16-bit code section limit when building x64 debug, so use /bigobj when we build
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
if(NOT ENABLE_RTTI)
string(REGEX REPLACE "/GR " " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-")
endif()
# special windows build options:
# debug info: pdbs with dlls, embedded in static libs
# release optimisations to purely focus on size, override debug info settings as necessary
if(BUILD_SHARED_LIBS)
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
else()
if(CMAKE_CXX_FLAGS MATCHES "/Zi")
string(REGEX REPLACE "/Zi" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
endif()
if(CMAKE_CXX_FLAGS_DEBUG MATCHES "/Zi")
message(STATUS "Clearing pdb setting")
string(REGEX REPLACE "/Zi" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
endif()
# put Z7 in config-specific flags so we can strip from release if we're concerned about size
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Z7")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Z7")
endif()
if(MINIMIZE_SIZE)
# strip debug info from release
string(REGEX REPLACE "/Z[a-zA-Z0-9]" "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
string(REGEX REPLACE "/DEBUG" "" CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
# strip optimization settings and replace with
string(REGEX REPLACE "/O[a-zA-Z0-9]*" "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
# pure size flags
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O1 /Ob0 /Os")
endif()
endif()
endmacro()
macro(set_msvc_warnings)
if(MSVC)
#remove bogus errors at generation time if these variables haven't been manually set
if(NOT CMAKE_CONFIGURATION_TYPES)
set(CMAKE_CONFIGURATION_TYPES "Debug;Release;MinSizeRel;RelWithDebInfo")
endif()
if(NOT CMAKE_CXX_FLAGS_DEBUGOPT)
set(CMAKE_CXX_FLAGS_DEBUGOPT "")
endif()
if(NOT CMAKE_EXE_LINKER_FLAGS_DEBUGOPT)
set(CMAKE_EXE_LINKER_FLAGS_DEBUGOPT "")
endif()
if(NOT CMAKE_SHARED_LINKER_FLAGS_DEBUGOPT)
set(CMAKE_SHARED_LINKER_FLAGS_DEBUGOPT "")
endif()
# warnings as errors, max warning level (4)
if(NOT CMAKE_CXX_FLAGS MATCHES "/WX")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
endif()
# taken from http://stackoverflow.com/questions/2368811/how-to-set-warning-level-in-cmake
if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
endif()
endif(MSVC)
endmacro()

92
support/aws-sdk-cpp-master/cmake/dependencies.cmake Normal file
View File

@@ -0,0 +1,92 @@
# from http://stackoverflow.com/questions/34637980/cmake-sort-a-list-of-target-considering-their-dependencies
define_property(TARGET PROPERTY LINK_LIBRARIES_ALL
BRIEF_DOCS "List of all targets, linked to this one"
FULL_DOCS "List of all targets, linked to this one"
)
# Compute list of all target links (direct and indirect) for given library
# Result is stored in LINK_LIBRARIES_ALL target property.
function(compute_links lib)
if(${lib}_IN_PROGRESS)
message(FATAL_ERROR "Circular dependency for library '${lib}'")
endif()
# Immediately return if output property is already set.
get_property(complete TARGET ${lib} PROPERTY LINK_LIBRARIES_ALL SET)
if(complete)
return()
endif()
# Initialize output property.
set_property(TARGET ${lib} PROPERTY LINK_LIBRARIES_ALL "")
set(${lib}_IN_PROGRESS 1) # Prevent recursion for the same lib
get_target_property(links ${lib} LINK_LIBRARIES)
if(NOT links)
return() # Do not iterate over `-NOTFOUND` value in case of absence of the property.
endif()
# For each direct link append it and its links
foreach(link ${links})
if(TARGET ${link}) # Collect only target links
compute_links(${link})
get_target_property(link_links_all ${link} LINK_LIBRARIES_ALL)
set_property(TARGET ${lib} APPEND PROPERTY
LINK_LIBRARIES_ALL ${link} ${link_links_all}
)
elseif(link MATCHES "$<")
message(STATUS "Library '${lib}' uses link '${link}'.")
message(FATAL_ERROR "Algorithm doesn't work with generator expressions.")
endif()
endforeach(link ${links})
# Remove duplicates
get_target_property(links_all ${lib} LINK_LIBRARIES_ALL)
list(REMOVE_DUPLICATES links_all)
set_property(TARGET ${lib} PROPERTY LINK_LIBRARIES_ALL ${links_all})
endfunction()
# Sort given list of targets, so for any target its links come before the target itself.
#
# Uses selection sort (stable).
function(sort_links targets_list)
# Special case of empty input list. Futher code assumes list to be non-empty.
if(NOT ${targets_list})
return()
endif()
foreach(link ${${targets_list}})
compute_links(${link})
endforeach()
set(output_list)
set(current_input_list ${${targets_list}})
list(LENGTH current_input_list current_len)
while(NOT current_len EQUAL 1)
# Assume first element as minimal
list(GET current_input_list 0 min_elem)
set(min_index 0)
get_target_property(min_links ${min_elem} LINK_LIBRARIES_ALL)
# Check that given element is actually minimal
set(index 0)
foreach(link ${current_input_list})
if(index) # First iteration should always fail, so skip it.
list(FIND min_links ${link} find_index)
if(NOT find_index EQUAL "-1")
# Choose linked library as new minimal element.
set(min_elem ${link})
set(min_index ${index})
get_target_property(min_links ${min_elem} LINK_LIBRARIES_ALL)
endif(NOT find_index EQUAL "-1")
endif()
math(EXPR index "${index}+1")
endforeach(link ${current_input_list})
# Move minimal element from the input list to the output one.
list(APPEND output_list ${min_elem})
list(REMOVE_AT current_input_list ${min_index})
math(EXPR current_len "${current_len}-1")
endwhile()
# Directly append the only element in the current input list to the resulted variable.
set(${targets_list} ${output_list} ${current_input_list} PARENT_SCOPE)
endfunction(sort_links)

127
support/aws-sdk-cpp-master/cmake/external_dependencies.cmake Normal file
View File

@@ -0,0 +1,127 @@
# Zlib
if(PLATFORM_ANDROID AND ANDROID_BUILD_ZLIB)
set(BUILD_ZLIB 1)
message(STATUS " Building Zlib as part of AWS SDK")
elseif(NOT PLATFORM_WINDOWS AND NOT PLATFORM_CUSTOM)
#If zlib is required either by openssl and curl in their linking chain, we should find it.
include(FindZLIB)
if(NOT ZLIB_FOUND)
message(FATAL_ERROR "Could not find zlib")
else()
message(STATUS " Zlib library: ${ZLIB_LIBRARIES}")
endif()
endif()
# Encryption control
if(NOT NO_ENCRYPTION)
if(PLATFORM_WINDOWS)
set(ENABLE_BCRYPT_ENCRYPTION ON)
elseif(PLATFORM_LINUX OR PLATFORM_ANDROID)
set(ENABLE_OPENSSL_ENCRYPTION ON)
elseif(PLATFORM_APPLE)
set(ENABLE_COMMONCRYPTO_ENCRYPTION ON)
endif()
else()
set(ENABLE_INJECTED_ENCRYPTION ON)
endif()
if(ENABLE_BCRYPT_ENCRYPTION)
add_definitions(-DENABLE_BCRYPT_ENCRYPTION)
set(CRYPTO_LIBS Bcrypt)
set(CRYPTO_LIBS_ABSTRACT_NAME Bcrypt)
message(STATUS "Encryption: Bcrypt")
elseif(ENABLE_OPENSSL_ENCRYPTION)
add_definitions(-DENABLE_OPENSSL_ENCRYPTION)
message(STATUS "Encryption: Openssl")
if(PLATFORM_ANDROID AND ANDROID_BUILD_OPENSSL)
set(BUILD_OPENSSL 1)
message(STATUS " Building Openssl as part of AWS SDK")
else()
include(FindOpenSSL)
if(NOT OPENSSL_FOUND)
message(FATAL_ERROR "Could not find openssl")
else()
message(STATUS " Openssl include directory: ${OPENSSL_INCLUDE_DIR}")
message(STATUS " Openssl library: ${OPENSSL_LIBRARIES}")
endif()
List(APPEND EXTERNAL_DEPS_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR})
endif()
set(CRYPTO_LIBS ${OPENSSL_LIBRARIES} ${ZLIB_LIBRARIES})
# ssl depends on libcrypto
set(CRYPTO_LIBS_ABSTRACT_NAME crypto ssl z)
elseif(ENABLE_COMMONCRYPTO_ENCRYPTION)
add_definitions(-DENABLE_COMMONCRYPTO_ENCRYPTION)
message(STATUS "Encryption: CommonCrypto")
elseif(ENABLE_INJECTED_ENCRYPTION)
message(STATUS "Encryption: None")
message(STATUS "You will need to inject an encryption implementation before making any http requests!")
endif()
# Http client control
if(NOT NO_HTTP_CLIENT)
if(PLATFORM_WINDOWS)
if(FORCE_CURL)
set(ENABLE_CURL_CLIENT 1)
else()
set(ENABLE_WINDOWS_CLIENT 1)
endif()
elseif(PLATFORM_LINUX OR PLATFORM_APPLE OR PLATFORM_ANDROID)
set(ENABLE_CURL_CLIENT 1)
endif()
if(ENABLE_CURL_CLIENT)
add_definitions(-DENABLE_CURL_CLIENT)
message(STATUS "Http client: Curl")
if(PLATFORM_ANDROID AND ANDROID_BUILD_CURL)
set(BUILD_CURL 1)
message(STATUS " Building Curl as part of AWS SDK")
else()
include(FindCURL)
if(NOT CURL_FOUND)
message(FATAL_ERROR "Could not find curl")
else()
message(STATUS " Curl include directory: ${CURL_INCLUDE_DIRS}")
message(STATUS " Curl library: ${CURL_LIBRARIES}")
endif()
List(APPEND EXTERNAL_DEPS_INCLUDE_DIRS ${CURL_INCLUDE_DIRS})
endif()
if(TEST_CERT_PATH)
message(STATUS "Setting curl cert path to ${TEST_CERT_PATH}")
add_definitions(-DTEST_CERT_PATH="\"${TEST_CERT_PATH}\"")
endif()
set(CLIENT_LIBS ${CURL_LIBRARIES})
set(CLIENT_LIBS_ABSTRACT_NAME curl)
elseif(ENABLE_WINDOWS_CLIENT)
add_definitions(-DENABLE_WINDOWS_CLIENT)
if(USE_IXML_HTTP_REQUEST_2)
add_definitions(-DENABLE_WINDOWS_IXML_HTTP_REQUEST_2_CLIENT)
set(CLIENT_LIBS msxml6 runtimeobject)
set(CLIENT_LIBS_ABSTRACT_NAME msxml6 runtimeobject)
message(STATUS "Http client: IXmlHttpRequest2")
if(BYPASS_DEFAULT_PROXY)
add_definitions(-DBYPASS_DEFAULT_PROXY)
list(APPEND CLIENT_LIBS winhttp)
list(APPEND CLIENT_LIBS_ABSTRACT_NAME winhttp)
message(STATUS "Proxy bypass is enabled via WinHttp")
endif()
else()
set(CLIENT_LIBS Wininet winhttp)
set(CLIENT_LIBS_ABSTRACT_NAME Wininet winhttp)
message(STATUS "Http client: WinHttp")
endif()
else()
message(FATAL_ERROR "No http client available for target platform and client injection not enabled (-DNO_HTTP_CLIENT=ON)")
endif()
else()
message(STATUS "You will need to inject an http client implementation before making any http requests!")
endif()
if (EXTERNAL_DEPS_INCLUDE_DIRS)
List(REMOVE_DUPLICATES EXTERNAL_DEPS_INCLUDE_DIRS)
endif()

46
support/aws-sdk-cpp-master/cmake/initialize_project_version.cmake Normal file
View File

@@ -0,0 +1,46 @@
if(GIT_FOUND)
execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git describe --abbrev=0 --tags
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
OUTPUT_VARIABLE VERSION_STRING
OUTPUT_STRIP_TRAILING_WHITESPACE)
endif()
if(NOT VERSION_STRING)
# extract it from the existing generated header file
file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/aws-cpp-sdk-core/include/aws/core/VersionConfig.h" __SDK_VERSION_LINE LIMIT_COUNT 1 REGEX "AWS_SDK_VERSION_STRING.*[0-9]+\\.[0-9]+\\.[0-9]+" )
string( REGEX MATCH "([0-9]+\\.[0-9]+\\.[0-9]+)" VERSION_STRING "${__SDK_VERSION_LINE}" )
endif()
set(PROJECT_VERSION "${VERSION_STRING}")
message(STATUS "Building project version: ${PROJECT_VERSION}")
macro(add_project name description)
set(PROJECT_NAME "${name}")
set(PROJECT_STRING "${name}_${PROJECT_VERSION}")
set(PROJECT_TARNAME "${name}-${PROJECT_VERSION}")
set(PROJECT_BUGREPORT "https://github.com/aws/aws-sdk-cpp/issues/")
set(PROJECT_DESCRIPTION "${description}")
set(PROJECT_LIBS "")
set(PROJECT_LIBS_STRING "")
foreach(library_var ${ARGN})
list(APPEND PROJECT_LIBS "${library_var}")
set(PROJECT_LIBS_STRING "${PROJECT_LIBS_STRING} ${library_var}")
endforeach()
if(POLICY CMP0028)
cmake_policy(SET CMP0028 NEW)
endif()
if(POLICY CMP0048)
cmake_policy(SET CMP0048 NEW)
endif()
if(POLICY CMP0054)
cmake_policy(SET CMP0054 NEW)
endif()
if(POLICY CMP0056)
cmake_policy(SET CMP0056 NEW)
endif()
project(${name} VERSION "${PROJECT_VERSION}" LANGUAGES CXX C)
endmacro()

24
support/aws-sdk-cpp-master/cmake/make_uninstall.cmake Normal file
View File

@@ -0,0 +1,24 @@
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0.
#
# for make uninstall
if(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/install_manifest.txt")
message(FATAL_ERROR "Cannot find install manifest: ${CMAKE_CURRENT_BINARY_DIR}/install_manifest.txt")
endif()
file(READ "${CMAKE_CURRENT_BINARY_DIR}/install_manifest.txt" files)
string(REGEX REPLACE "[\r\n]" ";" files "${files}")
foreach(file ${files})
message(STATUS "Uninstalling ${file}")
if(EXISTS "${file}")
file(REMOVE ${file})
if (EXISTS "${file}")
message(FATAL_ERROR "Problem when removing ${file}, please check your permissions")
endif()
else()
message(STATUS "File ${file} does not exist.")
endif()
endforeach()

126
support/aws-sdk-cpp-master/cmake/platform/android.cmake Normal file
View File

@@ -0,0 +1,126 @@
macro(verify_tools)
# TODO: don't do this if the user is supplying their own curl/openssl/zlib
# minimum version of cmake that
# (1) supports ExternalProject_Add URL_HASH
# (2) correctly extracts OPENSSL's version number from openssl/opensslv.h in version 1.0.2d
cmake_minimum_required (VERSION 3.1.2)
# TODO: don't do this if the user is supplying their own curl/openssl/zlib
if(NOT GIT_FOUND)
message(FATAL_ERROR "Unable to find git; git is required in order to build for Android")
endif()
endmacro()
macro(determine_stdlib_and_api)
if(ANDROID_STL MATCHES "c\\+\\+" OR NOT ANDROID_STL)
if(FORCE_SHARED_CRT OR BUILD_SHARED_LIBS)
SET(ANDROID_STL "c++_shared" CACHE STRING "" FORCE)
else()
SET(ANDROID_STL "c++_static" CACHE STRING "" FORCE)
endif()
if(NOT ANDROID_NATIVE_API_LEVEL)
set(ANDROID_NATIVE_API_LEVEL "android-21")
endif()
# API levels below 9 will not build with libc++
string(REGEX REPLACE "android-(..?)" "\\1" EXTRACTED_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}")
if(EXTRACTED_API_LEVEL LESS "9")
message(STATUS "Libc++ requires setting API level to at least 9")
set(ANDROID_NATIVE_API_LEVEL "android-9" CACHE STRING "" FORCE)
endif()
elseif(ANDROID_STL MATCHES "gnustl")
if(FORCE_SHARED_CRT OR BUILD_SHARED_LIBS)
SET(ANDROID_STL "gnustl_shared" CACHE STRING "" FORCE)
else()
SET(ANDROID_STL "gnustl_static" CACHE STRING "" FORCE)
endif()
# With gnustl, API level can go as low as 3, but let's make a reasonably modern default
if(NOT ANDROID_NATIVE_API_LEVEL)
set(ANDROID_NATIVE_API_LEVEL "android-19")
endif()
else()
message(FATAL_ERROR "Invalid value for ANDROID_STL: ${ANDROID_STL}")
endif()
string(REGEX REPLACE "android-(..?)" "\\1" ANDROID_NATIVE_API_LEVEL_NUM "${ANDROID_NATIVE_API_LEVEL}")
endmacro()
macro(apply_pre_project_platform_settings)
verify_tools()
if(NOT NDK_DIR)
set(NDK_DIR $ENV{ANDROID_NDK})
endif()
if(NOT IS_DIRECTORY "${NDK_DIR}")
message(FATAL_ERROR "Could not find Android NDK (${NDK_DIR}); either set the ANDROID_NDK environment variable or pass the path in via -DNDK_DIR=..." )
endif()
if(NOT CMAKE_TOOLCHAIN_FILE)
set(CMAKE_TOOLCHAIN_FILE "${NDK_DIR}/build/cmake/android.toolchain.cmake")
endif()
if(NOT EXISTS "${CMAKE_TOOLCHAIN_FILE}")
message(FATAL_ERROR "Could not find android.toolchain.cmake, please use an Android NDK (e.g. r19c) with a built-in cmake toolchain file or provide one by specifying CMAKE_TOOLCHAIN_FILE.")
endif()
# android-specific required overrrides
if (NOT DEFINED CUSTOM_MEMORY_MANAGEMENT)
set(CUSTOM_MEMORY_MANAGEMENT ON)
endif()
set(ANDROID_STL_FORCE_FEATURES "OFF")
# android-specific parameter defaults
if(NOT ANDROID_ABI)
set(ANDROID_ABI "armeabi-v7a")
message(STATUS "Android ABI: none specified, defaulting to ${ANDROID_ABI}")
else()
message(STATUS "Android ABI: ${ANDROID_ABI}")
endif()
if(NOT ANDROID_TOOLCHAIN)
set(ANDROID_TOOLCHAIN "clang")
message(STATUS "Android toolchain unspecified, defaulting to ${ANDROID_TOOLCHAIN}")
endif()
# CMake 3.7+ compatibility for Android NDK 13, 14
if(ANDROID_TOOLCHAIN STREQUAL "clang")
set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION "clang")
endif()
determine_stdlib_and_api()
message(STATUS "Android std lib: ${ANDROID_STL}")
message(STATUS "Android API level: ${ANDROID_NATIVE_API_LEVEL}")
add_definitions("-DDISABLE_HOME_DIR_REDIRECT")
endmacro()
macro(apply_post_project_platform_settings)
# CMAKE_FIND_ROOT_PATH_MODE_PACKAGE is set to ONLY by default, which means find_package will only search packages under ${ANDROID_NDK} (which is defined by built-in cmake toolchain file.)
# In Android NDK before and including 15c, we are not able to change CMAKE_FIND_ROOT_PATH_MODE_PACKAGE, we'd add AWS_DEPS_INSTALL_DIR to the search paths.
list(APPEND CMAKE_FIND_ROOT_PATH "${AWS_DEPS_INSTALL_DIR}")
set(SDK_INSTALL_BINARY_PREFIX "${SDK_INSTALL_BINARY_PREFIX}/${ANDROID_ABI}-api-${ANDROID_NATIVE_API_LEVEL}")
set(PLATFORM_DEP_LIBS log atomic)
set(PLATFORM_DEP_LIBS_ABSTRACT_NAME log atomic)
# Workaround for problem when ndk 13, gcc, and libc++ are used together.
# See https://www.bountysource.com/issues/38341727-stddef-h-no-such-file-or-directory
if(NOT NDK_RELEASE_NUMBER LESS "13000")
if(ANDROID_TOOLCHAIN_NAME STREQUAL "standalone" AND ANDROID_STL MATCHES "libc" AND ANDROID_STANDALONE_TOOLCHAIN)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${ANDROID_STANDALONE_TOOLCHAIN}/include/c++/4.9.x")
endif()
endif()
if(ANDROID_STL MATCHES "libc" AND ANDROID_NATIVE_API_LEVEL_NUM LESS "21")
include_directories("${NDK_DIR}/sources/android/support/include")
endif()
endmacro()

9
support/aws-sdk-cpp-master/cmake/platform/apple.cmake Normal file
View File

@@ -0,0 +1,9 @@
if(BUILD_SHARED_LIBS)
SET(SUFFIX dylib)
endif()
macro(apply_post_project_platform_settings)
set(PLATFORM_DEP_LIBS pthread)
set(PLATFORM_DEP_LIBS_ABSTRACT_NAME pthread)
endmacro()

24
support/aws-sdk-cpp-master/cmake/platform/custom.cmake Normal file
View File

@@ -0,0 +1,24 @@
if(NOT CUSTOM_PLATFORM_DIR )
message(FATAL_ERROR "Custom platforms require the CUSTOM_PLATFORM_DIR parameter to be set")
endif()
file(TO_CMAKE_PATH "${CUSTOM_PLATFORM_DIR}" __custom_platform_dir)
if(NOT IS_DIRECTORY "${__custom_platform_dir}")
message(FATAL_ERROR "${CUSTOM_PLATFORM_DIR} is not a valid directory for a custom platform")
endif()
set(__toolchain_file ${__custom_platform_dir}/${TARGET_ARCH}.toolchain.cmake)
IF(NOT (EXISTS ${__toolchain_file}))
message(FATAL_ERROR "Custom architecture target ${TARGET_ARCH} requires a cmake toolchain file at: ${__toolchain_file}")
endif()
SET(CMAKE_TOOLCHAIN_FILE ${__toolchain_file})
set(CUSTOM_PLATFORM_SOURCE_PATH "${__custom_platform_dir}/src")
list(APPEND CMAKE_MODULE_PATH "${__custom_platform_dir}/modules")
string(TOLOWER "${TARGET_ARCH}" __lower_arch)
set(SDK_INSTALL_BINARY_PREFIX ${__lower_arch})
include(${__custom_platform_dir}/${__lower_arch}_platform.cmake)
message(STATUS "Generating ${__lower_arch} build config")

53
support/aws-sdk-cpp-master/cmake/platform/linux.cmake Normal file
View File

@@ -0,0 +1,53 @@
message(STATUS "Generating linux build config")
set(SDK_INSTALL_BINARY_PREFIX "linux")
include(CheckCXXSourceCompiles)
include(CMakePushCheckState)
include(CheckLibraryExists)
set(ATOMIC_TEST_CXX_SOURCE "
#include <cstdint>
#include <atomic>
std::atomic<uintptr_t> x;
std::atomic<uintmax_t> y;
int main() {
return x + y;
}")
set(LIBATOMIC_TEST_CXX_SOURCE "
int main() {
__atomic_load_8(nullptr, 0);
return 0;
}")
macro(apply_post_project_platform_settings)
include(GNUInstallDirs)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(SDK_INSTALL_BINARY_PREFIX "${SDK_INSTALL_BINARY_PREFIX}/intel64")
else()
set(SDK_INSTALL_BINARY_PREFIX "${SDK_INSTALL_BINARY_PREFIX}/ia32")
endif()
set(PLATFORM_DEP_LIBS pthread)
set(PLATFORM_DEP_LIBS_ABSTRACT_NAME pthread)
# libatomic - some arches need to link against libatomic.so, some don't
cmake_push_check_state()
list(APPEND CMAKE_REQUIRED_FLAGS "-std=c++${CPP_STANDARD}")
check_cxx_source_compiles("${ATOMIC_TEST_CXX_SOURCE}" HAVE_ATOMICS_WITHOUT_LIBATOMIC)
if(NOT HAVE_ATOMICS_WITHOUT_LIBATOMIC)
set(CMAKE_REQUIRED_LIBRARIES atomic)
check_cxx_source_compiles("${LIBATOMIC_TEST_CXX_SOURCE}" LIBATOMIC_EXISTS)
if(LIBATOMIC_EXISTS)
check_cxx_source_compiles("${ATOMIC_TEST_CXX_SOURCE}" HAVE_ATOMICS_WITH_LIBATOMIC)
endif()
if(HAVE_ATOMICS_WITH_LIBATOMIC)
list(APPEND PLATFORM_DEP_LIBS atomic)
else()
message(FATAL_ERROR "Could not determine support for atomic operations.")
endif()
endif()
cmake_pop_check_state()
endmacro()

5
support/aws-sdk-cpp-master/cmake/platform/unix.cmake Normal file
View File

@@ -0,0 +1,5 @@
if(BUILD_SHARED_LIBS)
SET(SUFFIX so)
else()
SET(SUFFIX a)
endif()

22
support/aws-sdk-cpp-master/cmake/platform/windows.cmake Normal file
View File

@@ -0,0 +1,22 @@
message(STATUS "Generating windows build config")
set(SDK_INSTALL_BINARY_PREFIX "windows")
set(USE_WINDOWS_DLL_SEMANTICS 1)
if(BUILD_SHARED_LIBS)
SET(SUFFIX dll)
else()
SET(SUFFIX lib)
endif()
macro(apply_post_project_platform_settings)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(SDK_INSTALL_BINARY_PREFIX "${SDK_INSTALL_BINARY_PREFIX}/intel64")
else()
set(SDK_INSTALL_BINARY_PREFIX "${SDK_INSTALL_BINARY_PREFIX}/ia32")
endif()
set(PLATFORM_DEP_LIBS Userenv version ws2_32)
set(PLATFORM_DEP_LIBS_ABSTRACT_NAME Userenv version ws2_32)
endmacro()

63
support/aws-sdk-cpp-master/cmake/resolve_platform.cmake Normal file
View File

@@ -0,0 +1,63 @@
# Platform recognition
if(TARGET_ARCH)
string(TOUPPER ${TARGET_ARCH} __UPPER_TARGET_ARCH)
endif()
if("${__UPPER_TARGET_ARCH}" STREQUAL "WINDOWS" OR
"${__UPPER_TARGET_ARCH}" STREQUAL "LINUX" OR
"${__UPPER_TARGET_ARCH}" STREQUAL "APPLE" OR
"${__UPPER_TARGET_ARCH}" STREQUAL "ANDROID")
set(PLATFORM_${__UPPER_TARGET_ARCH} 1)
elseif(TARGET_ARCH)
set(PLATFORM_CUSTOM 1)
else()
message(STATUS "TARGET_ARCH not specified; inferring host OS to be platform compilation target")
if(CMAKE_HOST_WIN32)
set(PLATFORM_WINDOWS 1)
set(TARGET_ARCH "WINDOWS")
set(__UPPER_TARGET_ARCH "WINDOWS")
elseif(CMAKE_HOST_APPLE)
set(PLATFORM_APPLE 1)
set(TARGET_ARCH "APPLE")
set(__UPPER_TARGET_ARCH "APPLE")
set(CMAKE_MACOSX_RPATH TRUE)
set(CMAKE_INSTALL_RPATH "@executable_path")
elseif(CMAKE_HOST_UNIX)
set(PLATFORM_LINUX 1)
set(TARGET_ARCH "LINUX")
set(__UPPER_TARGET_ARCH "LINUX")
else()
message(FATAL_ERROR "Unknown host OS; unable to determine platform compilation target")
endif()
endif()
# directory defaults; linux overrides these on SIMPLE_INSTALL builds
# user sepficied cmake variables (cmake -DVAR=xx) will further overrides these
set(BINARY_DIRECTORY "bin")
set(LIBRARY_DIRECTORY "lib")
set(INCLUDE_DIRECTORY "include")
if(BUILD_SHARED_LIBS)
set(ARCHIVE_DIRECTORY "bin")
message(STATUS "Building AWS libraries as shared objects")
else()
set(ARCHIVE_DIRECTORY "lib")
message(STATUS "Building AWS libraries as static objects")
endif()
string(TOLOWER ${TARGET_ARCH} __LOWER_ARCH)
# default settings is unix platform
if(PLATFORM_LINUX OR PLATFORM_APPLE OR PLATFORM_ANDROID)
include(${CMAKE_CURRENT_LIST_DIR}/platform/unix.cmake)
endif()
# if not specified to custom platform, settings above will be reset by specific platform settings
if(NOT PLATFORM_CUSTOM)
include(${CMAKE_CURRENT_LIST_DIR}/platform/${__LOWER_ARCH}.cmake)
else()
include(${CMAKE_CURRENT_LIST_DIR}/platform/custom.cmake)
endif()
# only usable in .cpp files
add_definitions(-DPLATFORM_${__UPPER_TARGET_ARCH})

285
support/aws-sdk-cpp-master/cmake/sdks.cmake Normal file
View File

@@ -0,0 +1,285 @@
include(sdksCommon)
set(SDK_DEPENDENCY_BUILD_LIST "")
if(REGENERATE_CLIENTS)
message(STATUS "Checking for SDK generation requirements")
include(FindJava)
if(NOT Java_JAVA_EXECUTABLE OR NOT Java_JAVAC_EXECUTABLE)
message(FATAL_ERROR "Generating SDK clients requires a jdk 1.8 installation")
endif()
find_program(MAVEN_PROGRAM mvn)
if(NOT MAVEN_PROGRAM)
message(FATAL_ERROR "Generating SDK clients requires a maven installation")
endif()
endif()
if(BUILD_ONLY)
# Sanitize input client list, for example removing empty elements
# that may be introduced by trailing semicolons
set(BUILD_ONLY ${BUILD_ONLY})
set(SDK_BUILD_LIST ${BUILD_ONLY})
foreach(TARGET IN LISTS BUILD_ONLY)
message(STATUS "Considering ${TARGET}")
get_dependencies_for_sdk(${TARGET} DEPENDENCY_LIST)
if(DEPENDENCY_LIST)
STRING(REPLACE "," ";" LIST_RESULT ${DEPENDENCY_LIST})
foreach(DEPENDENCY IN LISTS LIST_RESULT)
list(APPEND SDK_DEPENDENCY_BUILD_LIST ${DEPENDENCY})
endforeach()
endif()
get_dependencies_for_test(${TARGET} DEPENDENCY_LIST)
if(DEPENDENCY_LIST)
STRING(REPLACE "," ";" LIST_RESULT ${DEPENDENCY_LIST})
foreach(DEPENDENCY IN LISTS LIST_RESULT)
list(APPEND SDK_DEPENDENCY_BUILD_LIST ${DEPENDENCY})
endforeach()
endif()
endforeach()
LIST(REMOVE_DUPLICATES SDK_BUILD_LIST)
LIST(REMOVE_DUPLICATES SDK_DEPENDENCY_BUILD_LIST)
else()
set(TEMP_SDK_BUILD_LIST ${GENERATED_SERVICE_LIST})
list(APPEND TEMP_SDK_BUILD_LIST "core")
list(APPEND TEMP_SDK_BUILD_LIST ${HIGH_LEVEL_SDK_LIST})
set(SDK_BUILD_LIST ${TEMP_SDK_BUILD_LIST})
# remove any missing targets from the build list, factoring in dependencies appropriately
foreach(SDK IN LISTS TEMP_SDK_BUILD_LIST)
set(REMOVE_SDK 0)
set(SDK_DIR "aws-cpp-sdk-${SDK}")
if(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${SDK_DIR}" AND NOT REGENERATE_CLIENTS)
set(REMOVE_SDK 1)
endif()
if(REMOVE_SDK)
get_sdks_depending_on(${SDK} REMOVE_LIST)
foreach(REMOVE_SDK IN LISTS REMOVE_LIST)
list(REMOVE_ITEM SDK_BUILD_LIST ${REMOVE_SDK})
endforeach()
endif()
endforeach()
endif()
# SDK_BUILD_LIST is now a list of present SDKs that can be processed unconditionally
if(ADD_CUSTOM_CLIENTS OR REGENERATE_CLIENTS)
execute_process(
COMMAND ${PYTHON_CMD} scripts/generate_sdks.py --prepareTools
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
endif()
if(ENABLE_VIRTUAL_OPERATIONS) # it could be set to 0/1 or ON/OFF
set(ENABLE_VIRTUAL_OPERATIONS_ARG "--enableVirtualOperations")
else()
set(ENABLE_VIRTUAL_OPERATIONS_ARG "")
endif()
if(REGENERATE_CLIENTS)
message(STATUS "Regenerating clients that have been selected for build.")
set(MERGED_BUILD_LIST ${SDK_BUILD_LIST})
list(APPEND MERGED_BUILD_LIST ${SDK_DEPENDENCY_BUILD_LIST})
LIST(REMOVE_DUPLICATES MERGED_BUILD_LIST)
foreach(SDK IN LISTS MERGED_BUILD_LIST)
get_c2j_date_for_service(${SDK} C2J_DATE)
get_c2j_name_for_service(${SDK} C2J_NAME)
set(SDK_C2J_FILE "${CMAKE_CURRENT_SOURCE_DIR}/code-generation/api-descriptions/${C2J_NAME}-${C2J_DATE}.normal.json")
if(EXISTS ${SDK_C2J_FILE})
message(STATUS "Clearing existing directory for ${SDK} to prepare for generation.")
file(REMOVE_RECURSE "${CMAKE_CURRENT_SOURCE_DIR}/aws-cpp-sdk-${SDK}")
execute_process(
COMMAND ${PYTHON_CMD} scripts/generate_sdks.py --serviceName ${SDK} --apiVersion ${C2J_DATE} ${ENABLE_VIRTUAL_OPERATIONS_ARG} --outputLocation ./
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
message(STATUS "Generated service: ${SDK}, version: ${C2J_DATE}")
else()
message(STATUS "Directory for ${SDK} is either missing a service definition, is a custom client, or it is not a generated client. Skipping.")
endif()
endforeach()
endif()
#at this point, if user has specified some customized clients, generate them and add them to the build here.
foreach(custom_client ${ADD_CUSTOM_CLIENTS})
message(STATUS "${custom_client}")
STRING(REGEX MATCHALL "serviceName=(.*), ?version=(.*)" CLIENT_MATCHES "${custom_client}")
set(C_LEN 0)
LIST(LENGTH CLIENT_MATCHES C_LEN)
if(CMAKE_MATCH_COUNT GREATER 0)
set(C_SERVICE_NAME ${CMAKE_MATCH_1})
set(C_VERSION ${CMAKE_MATCH_2})
set(SDK_C2J_FILE "${CMAKE_CURRENT_SOURCE_DIR}/code-generation/api-descriptions/${C_SERVICE_NAME}-${C_VERSION}.normal.json")
if(NOT (EXISTS ${SDK_C2J_FILE}))
message(FATAL_ERROR "${C_SERVICE_NAME} is required for build, but C2J file '${SDK_C2J_FILE}' is missing!")
endif()
message(STATUS "Clearing existing directory for ${C_SERVICE_NAME} to prepare for generation.")
file(REMOVE_RECURSE "${CMAKE_CURRENT_SOURCE_DIR}/aws-cpp-sdk-${C_SERVICE_NAME}")
message(STATUS "generating client for ${C_SERVICE_NAME} version ${C_VERSION}")
execute_process(
COMMAND ${PYTHON_CMD} scripts/generate_sdks.py --serviceName ${C_SERVICE_NAME} --apiVersion ${C_VERSION} ${ENABLE_VIRTUAL_OPERATIONS_ARG} --outputLocation ./
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
LIST(APPEND SDK_BUILD_LIST ${C_SERVICE_NAME})
endif()
endforeach(custom_client)
# when building a fixed target set, missing SDKs are an error
# when building "everything", we forgive missing SDKs; should this become an option instead?
if(BUILD_ONLY)
# make sure all the sdks/c2js are present; a missing sdk-directory or c2j file is a build error when building a manually-specified set
foreach(SDK IN LISTS SDK_BUILD_LIST)
set(SDK_DIR "aws-cpp-sdk-${SDK}")
if(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${SDK_DIR}")
message(FATAL_ERROR "${SDK} is required for build, but ${SDK_DIR} directory is missing!")
endif()
endforeach()
set(TEMP_SDK_DEPENDENCY_BUILD_LIST ${SDK_DEPENDENCY_BUILD_LIST})
foreach (SDK IN LISTS TEMP_SDK_DEPENDENCY_BUILD_LIST)
list(FIND SDK_BUILD_LIST ${SDK} DEPENDENCY_INDEX)
if(DEPENDENCY_INDEX LESS 0)
# test dependencies should also be built from source instead of locating by calling find_package
# which may cause version conflicts as well as double targeting built targets
set(SDK_DIR "aws-cpp-sdk-${SDK}")
if (NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${SDK_DIR}")
message(FATAL_ERROR "${SDK} is required for build, but ${SDK_DIR} directory is missing!")
endif ()
else ()
list(REMOVE_ITEM SDK_DEPENDENCY_BUILD_LIST ${SDK})
endif ()
endforeach ()
foreach (SDK IN LISTS SDK_DEPENDENCY_BUILD_LIST)
list(APPEND SDK_BUILD_LIST "${SDK}")
endforeach()
endif()
LIST(REMOVE_DUPLICATES SDK_BUILD_LIST)
LIST(REMOVE_DUPLICATES SDK_DEPENDENCY_BUILD_LIST)
function(add_sdks)
LIST(APPEND EXPORTS "")
#[[
foreach(SDK IN LISTS SDK_BUILD_LIST)
set(SDK_DIR "aws-cpp-sdk-${SDK}")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
endforeach()
]]
set(SDK_DIR "aws-cpp-sdk-core")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
#[[
set(SDK_DIR "aws-cpp-sdk-sts")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
set(SDK_DIR "aws-cpp-sdk-identity-management")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
set(SDK_DIR "aws-cpp-sdk-cognito-identity")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
set(SDK_DIR "aws-cpp-sdk-kms")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
set(SDK_DIR "aws-cpp-sdk-s3-encryption")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
set(SDK_DIR "aws-cpp-sdk-s3control")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
set(SDK_DIR "aws-cpp-sdk-text-to-speech")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
]]
set(SDK_DIR "aws-cpp-sdk-s3")
add_subdirectory("${SDK_DIR}")
LIST(APPEND EXPORTS "${SDK_DIR}")
#testing
if(ENABLE_TESTING)
add_subdirectory(testing-resources)
# android-unified-tests includes all the tests in our code base, those tests related services may not be incldued in BUILD_ONLY,
# means, those services will not be built, but will be tried to linked against with test targets, which will cause link time error.
# See https://github.com/aws/aws-sdk-cpp/issues/786. We should only build android-unified-tests when doing a full build.
if(PLATFORM_ANDROID AND NOT BUILD_SHARED_LIBS AND NOT BUILD_ONLY)
add_subdirectory(android-unified-tests)
else()
foreach(SDK IN LISTS SDK_BUILD_LIST)
get_test_projects_for_service(${SDK} TEST_PROJECTS)
if(TEST_PROJECTS)
if (NO_HTTP_CLIENT AND NOT "${SDK}" STREQUAL "core")
set(NO_HTTP_CLIENT_SKIP_INTEGRATION_TEST ON)
continue()
endif()
if (NOT ENABLE_VIRTUAL_OPERATIONS)
if ("${SDK}" STREQUAL "transfer" OR "${SDK}" STREQUAL "s3-encryption")
message(STATUS "Skip building ${SDK} integration tests because some tests need to override service operations, but ENABLE_VIRTUAL_OPERATIONS is switched off.")
continue()
endif()
endif()
STRING(REPLACE "," ";" LIST_RESULT ${TEST_PROJECTS})
foreach(TEST_PROJECT IN LISTS LIST_RESULT)
if(TEST_PROJECT)
# before we add the test, make sure all of its dependencies are present
set(ADD_TEST 1)
get_dependencies_for_test(${SDK} DEPENDENCY_LIST)
if(DEPENDENCY_LIST)
STRING(REPLACE "," ";" LIST_RESULT ${DEPENDENCY_LIST})
foreach(DEPENDENCY IN LISTS LIST_RESULT)
list(FIND SDK_BUILD_LIST ${DEPENDENCY} DEPENDENCY_INDEX)
if(DEPENDENCY_INDEX LESS 0)
message(STATUS "Removing test project ${TEST_PROJECT} due to missing dependency ${DEPENDENCY}")
set(ADD_TEST 0)
endif()
endforeach()
endif()
if(ADD_TEST)
add_subdirectory(${TEST_PROJECT})
endif()
endif()
endforeach()
endif()
endforeach()
if (NO_HTTP_CLIENT_SKIP_INTEGRATION_TEST)
message(STATUS "No http client is specified, SDK will not build integration tests")
endif()
unset(NO_HTTP_CLIENT_SKIP_INTEGRATION_TEST)
endif()
endif()
# the catch-all config needs to list all the targets in a dependency-sorted order
include(dependencies)
sort_links(EXPORTS)
# make an everything config by just including all the individual configs
file(WRITE ${CMAKE_BINARY_DIR}/aws-sdk-cpp-config.cmake "")
foreach(EXPORT_TARGET IN LISTS EXPORTS)
file(APPEND ${CMAKE_BINARY_DIR}/aws-sdk-cpp-config.cmake "include(\"\${CMAKE_CURRENT_LIST_DIR}/${EXPORT_TARGET}/${EXPORT_TARGET}-config.cmake\")\n")
endforeach()
endfunction()

168
support/aws-sdk-cpp-master/cmake/sdksCommon.cmake Normal file
View File

@@ -0,0 +1,168 @@
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0.
#
# helper function that that gives primitive map functionality by treating a colon as the key-value separator, while the list semi-colon separates pairs
# to use, pass the list-map in as a third parameter (see helper functions below)
function(get_map_element KEY VALUE_VAR)
foreach(ELEMENT_PAIR ${ARGN})
STRING(REGEX REPLACE "([^:]+):.*" "\\1" KEY_RESULT ${ELEMENT_PAIR})
if(${KEY_RESULT} STREQUAL ${KEY} )
STRING(REGEX REPLACE "[^:]+:(.*)" "\\1" VALUE_RESULT ${ELEMENT_PAIR})
set(${VALUE_VAR} "${VALUE_RESULT}" PARENT_SCOPE)
return()
endif()
endforeach()
set(${VALUE_VAR} "" PARENT_SCOPE)
endfunction(get_map_element)
# a bunch of key-value retrieval functions for the list-maps we defined above
function(get_c2j_date_for_service SERVICE_NAME C2J_DATE_VAR)
get_map_element(${SERVICE_NAME} TEMP_VAR ${C2J_LIST})
set(${C2J_DATE_VAR} "${TEMP_VAR}" PARENT_SCOPE)
endfunction()
function(get_c2j_name_for_service SERVICE_NAME C2J_NAME_VAR)
get_map_element(${SERVICE_NAME} TEMP_VAR ${C2J_SPECIAL_NAME_LIST})
if(TEMP_VAR)
set(${C2J_NAME_VAR} "${TEMP_VAR}" PARENT_SCOPE)
else()
set(${C2J_NAME_VAR} "${SERVICE_NAME}" PARENT_SCOPE)
endif()
endfunction()
function(get_test_projects_for_service SERVICE_NAME TEST_PROJECT_NAME_VAR)
get_map_element(${SERVICE_NAME} TEMP_VAR ${SDK_TEST_PROJECT_LIST})
set(${TEST_PROJECT_NAME_VAR} "${TEMP_VAR}" PARENT_SCOPE)
endfunction()
function(get_dependencies_for_sdk PROJECT_NAME DEPENDENCY_LIST_VAR)
get_map_element(${PROJECT_NAME} TEMP_VAR ${SDK_DEPENDENCY_LIST})
# "core" is the default dependency for every sdk.
# Since we removed the hand-written C2J_LIST and instead auto generating it based on models,
# and location of models may not exist or incorrect when SDK is installed and then source has been deleted by customers.
# we end up getting an incomplete C2J_LIST when customers call find_package(AWSSDK). But C2J_LIST is only used in customers code for dependencies completing.
set(${DEPENDENCY_LIST_VAR} "${TEMP_VAR},core" PARENT_SCOPE)
endfunction()
function(get_dependencies_for_test TEST_NAME DEPENDENCY_LIST_VAR)
get_map_element(${TEST_NAME} TEMP_VAR ${TEST_DEPENDENCY_LIST})
set(${DEPENDENCY_LIST_VAR} "${TEMP_VAR}" PARENT_SCOPE)
endfunction()
# returns all sdks, including itself, that depend on the supplied sdk
# this is kind of a reverse function of get_dependencies_for_sdk
function(get_sdks_depending_on SDK_NAME DEPENDING_SDKS_VAR)
set(TEMP_SDK_LIST "${SDK_NAME}")
foreach(SDK_DEP ${SDK_DEPENDENCY_LIST})
STRING(REGEX REPLACE "([^:]+):.*" "\\1" KEY_RESULT ${SDK_DEP})
STRING(REGEX REPLACE "[^:]+:(.*)" "\\1" VALUE_RESULT ${SDK_DEP})
STRING(REPLACE "," ";" LIST_RESULT ${VALUE_RESULT})
list(FIND LIST_RESULT ${SDK_NAME} FIND_INDEX)
if(FIND_INDEX GREATER -1)
list(APPEND TEMP_SDK_LIST ${KEY_RESULT})
endif()
endforeach()
set(${DEPENDING_SDKS_VAR} "${TEMP_SDK_LIST}" PARENT_SCOPE)
endfunction()
# function that automatically picks up models from <sdkrootdir>/code-generation/api-descriptions/ directory and build
# C2J_LIST needed for generation, services have multiple models will use the latest model (decided by model files' date)
# services have the name format abc.def.ghi will be renamed to ghi-def-abc (dot will not be accepted as Windows directory name )
# and put into C2J_SPECIAL_NAME_LIST, but rumtime.lex will be renamed to lex based on historical reason.
function(build_sdk_list)
file(GLOB ALL_MODEL_FILES "${CMAKE_CURRENT_SOURCE_DIR}/code-generation/api-descriptions/*-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9].normal.json")
foreach(model IN LISTS ALL_MODEL_FILES)
get_filename_component(modelName "${model}" NAME)
STRING(REGEX MATCH "([0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9])" date "${modelName}")
STRING(REGEX REPLACE "-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9].normal.json" "" svc "${modelName}")
#special svc name conversion, e.g: runtime.lex->lex; abc.def.ghi->ghi-def-abc
if ("${svc}" STREQUAL "runtime.lex")
LIST(APPEND C2J_SPECIAL_NAME_LIST "lex:runtime.lex")
set(svc "lex")
elseif ("${svc}" STREQUAL "transfer")
LIST(APPEND C2J_SPECIAL_NAME_LIST "awstransfer:transfer")
set(svc "awstransfer")
elseif ("${svc}" STREQUAL "transcribe-streaming")
LIST(APPEND C2J_SPECIAL_NAME_LIST "transcribestreaming:transcribe-streaming")
set(svc "transcribestreaming")
elseif("${svc}" MATCHES "\\.")
string(REPLACE "." ";" nameParts ${svc})
LIST(REVERSE nameParts)
string(REPLACE ";" "-" tmpSvc "${nameParts}")
LIST(APPEND C2J_SPECIAL_NAME_LIST "${tmpSvc}:${svc}")
set(svc "${tmpSvc}")
elseif("${svc}" STREQUAL "ec2")
if(PLATFORM_ANDROID AND CMAKE_HOST_WIN32) # ec2 isn't building for android on windows atm due to an internal compiler error, TODO: investigate further
continue()
endif()
endif()
get_map_element(${svc} existingDate ${C2J_LIST})
if ("${existingDate}" STREQUAL "")
LIST(APPEND C2J_LIST "${svc}:${date}")
elseif(${existingDate} STRLESS ${date})
LIST(REMOVE_ITEM C2J_LIST "${svc}:${existingDate}")
LIST(APPEND C2J_LIST "${svc}:${date}")
endif()
endforeach()
set(C2J_LIST "${C2J_LIST}" PARENT_SCOPE)
set(C2J_SPECIAL_NAME_LIST "${C2J_SPECIAL_NAME_LIST}" PARENT_SCOPE)
endfunction()
set(HIGH_LEVEL_SDK_LIST "")
list(APPEND HIGH_LEVEL_SDK_LIST "access-management")
list(APPEND HIGH_LEVEL_SDK_LIST "identity-management")
list(APPEND HIGH_LEVEL_SDK_LIST "queues")
list(APPEND HIGH_LEVEL_SDK_LIST "transfer")
list(APPEND HIGH_LEVEL_SDK_LIST "s3-encryption")
list(APPEND HIGH_LEVEL_SDK_LIST "text-to-speech")
set(SDK_TEST_PROJECT_LIST "")
list(APPEND SDK_TEST_PROJECT_LIST "cognito-identity:aws-cpp-sdk-cognitoidentity-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "core:aws-cpp-sdk-core-tests")
list(APPEND SDK_TEST_PROJECT_LIST "dynamodb:aws-cpp-sdk-dynamodb-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "ec2:aws-cpp-sdk-ec2-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "elasticfilesystem:aws-cpp-sdk-elasticfilesystem-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "identity-management:aws-cpp-sdk-identity-management-tests")
list(APPEND SDK_TEST_PROJECT_LIST "kinesis:aws-cpp-sdk-kinesis-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "lambda:aws-cpp-sdk-lambda-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "logs:aws-cpp-sdk-logs-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "mediastore-data:aws-cpp-sdk-mediastore-data-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "redshift:aws-cpp-sdk-redshift-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "s3:aws-cpp-sdk-s3-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "s3-encryption:aws-cpp-sdk-s3-encryption-tests,aws-cpp-sdk-s3-encryption-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "s3control:aws-cpp-sdk-s3control-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "sqs:aws-cpp-sdk-sqs-integration-tests")
list(APPEND SDK_TEST_PROJECT_LIST "transfer:aws-cpp-sdk-transfer-tests")
list(APPEND SDK_TEST_PROJECT_LIST "text-to-speech:aws-cpp-sdk-text-to-speech-tests,aws-cpp-sdk-polly-sample")
list(APPEND SDK_TEST_PROJECT_LIST "transcribestreaming:aws-cpp-sdk-transcribestreaming-integration-tests")
set(SDK_DEPENDENCY_LIST "")
list(APPEND SDK_DEPENDENCY_LIST "access-management:iam,cognito-identity,core")
list(APPEND SDK_DEPENDENCY_LIST "identity-management:cognito-identity,sts,core")
list(APPEND SDK_DEPENDENCY_LIST "queues:sqs,core")
list(APPEND SDK_DEPENDENCY_LIST "s3-encryption:s3,kms,core")
list(APPEND SDK_DEPENDENCY_LIST "text-to-speech:polly,core")
list(APPEND SDK_DEPENDENCY_LIST "transfer:s3,core")
set(TEST_DEPENDENCY_LIST "")
list(APPEND TEST_DEPENDENCY_LIST "cognito-identity:access-management,iam,core")
list(APPEND TEST_DEPENDENCY_LIST "identity-management:cognito-identity,sts,core")
list(APPEND TEST_DEPENDENCY_LIST "lambda:access-management,cognito-identity,iam,kinesis,core")
list(APPEND TEST_DEPENDENCY_LIST "s3-encryption:s3,kms,core")
list(APPEND TEST_DEPENDENCY_LIST "s3control:s3,access-management,cognito-identity,iam,core")
list(APPEND TEST_DEPENDENCY_LIST "sqs:access-management,cognito-identity,iam,core")
list(APPEND TEST_DEPENDENCY_LIST "text-to-speech:polly,core")
list(APPEND TEST_DEPENDENCY_LIST "transfer:s3,core")
build_sdk_list()
# make a list of the generated clients
set(GENERATED_SERVICE_LIST "")
foreach(GENERATED_C2J_SERVICE IN LISTS C2J_LIST)
STRING(REGEX REPLACE "([^:]+):.*" "\\1" SERVICE_RESULT ${GENERATED_C2J_SERVICE})
list(APPEND GENERATED_SERVICE_LIST ${SERVICE_RESULT})
list(APPEND SDK_DEPENDENCY_LIST "${SERVICE_RESULT}:core")
endforeach()

84
support/aws-sdk-cpp-master/cmake/setup_cmake_find_module.cmake Normal file
View File

@@ -0,0 +1,84 @@
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0.
add_project(AWSSDK "User friendly cmake creator")
# create a new version file for AWSSDK, then find_package will return latest PACKAGE_VERSION
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
file(APPEND
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
"set(AWSSDK_INSTALL_AS_SHARED_LIBS ${BUILD_SHARED_LIBS})\n")
file(WRITE
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/platformDeps.cmake"
"# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0.\n"
"set(AWSSDK_PLATFORM_DEPS_LIBS ${PLATFORM_DEP_LIBS_ABSTRACT_NAME})\n"
"set(AWSSDK_CLIENT_LIBS ${CLIENT_LIBS_ABSTRACT_NAME})\n"
"set(AWSSDK_CRYPTO_LIBS ${CRYPTO_LIBS_ABSTRACT_NAME})\n"
"set(AWSSDK_THIRD_PARTY_LIBS ${THIRD_PARTY_LIBS})\n"
"set(AWSSDK_ADDITIONAL_LIBS ${AWS_SDK_ADDITIONAL_LIBRARIES_ABSTRACT_NAME})\n"
"set(AWSSDK_INSTALL_LIBDIR ${LIBRARY_DIRECTORY})\n"
"set(AWSSDK_INSTALL_BINDIR ${BINARY_DIRECTORY})\n"
"set(AWSSDK_INSTALL_INCLUDEDIR ${INCLUDE_DIRECTORY})\n"
"set(AWSSDK_INSTALL_ARCHIVEDIR ${ARCHIVE_DIRECTORY})\n"
)
if (NOT SIMPLE_INSTALL)
file(APPEND
"${CMAKE_CURRENT_BINARY_DIR}/platformDeps.cmake"
"set(AWSSDK_PLATFORM_PREFIX ${SDK_INSTALL_BINARY_PREFIX}/${PLATFORM_INSTALL_QUALIFIER})\n")
endif()
# copy version file to destination
install(
FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
DESTINATION "${LIBRARY_DIRECTORY}/cmake/${PROJECT_NAME}")
# platform external dependencies
install(
FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/platformDeps.cmake"
DESTINATION "${LIBRARY_DIRECTORY}/cmake/${PROJECT_NAME}/")
# copy all cmake files to destination, these files include useful macros, functions and variables for users.
# useful macros and variables will be included in this cmake file for user to use
install(DIRECTORY "${AWS_NATIVE_SDK_ROOT}/cmake/" DESTINATION "${LIBRARY_DIRECTORY}/cmake/${PROJECT_NAME}")
# copy third party dependencies
if (BUILD_DEPS)
if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
set(CMAKE_INSTALL_LIBDIR lib)
endif()
if (NOT DEFINED CMAKE_INSTALL_BINDIR)
set(CMAKE_INSTALL_BINDIR bin)
endif()
if (EXISTS "${AWS_DEPS_INSTALL_DIR}/include")
install(DIRECTORY "${AWS_DEPS_INSTALL_DIR}/include/" DESTINATION "${INCLUDE_DIRECTORY}")
endif()
if (EXISTS "${AWS_DEPS_INSTALL_DIR}/${CMAKE_INSTALL_LIBDIR}")
install(DIRECTORY "${AWS_DEPS_INSTALL_DIR}/${CMAKE_INSTALL_LIBDIR}/" DESTINATION "${LIBRARY_DIRECTORY}")
endif()
if (EXISTS "${AWS_DEPS_INSTALL_DIR}/${CMAKE_INSTALL_BINDIR}")
install(DIRECTORY "${AWS_DEPS_INSTALL_DIR}/${CMAKE_INSTALL_BINDIR}/" DESTINATION "${BINARY_DIRECTORY}")
endif()
endif()
# following two files are vital for cmake to find correct package, but since we copied all files from above
# we left the code here to give you bettern understanding
#install(
# FILES "${AWS_NATIVE_SDK_ROOT}/cmake/${PROJECT_NAME}Config.cmake"
# DESTINATION "${LIBRARY_DIRECTORY}/cmake/${PROJECT_NAME}")
# to make compile time settings consistent with user usage time settings, we copy common settings to
# destination. These settings will be included by ${PROJECT_NAME}-config.cmake
# internal dependencies
#install(
# FILES "${AWS_NATIVE_SDK_ROOT}/cmake/sdksCommon.cmake"
# DESTINATION "${LIBRARY_DIRECTORY}/cmake/${PROJECT_NAME}/")

102
support/aws-sdk-cpp-master/cmake/utilities.cmake Normal file
View File

@@ -0,0 +1,102 @@
macro(generate_pkgconfig_link_flags LIBS_LIST OUTPUT_VAR)
set(${OUTPUT_VAR} "")
foreach(LIB IN LISTS ${LIBS_LIST})
if(${OUTPUT_VAR})
set(${OUTPUT_VAR} "${${OUTPUT_VAR}} -l${LIB}")
else()
set(${OUTPUT_VAR} "-l${LIB}")
endif()
endforeach()
endmacro()
# this function is based on the unity build function described at: https://cheind.wordpress.com/2009/12/10/reducing-compilation-time-unity-builds/
function(enable_unity_build UNITY_SUFFIX SOURCE_FILES)
set(files ${${SOURCE_FILES}})
# Generate a unique filename for the unity build translation unit
set(unity_build_file ${CMAKE_CURRENT_BINARY_DIR}/ub_${UNITY_SUFFIX}.cpp)
# Exclude all translation units from compilation
set_source_files_properties(${files} PROPERTIES HEADER_FILE_ONLY true)
# Open the ub file
FILE(WRITE ${unity_build_file} "// Unity Build generated by CMake\n")
# Add include statement for each translation unit
foreach(source_file ${files} )
FILE( APPEND ${unity_build_file} "#include <${source_file}>\n")
endforeach(source_file)
# Complement list of translation units with the name of ub
set(${SOURCE_FILES} ${${SOURCE_FILES}} ${unity_build_file} PARENT_SCOPE)
endfunction(enable_unity_build)
macro(setup_install)
if(SIMPLE_INSTALL)
configure_file("${AWS_NATIVE_SDK_ROOT}/toolchains/pkg-config.pc.in" "${PROJECT_NAME}.pc" @ONLY)
install( TARGETS ${PROJECT_NAME}
EXPORT "${PROJECT_NAME}-targets"
ARCHIVE DESTINATION ${ARCHIVE_DIRECTORY}
LIBRARY DESTINATION ${LIBRARY_DIRECTORY}
RUNTIME DESTINATION ${BINARY_DIRECTORY} )
if (BUILD_SHARED_LIBS)
install(
FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
DESTINATION ${LIBRARY_DIRECTORY}/pkgconfig)
endif()
else()
if(PLATFORM_CUSTOM)
install_custom_library(${PROJECT_NAME})
else()
install (TARGETS ${PROJECT_NAME}
ARCHIVE DESTINATION ${ARCHIVE_DIRECTORY}/${SDK_INSTALL_BINARY_PREFIX}/${PLATFORM_INSTALL_QUALIFIER}/\${CMAKE_INSTALL_CONFIG_NAME}
LIBRARY DESTINATION ${LIBRARY_DIRECTORY}/${SDK_INSTALL_BINARY_PREFIX}/${PLATFORM_INSTALL_QUALIFIER}/\${CMAKE_INSTALL_CONFIG_NAME}
RUNTIME DESTINATION ${BINARY_DIRECTORY}/${SDK_INSTALL_BINARY_PREFIX}/${PLATFORM_INSTALL_QUALIFIER}/\${CMAKE_INSTALL_CONFIG_NAME})
endif()
endif()
endmacro()
macro(do_packaging)
if(SIMPLE_INSTALL)
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
export(EXPORT "${PROJECT_NAME}-targets"
FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-targets.cmake"
)
if(${PROJECT_NAME} STREQUAL "aws-cpp-sdk-core")
configure_file(
"${AWS_NATIVE_SDK_ROOT}/toolchains/core-config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
@ONLY)
else()
configure_file(
"${AWS_NATIVE_SDK_ROOT}/toolchains/cmakeProjectConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
@ONLY)
endif()
set(ConfigPackageLocation "${LIBRARY_DIRECTORY}/cmake/${PROJECT_NAME}")
install(EXPORT "${PROJECT_NAME}-targets"
FILE "${PROJECT_NAME}-targets.cmake"
DESTINATION ${ConfigPackageLocation}
)
install(
FILES
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
DESTINATION
${ConfigPackageLocation}
COMPONENT
Devel)
endif()
endmacro()