diff options
| author | mag1str0 <mag1str0@yandex-team.com> | 2023-12-12 11:44:11 +0300 |
|---|---|---|
| committer | mag1str0 <mag1str0@yandex-team.com> | 2023-12-12 12:19:43 +0300 |
| commit | 07236af9e0df85336acad6f7e5979ca371068d47 (patch) | |
| tree | 7b2e81f7d57f8f04de3c25e1ec743ea755e8e68e | |
| parent | ec936365a4e886170118cf2fb8d976cb04146fa3 (diff) | |
| download | ydb-07236af9e0df85336acad6f7e5979ca371068d47.tar.gz | |
Moved cmake files to generator dir and updated generator.toml
25 files changed, 2229 insertions, 40 deletions
diff --git a/build/export_generators/hardcoded-cmake/build/scripts/create_recursive_library_for_cmake.py b/build/export_generators/hardcoded-cmake/build/scripts/create_recursive_library_for_cmake.py new file mode 100644 index 0000000000..0023e7d02a --- /dev/null +++ b/build/export_generators/hardcoded-cmake/build/scripts/create_recursive_library_for_cmake.py @@ -0,0 +1,201 @@ +# Custom script is necessary because CMake does not yet support creating static libraries combined with dependencies +# https://gitlab.kitware.com/cmake/cmake/-/issues/22975 +# +# This script is intended to be used set as a CXX_LINKER_LAUNCHER property for recursive library targets. +# It parses the linking command and transforms it to archiving commands combining static libraries from dependencies. + +import argparse +import os +import shlex +import subprocess +import sys +import tempfile + + +class Opts(object): + def __init__(self, args): + argparser = argparse.ArgumentParser(allow_abbrev=False) + argparser.add_argument('--cmake-binary-dir', required=True) + argparser.add_argument('--cmake-ar', required=True) + argparser.add_argument('--cmake-ranlib', required=True) + argparser.add_argument('--cmake-host-system-name', required=True) + argparser.add_argument('--cmake-cxx-standard-libraries') + argparser.add_argument('--global-part-suffix', required=True) + self.parsed_args, other_args = argparser.parse_known_args(args=args) + + if len(other_args) < 2: + # must contain at least '--linking-cmdline' and orginal linking tool name + raise Exception('not enough arguments') + if other_args[0] != '--linking-cmdline': + raise Exception("expected '--linking-cmdline' arg, got {}".format(other_args[0])) + + self.is_msvc_linker = other_args[1].endswith('\\link.exe') + + is_host_system_windows = self.parsed_args.cmake_host_system_name == 'Windows' + std_libraries_to_exclude_from_input = ( + set(self.parsed_args.cmake_cxx_standard_libraries.split()) + if self.parsed_args.cmake_cxx_standard_libraries is not None + else set() + ) + msvc_preserved_option_prefixes = [ + 'errorreport', + 'machine:', + 'nodefaultlib', + 'nologo', + 'subsystem', + ] + + self.preserved_options = [] + + # these variables can contain paths absolute or relative to CMAKE_BINARY_DIR + self.global_libs_and_objects_input = [] + self.non_global_libs_input = [] + self.output = None + + def is_external_library(path): + """ + Check whether this library has been built in this CMake project or came from Conan-provided dependencies + (these use absolute paths). + If it is a library that is added from some other path (like CUDA) return True + """ + return not (os.path.exists(path) or os.path.exists(os.path.join(self.parsed_args.cmake_binary_dir, path))) + + def process_input(args): + i = 0 + is_in_whole_archive = False + + while i < len(args): + arg = args[i] + if is_host_system_windows and ((arg[0] == '/') or (arg[0] == '-')): + arg_wo_specifier_lower = arg[1:].lower() + if arg_wo_specifier_lower.startswith('out:'): + self.output = arg[len('/out:') :] + elif arg_wo_specifier_lower.startswith('wholearchive:'): + lib_path = arg[len('/wholearchive:') :] + if not is_external_library(lib_path): + self.global_libs_and_objects_input.append(lib_path) + else: + for preserved_option_prefix in msvc_preserved_option_prefixes: + if arg_wo_specifier_lower.startswith(preserved_option_prefix): + self.preserved_options.append(arg) + break + # other flags are non-linking related and just ignored + elif arg[0] == '-': + if arg == '-o': + if (i + 1) >= len(args): + raise Exception('-o flag without an argument') + self.output = args[i + 1] + i += 1 + elif arg == '-Wl,--whole-archive': + is_in_whole_archive = True + elif arg == '-Wl,--no-whole-archive': + is_in_whole_archive = False + elif arg.startswith('-Wl,-force_load,'): + lib_path = arg[len('-Wl,-force_load,') :] + if not is_external_library(lib_path): + self.global_libs_and_objects_input.append(lib_path) + elif arg == '-isysroot': + i += 1 + # other flags are non-linking related and just ignored + elif arg[0] == '@': + # response file with args + with open(arg[1:]) as response_file: + parsed_args = shlex.shlex(response_file, posix=False, punctuation_chars=False) + parsed_args.whitespace_split = True + args_in_response_file = list(arg.strip('"') for arg in parsed_args) + process_input(args_in_response_file) + elif not is_external_library(arg): + if is_in_whole_archive or arg.endswith('.o') or arg.endswith('.obj'): + self.global_libs_and_objects_input.append(arg) + elif arg not in std_libraries_to_exclude_from_input: + self.non_global_libs_input.append(arg) + i += 1 + + process_input(other_args[2:]) + + if self.output is None: + raise Exception("No output specified") + + if (len(self.global_libs_and_objects_input) == 0) and (len(self.non_global_libs_input) == 0): + raise Exception("List of input objects and libraries is empty") + + +class FilesCombiner(object): + def __init__(self, opts): + self.opts = opts + + archiver_tool_path = opts.parsed_args.cmake_ar + if sys.platform.startswith('darwin'): + # force LIBTOOL even if CMAKE_AR is defined because 'ar' under Darwin does not contain the necessary options + arch_type = 'LIBTOOL' + archiver_tool_path = 'libtool' + elif opts.is_msvc_linker: + arch_type = 'LIB' + elif opts.parsed_args.cmake_ar.endswith('llvm-ar'): + arch_type = 'LLVM_AR' + elif opts.parsed_args.cmake_ar.endswith('ar'): + arch_type = 'GNU_AR' + else: + raise Exception('Unsupported arch type for CMAKE_AR={}'.format(opts.parsed_args.cmake_ar)) + + self.archiving_cmd_prefix = [ + sys.executable, + os.path.join(os.path.dirname(os.path.abspath(__file__)), 'link_lib.py'), + archiver_tool_path, + arch_type, + 'gnu', # llvm_ar_format, used only if arch_type == 'LLVM_AR' + opts.parsed_args.cmake_binary_dir, + 'None', # plugin. Unused for now + ] + # the remaining archiving cmd args are [output, .. input .. ] + + def do(self, output, input_list): + input_file_path = None + try: + if self.opts.is_msvc_linker: + # use response file for input (because of Windows cmdline length limitations) + + # can't use NamedTemporaryFile because of permissions issues on Windows + input_file_fd, input_file_path = tempfile.mkstemp() + try: + input_file = os.fdopen(input_file_fd, 'w') + for input in input_list: + if ' ' in input: + input_file.write('"{}" '.format(input)) + else: + input_file.write('{} '.format(input)) + input_file.flush() + finally: + os.close(input_file_fd) + input_args = ['@' + input_file_path] + else: + input_args = input_list + + cmd = self.archiving_cmd_prefix + [output] + self.opts.preserved_options + input_args + subprocess.check_call(cmd) + finally: + if input_file_path is not None: + os.remove(input_file_path) + + if not self.opts.is_msvc_linker: + subprocess.check_call([self.opts.parsed_args.cmake_ranlib, output]) + + +if __name__ == "__main__": + opts = Opts(sys.argv[1:]) + + output_prefix, output_ext = os.path.splitext(opts.output) + globals_output = output_prefix + opts.parsed_args.global_part_suffix + output_ext + + if os.path.exists(globals_output): + os.remove(globals_output) + if os.path.exists(opts.output): + os.remove(opts.output) + + files_combiner = FilesCombiner(opts) + + if len(opts.global_libs_and_objects_input) > 0: + files_combiner.do(globals_output, opts.global_libs_and_objects_input) + + if len(opts.non_global_libs_input) > 0: + files_combiner.do(opts.output, opts.non_global_libs_input) diff --git a/build/export_generators/hardcoded-cmake/build/scripts/export_script_gen.py b/build/export_generators/hardcoded-cmake/build/scripts/export_script_gen.py index 6bf68fef7c..3df3df8638 100644 --- a/build/export_generators/hardcoded-cmake/build/scripts/export_script_gen.py +++ b/build/export_generators/hardcoded-cmake/build/scripts/export_script_gen.py @@ -22,12 +22,12 @@ def parse_export_file(src): def to_c(sym): symbols = collections.deque(sym.split('::')) c_prefixes = [ # demangle prefixes for c++ symbols - '_ZN', # namespace - '_ZTIN', # typeinfo for - '_ZTSN', # typeinfo name for - '_ZTTN', # VTT for - '_ZTVN', # vtable for - '_ZNK', # const methods + '_ZN', # namespace + '_ZTIN', # typeinfo for + '_ZTSN', # typeinfo name for + '_ZTTN', # VTT for + '_ZTVN', # vtable for + '_ZNK', # const methods ] c_sym = '' while symbols: @@ -102,9 +102,15 @@ def to_darwin(src, dest): def main(): - parser = argparse.ArgumentParser(description='Convert self-invented platform independent export file format to the format required by specific linker') - parser.add_argument('src', type=argparse.FileType('r', encoding='UTF-8'), help='platform independent export file path') - parser.add_argument('dest', type=argparse.FileType('w', encoding='UTF-8'), help='destination export file for required linker') + parser = argparse.ArgumentParser( + description='Convert self-invented platform independent export file format to the format required by specific linker' + ) + parser.add_argument( + 'src', type=argparse.FileType('r', encoding='UTF-8'), help='platform independent export file path' + ) + parser.add_argument( + 'dest', type=argparse.FileType('w', encoding='UTF-8'), help='destination export file for required linker' + ) parser.add_argument('--format', help='destination file type format: gnu, msvc or darwin') args = parser.parse_args() diff --git a/build/export_generators/hardcoded-cmake/build/scripts/gather_swig_java.cmake b/build/export_generators/hardcoded-cmake/build/scripts/gather_swig_java.cmake new file mode 100644 index 0000000000..fa0acf42c1 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/build/scripts/gather_swig_java.cmake @@ -0,0 +1,3 @@ +file(GLOB JAVA_FILES ${JAVA_SRC_DIR}/*.java) +list(JOIN JAVA_FILES "\n" JAVA_LST_CONTENT) +file(WRITE ${JAVA_LST} ${JAVA_LST_CONTENT}) diff --git a/build/export_generators/hardcoded-cmake/build/scripts/generate_vcs_info.py b/build/export_generators/hardcoded-cmake/build/scripts/generate_vcs_info.py index 770d2ec802..b311be5617 100644 --- a/build/export_generators/hardcoded-cmake/build/scripts/generate_vcs_info.py +++ b/build/export_generators/hardcoded-cmake/build/scripts/generate_vcs_info.py @@ -29,19 +29,19 @@ def _get_user_locale(): return [] -class _GitVersion(): +class _GitVersion: @classmethod def parse(cls, commit_hash, author_info, summary_info, body_info, tag_info, branch_info, depth=None): - r""" Parses output of - git rev-parse HEAD - git log -1 --format='format:%an <%ae>' - git log -1 --format='format:%s' - git log -1 --grep='^git-svn-id: ' --format='format:%b' or - git log -1 --grep='^Revision: r?\d*' --format='format:%b - git describe --exact-match --tags HEAD - git describe --exact-match --all HEAD - and depth as computed by _get_git_depth - '""" + r"""Parses output of + git rev-parse HEAD + git log -1 --format='format:%an <%ae>' + git log -1 --format='format:%s' + git log -1 --grep='^git-svn-id: ' --format='format:%b' or + git log -1 --grep='^Revision: r?\d*' --format='format:%b + git describe --exact-match --tags HEAD + git describe --exact-match --all HEAD + and depth as computed by _get_git_depth + '""" info = {} info['hash'] = commit_hash @@ -91,8 +91,8 @@ class _GitVersion(): hash_args = ['rev-parse', 'HEAD'] author_args = ['log', '-1', '--format=format:%an <%ae>'] summary_args = ['log', '-1', '--format=format:%s'] - svn_args = ['log', '-1', '--grep=^git-svn-id: ', '--format=format:%b'] - svn_args_alt = ['log', '-1', '--grep=^Revision: r\\?\\d*', '--format=format:%b'] + svn_args = ['log', '-1', '--grep=^git-svn-id: ', '--format=format:%b'] + svn_args_alt = ['log', '-1', '--grep=^Revision: r\\?\\d*', '--format=format:%b'] tag_args = ['describe', '--exact-match', '--tags', 'HEAD'] branch_args = ['describe', '--exact-match', '--all', 'HEAD'] @@ -163,6 +163,7 @@ class _SystemInfo: @classmethod def get_locale(cls): import codecs + for i in cls.LOCALE_LIST: if not i: continue @@ -237,6 +238,7 @@ class _SystemInfo: errcodes += ', win-error {}'.format(e.winerror) try: import ctypes + msg = six_.text_type(ctypes.FormatError(e.winerror), _SystemInfo.get_locale()).encode('utf-8') except ImportError: pass @@ -262,7 +264,8 @@ def _get_json(vcs_root): def _dump_json( - arc_root, info, + arc_root, + info, other_data=None, build_user=None, build_date=None, @@ -287,14 +290,14 @@ def _dump_json( j['DIRTY'] = info.get('dirty', '') if 'url' in info or 'svn_url' in info: - j['SVN_REVISION'] = info.get('svn_commit_revision', info.get('revision', -1)) - j['SVN_ARCROOT'] = info.get('url', info.get('svn_url', '')) - j['SVN_TIME'] = info.get('commit_date', info.get('svn_commit_date', '')) + j['SVN_REVISION'] = info.get('svn_commit_revision', info.get('revision', -1)) + j['SVN_ARCROOT'] = info.get('url', info.get('svn_url', '')) + j['SVN_TIME'] = info.get('commit_date', info.get('svn_commit_date', '')) j['BUILD_DATE'] = build_date j['BUILD_TIMESTAMP'] = build_timestamp - return json.dumps(j, sort_keys=True, indent=4, separators=(',', ': ')) + return json.dumps(j, sort_keys=True, indent=4, separators=(',', ': ')) def get_version_info(arc_root, custom_version=""): @@ -318,4 +321,3 @@ def get_version_info(arc_root, custom_version=""): if __name__ == '__main__': with open(sys.argv[1], 'w') as f: f.write(get_version_info(sys.argv[2])) - diff --git a/build/export_generators/hardcoded-cmake/cmake/FindAIO.cmake b/build/export_generators/hardcoded-cmake/cmake/FindAIO.cmake new file mode 100644 index 0000000000..a9d7d87b55 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/FindAIO.cmake @@ -0,0 +1,26 @@ +# - Find AIO +# +# AIO_INCLUDE - Where to find libaio.h +# AIO_LIBS - List of libraries when using AIO. +# AIO_FOUND - True if AIO found. + +find_path(AIO_INCLUDE_DIR + libaio.h + HINTS $ENV{AIO_ROOT}/include) + +find_library(AIO_LIBRARIES + aio + HINTS $ENV{AIO_ROOT}/lib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(AIO DEFAULT_MSG AIO_LIBRARIES AIO_INCLUDE_DIR) + +mark_as_advanced(AIO_INCLUDE_DIR AIO_LIBRARIES) + +if (AIO_FOUND AND NOT TARGET AIO::aio) + add_library(AIO::aio UNKNOWN IMPORTED) + set_target_properties(AIO::aio PROPERTIES + IMPORTED_LOCATION ${AIO_LIBRARIES} + INTERFACE_INCLUDE_DIRECTORIES ${AIO_INCLUDE_DIR} + ) +endif() diff --git a/build/export_generators/hardcoded-cmake/cmake/FindIDN.cmake b/build/export_generators/hardcoded-cmake/cmake/FindIDN.cmake new file mode 100644 index 0000000000..7342fb6d7a --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/FindIDN.cmake @@ -0,0 +1,26 @@ +# - Find IDN +# +# IDN_INCLUDE - Where to find LibIDN public headers +# IDN_LIBS - List of libraries when using LibIDN. +# IDN_FOUND - True if LibIDN found. + +find_path(IDN_INCLUDE_DIR + idna.h + HINTS $ENV{IDN_ROOT}/include) + +find_library(IDN_LIBRARIES + idn + HINTS $ENV{IDN_ROOT}/lib) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(IDN DEFAULT_MSG IDN_LIBRARIES IDN_INCLUDE_DIR) + +mark_as_advanced(IDN_INCLUDE_DIR IDN_LIBRARIES) + +if (IDN_FOUND AND NOT TARGET IDN::IDN) + add_library(IDN::IDN UNKNOWN IMPORTED) + set_target_properties(IDN::IDN PROPERTIES + IMPORTED_LOCATION ${IDN_LIBRARIES} + INTERFACE_INCLUDE_DIRECTORIES ${IDN_INCLUDE_DIR} + ) +endif() diff --git a/build/export_generators/hardcoded-cmake/cmake/FindJNITarget.cmake b/build/export_generators/hardcoded-cmake/cmake/FindJNITarget.cmake new file mode 100644 index 0000000000..1c7f7d59a6 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/FindJNITarget.cmake @@ -0,0 +1,33 @@ +if(JNITarget_FIND_QUIETLY) + find_package(JNI QUIET) +elseif(JNITarget_FIND_REQUIRED) + find_package(JNI REQUIRED) +else() + find_package(JNI) +endif() + +set(JNI_TARGET_INCLUDE_DIRS ${JNI_INCLUDE_DIRS}) +set(JNI_TARGET_LIBRARIES ${JNI_LIBRARIES}) + +if (JNI_FOUND) + add_library(JNITarget::jni IMPORTED UNKNOWN) + set_property(TARGET JNITarget::jni PROPERTY + IMPORTED_LOCATION ${JAVA_JVM_LIBRARY} + ) + set_property(TARGET JNITarget::jni PROPERTY + INTERFACE_INCLUDE_DIRECTORIES ${JAVA_INCLUDE_PATH} ${JAVA_INCLUDE_PATH2} + ) + + add_library(JNITarget::jni_awt IMPORTED UNKNOWN) + set_property(TARGET JNITarget::jni_awt PROPERTY + IMPORTED_LOCATION ${JAVA_AWT_LIBRARY} + ) + set_property(TARGET JNITarget::jni_awt PROPERTY + INTERFACE_INCLUDE_DIRECTORIES ${JAVA_AWT_INCLUDE_PATH} + ) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(JNITarget DEFAULT_MSG JNI_TARGET_LIBRARIES JNI_TARGET_INCLUDE_DIRS) + +mark_as_advanced(JNI_TARGET_INCLUDE_DIRS JNI_TARGET_LIBRARIES) diff --git a/build/export_generators/hardcoded-cmake/cmake/antlr.cmake b/build/export_generators/hardcoded-cmake/cmake/antlr.cmake new file mode 100644 index 0000000000..d203fd9c88 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/antlr.cmake @@ -0,0 +1,31 @@ +function(ensure_antlr) + if(NOT ANTLR3_EXECUTABLE) + find_program(ANTLR3_EXECUTABLE + NAMES antlr3) + if (NOT ANTLR3_EXECUTABLE) + message(FATAL_ERROR "Unable to find antlr3 program. Please install antlr3 and make sure executable file present in the $PATH env.") + endif() + endif() +endfunction() + +function(run_antlr) + ensure_antlr() + set(options "") + set(oneValueArgs WORKING_DIRECTORY) + set(multiValueArgs OUTPUT DEPENDS ANTLER_ARGS) + cmake_parse_arguments( + RUN_ANTLR + "${options}" + "${oneValueArgs}" + "${multiValueArgs}" + ${ARGN} + ) + + add_custom_command( + OUTPUT ${RUN_ANTLR_OUTPUT} + COMMAND ${ANTLR3_EXECUTABLE} ${RUN_ANTLR_ANTLER_ARGS} + WORKING_DIRECTORY ${RUN_ANTLR_WORKING_DIRECTORY} + DEPENDS ${RUN_ANTLR_DEPENDS} + ) + +endfunction() diff --git a/build/export_generators/hardcoded-cmake/cmake/archive.cmake b/build/export_generators/hardcoded-cmake/cmake/archive.cmake new file mode 100644 index 0000000000..f822498dae --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/archive.cmake @@ -0,0 +1,13 @@ +find_package(Python3 REQUIRED) + +function(target_rodata_sources TgtName Scope) + foreach(rodata ${ARGN}) + get_filename_component(CppVar ${rodata} NAME_WLE) + add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${CppVar}.cpp + COMMAND Python3::Interpreter ${CMAKE_SOURCE_DIR}/build/scripts/rodata2cpp.py ${CppVar} ${rodata} ${CMAKE_CURRENT_BINARY_DIR}/${CppVar}.cpp + DEPENDS ${CMAKE_SOURCE_DIR}/build/scripts/rodata2cpp.py ${rodata} + ) + target_sources(${TgtName} ${Scope} ${CMAKE_CURRENT_BINARY_DIR}/${CppVar}.cpp) + endforeach() +endfunction()
\ No newline at end of file diff --git a/build/export_generators/hardcoded-cmake/cmake/bison.cmake b/build/export_generators/hardcoded-cmake/cmake/bison.cmake new file mode 100644 index 0000000000..38d2b91ff9 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/bison.cmake @@ -0,0 +1,24 @@ +function(target_bison_parser Tgt Scope) + foreach(arg ${ARGN}) + get_filename_component(argPath ${arg} REALPATH) + if (argPath MATCHES "${CMAKE_SOURCE_DIR}/.*") + file(RELATIVE_PATH argRel ${CMAKE_CURRENT_SOURCE_DIR} ${argPath}) + string(REPLACE ".." "__" ArgInBindir ${argRel}) + set(ArgInBindir ${CMAKE_CURRENT_BINARY_DIR}/${ArgInBindir}) + else() + set(ArgInBindir ${argPath}) + endif() + get_filename_component(OutputBase ${arg} NAME_WLE) + get_filename_component(OutputDir ${ArgInBindir} DIRECTORY) + add_custom_command( + OUTPUT ${OutputDir}/${OutputBase}.cpp ${OutputDir}/${OutputBase}.h + COMMAND ${CMAKE_COMMAND} -E make_directory ${OutputDir} + COMMAND ${CMAKE_COMMAND} -E env M4=${CMAKE_BINARY_DIR}/bin/m4/bin/m4 ${CMAKE_BINARY_DIR}/bin/bison/bin/bison ${BISON_FLAGS} -v --defines=${OutputDir}/${OutputBase}.h -o ${OutputDir}/${OutputBase}.cpp ${arg} + DEPENDS ${arg} + ) + target_sources(${Tgt} ${Scope} ${OutputDir}/${OutputBase}.cpp ${OutputDir}/${OutputBase}.h) + endforeach() +endfunction() + +function(target_flex_lexers Tgt) +endfunction() diff --git a/build/export_generators/hardcoded-cmake/cmake/common.cmake b/build/export_generators/hardcoded-cmake/cmake/common.cmake index 2f266468ac..0ffe61ad17 100644 --- a/build/export_generators/hardcoded-cmake/cmake/common.cmake +++ b/build/export_generators/hardcoded-cmake/cmake/common.cmake @@ -257,16 +257,28 @@ function(add_yunittest) "${multival_args}" ${ARGN} ) - get_property(SPLIT_FACTOR TARGET ${YUNITTEST_ARGS_TEST_TARGET} PROPERTY SPLIT_FACTOR) + + get_property(SPLIT_FACTOR TARGET ${YUNITTEST_ARGS_TEST_TARGET} PROPERTY SPLIT_FACTOR) + get_property(SPLIT_TYPE TARGET ${YUNITTEST_ARGS_TEST_TARGET} PROPERTY SPLIT_TYPE) + + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/run_testpack") + add_test(NAME ${YUNITTEST_ARGS_NAME} COMMAND "${CMAKE_CURRENT_SOURCE_DIR}/run_testpack" ${YUNITTEST_ARGS_TEST_ARG}) + set_property(TEST ${YUNITTEST_ARGS_NAME} PROPERTY ENVIRONMENT "source_root=${CMAKE_SOURCE_DIR};build_root=${CMAKE_BINARY_DIR};test_split_factor=${SPLIT_FACTOR};test_split_type=${SPLIT_TYPE}") + return() + endif() + if (${SPLIT_FACTOR} EQUAL 1) add_test(NAME ${YUNITTEST_ARGS_NAME} COMMAND ${YUNITTEST_ARGS_TEST_TARGET} ${YUNITTEST_ARGS_TEST_ARG}) return() endif() + if ("${SPLIT_TYPE}") + set(FORK_MODE_ARG --fork-mode ${SPLIT_TYPE}) + endif() math(EXPR LastIdx "${SPLIT_FACTOR} - 1") foreach(Idx RANGE ${LastIdx}) add_test(NAME ${YUNITTEST_ARGS_NAME}_${Idx} - COMMAND Python3::Interpreter ${CMAKE_SOURCE_DIR}/build/scripts/split_unittest.py --split-factor ${SPLIT_FACTOR} --shard ${Idx} + COMMAND Python3::Interpreter ${CMAKE_SOURCE_DIR}/build/scripts/split_unittest.py --split-factor ${SPLIT_FACTOR} ${FORK_MODE_ARG} --shard ${Idx} $<TARGET_FILE:${YUNITTEST_ARGS_TEST_TARGET}> ${YUNITTEST_ARGS_TEST_ARG}) endforeach() endfunction() @@ -283,7 +295,7 @@ function(set_yunittest_property) ) get_property(SPLIT_FACTOR TARGET ${YUNITTEST_ARGS_TEST} PROPERTY SPLIT_FACTOR) - if (${SPLIT_FACTOR} EQUAL 1) + if ((${SPLIT_FACTOR} EQUAL 1) OR (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/run_testpack")) set_property(TEST ${YUNITTEST_ARGS_TEST} PROPERTY ${YUNITTEST_ARGS_PROPERTY} ${YUNITTEST_ARGS_UNPARSED_ARGUMENTS}) return() endif() diff --git a/build/export_generators/hardcoded-cmake/cmake/conan.cmake b/build/export_generators/hardcoded-cmake/cmake/conan.cmake new file mode 100644 index 0000000000..d6a8b5e8c4 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/conan.cmake @@ -0,0 +1,939 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 JFrog + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + + +# This file comes from: https://github.com/conan-io/cmake-conan. Please refer +# to this repository for issues and documentation. + +# Its purpose is to wrap and launch Conan C/C++ Package Manager when cmake is called. +# It will take CMake current settings (os, compiler, compiler version, architecture) +# and translate them to conan settings for installing and retrieving dependencies. + +# It is intended to facilitate developers building projects that have conan dependencies, +# but it is only necessary on the end-user side. It is not necessary to create conan +# packages, in fact it shouldn't be use for that. Check the project documentation. + +# version: 0.17.0 + +include(CMakeParseArguments) + +function(_get_msvc_ide_version result) + set(${result} "" PARENT_SCOPE) + if(NOT MSVC_VERSION VERSION_LESS 1400 AND MSVC_VERSION VERSION_LESS 1500) + set(${result} 8 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1500 AND MSVC_VERSION VERSION_LESS 1600) + set(${result} 9 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1600 AND MSVC_VERSION VERSION_LESS 1700) + set(${result} 10 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1700 AND MSVC_VERSION VERSION_LESS 1800) + set(${result} 11 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1800 AND MSVC_VERSION VERSION_LESS 1900) + set(${result} 12 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1900 AND MSVC_VERSION VERSION_LESS 1910) + set(${result} 14 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1910 AND MSVC_VERSION VERSION_LESS 1920) + set(${result} 15 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930) + set(${result} 16 PARENT_SCOPE) + elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940) + set(${result} 17 PARENT_SCOPE) + else() + message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]") + endif() +endfunction() + +macro(_conan_detect_build_type) + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_BUILD_TYPE) + set(_CONAN_SETTING_BUILD_TYPE ${ARGUMENTS_BUILD_TYPE}) + elseif(CMAKE_BUILD_TYPE) + set(_CONAN_SETTING_BUILD_TYPE ${CMAKE_BUILD_TYPE}) + else() + message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") + endif() + + string(TOUPPER ${_CONAN_SETTING_BUILD_TYPE} _CONAN_SETTING_BUILD_TYPE_UPPER) + if (_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "DEBUG") + set(_CONAN_SETTING_BUILD_TYPE "Debug") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELEASE") + set(_CONAN_SETTING_BUILD_TYPE "Release") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELWITHDEBINFO") + set(_CONAN_SETTING_BUILD_TYPE "RelWithDebInfo") + elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "MINSIZEREL") + set(_CONAN_SETTING_BUILD_TYPE "MinSizeRel") + endif() +endmacro() + +macro(_conan_check_system_name) + #handle -s os setting + if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic") + #use default conan os setting if CMAKE_SYSTEM_NAME is not defined + set(CONAN_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}) + if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") + set(CONAN_SYSTEM_NAME Macos) + endif() + if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX") + set(CONAN_SYSTEM_NAME Neutrino) + endif() + set(CONAN_SUPPORTED_PLATFORMS Windows Linux Macos Android iOS FreeBSD WindowsStore WindowsCE watchOS tvOS FreeBSD SunOS AIX Arduino Emscripten Neutrino) + list (FIND CONAN_SUPPORTED_PLATFORMS "${CONAN_SYSTEM_NAME}" _index) + if (${_index} GREATER -1) + #check if the cmake system is a conan supported one + set(_CONAN_SETTING_OS ${CONAN_SYSTEM_NAME}) + else() + message(FATAL_ERROR "cmake system ${CONAN_SYSTEM_NAME} is not supported by conan. Use one of ${CONAN_SUPPORTED_PLATFORMS}") + endif() + endif() +endmacro() + +macro(_conan_check_language) + get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES) + if (";${_languages};" MATCHES ";CXX;") + set(LANGUAGE CXX) + set(USING_CXX 1) + elseif (";${_languages};" MATCHES ";C;") + set(LANGUAGE C) + set(USING_CXX 0) + else () + message(FATAL_ERROR "Conan: Neither C or C++ was detected as a language for the project. Unabled to detect compiler version.") + endif() +endmacro() + +macro(_conan_detect_compiler) + + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_ARCH) + set(_CONAN_SETTING_ARCH ${ARGUMENTS_ARCH}) + endif() + + if(USING_CXX) + set(_CONAN_SETTING_COMPILER_CPPSTD ${CMAKE_CXX_STANDARD}) + endif() + + if (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL GNU) + # using GCC + # TODO: Handle other params + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(COMPILER_VERSION ${MAJOR}.${MINOR}) + if(${MAJOR} GREATER 4) + set(COMPILER_VERSION ${MAJOR}) + endif() + set(_CONAN_SETTING_COMPILER gcc) + set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Intel) + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(COMPILER_VERSION ${MAJOR}.${MINOR}) + set(_CONAN_SETTING_COMPILER intel) + set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL AppleClang) + # using AppleClang + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(_CONAN_SETTING_COMPILER apple-clang) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang) + string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION}) + list(GET VERSION_LIST 0 MAJOR) + list(GET VERSION_LIST 1 MINOR) + set(_CONAN_SETTING_COMPILER clang) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR}) + if(APPLE) + cmake_policy(GET CMP0025 APPLE_CLANG_POLICY) + if(NOT APPLE_CLANG_POLICY STREQUAL NEW) + message(STATUS "Conan: APPLE and Clang detected. Assuming apple-clang compiler. Set CMP0025 to avoid it") + set(_CONAN_SETTING_COMPILER apple-clang) + endif() + endif() + if(${_CONAN_SETTING_COMPILER} STREQUAL clang AND ${MAJOR} GREATER 7) + set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}) + endif() + if (USING_CXX) + conan_cmake_detect_unix_libcxx(_LIBCXX) + set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX}) + endif () + elseif(${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL MSVC) + set(_VISUAL "Visual Studio") + _get_msvc_ide_version(_VISUAL_VERSION) + if("${_VISUAL_VERSION}" STREQUAL "") + message(FATAL_ERROR "Conan: Visual Studio not recognized") + else() + set(_CONAN_SETTING_COMPILER ${_VISUAL}) + set(_CONAN_SETTING_COMPILER_VERSION ${_VISUAL_VERSION}) + endif() + + if(NOT _CONAN_SETTING_ARCH) + if (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "64") + set(_CONAN_SETTING_ARCH x86_64) + elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "^ARM") + message(STATUS "Conan: Using default ARM architecture from MSVC") + set(_CONAN_SETTING_ARCH armv6) + elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "86") + set(_CONAN_SETTING_ARCH x86) + else () + message(FATAL_ERROR "Conan: Unknown MSVC architecture [${MSVC_${LANGUAGE}_ARCHITECTURE_ID}]") + endif() + endif() + + conan_cmake_detect_vs_runtime(_vs_runtime ${ARGV}) + message(STATUS "Conan: Detected VS runtime: ${_vs_runtime}") + set(_CONAN_SETTING_COMPILER_RUNTIME ${_vs_runtime}) + + if (CMAKE_GENERATOR_TOOLSET) + set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) + elseif(CMAKE_VS_PLATFORM_TOOLSET AND (CMAKE_GENERATOR STREQUAL "Ninja")) + set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET}) + endif() + else() + message(FATAL_ERROR "Conan: compiler setup not recognized") + endif() + +endmacro() + +function(conan_cmake_settings result) + #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER}) + #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER_ID}) + #message(STATUS "VERSION " ${CMAKE_CXX_COMPILER_VERSION}) + #message(STATUS "FLAGS " ${CMAKE_LANG_FLAGS}) + #message(STATUS "LIB ARCH " ${CMAKE_CXX_LIBRARY_ARCHITECTURE}) + #message(STATUS "BUILD TYPE " ${CMAKE_BUILD_TYPE}) + #message(STATUS "GENERATOR " ${CMAKE_GENERATOR}) + #message(STATUS "GENERATOR WIN64 " ${CMAKE_CL_64}) + + message(STATUS "Conan: Automatic detection of conan settings from cmake") + + conan_parse_arguments(${ARGV}) + + _conan_detect_build_type(${ARGV}) + + _conan_check_system_name() + + _conan_check_language() + + _conan_detect_compiler(${ARGV}) + + # If profile is defined it is used + if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARGUMENTS_DEBUG_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_DEBUG_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND ARGUMENTS_RELEASE_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_RELEASE_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" AND ARGUMENTS_RELWITHDEBINFO_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_RELWITHDEBINFO_PROFILE}) + elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" AND ARGUMENTS_MINSIZEREL_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_MINSIZEREL_PROFILE}) + elseif(ARGUMENTS_PROFILE) + set(_APPLIED_PROFILES ${ARGUMENTS_PROFILE}) + endif() + + foreach(ARG ${_APPLIED_PROFILES}) + set(_SETTINGS ${_SETTINGS} -pr=${ARG}) + endforeach() + foreach(ARG ${ARGUMENTS_PROFILE_BUILD}) + conan_check(VERSION 1.24.0 REQUIRED DETECT_QUIET) + set(_SETTINGS ${_SETTINGS} -pr:b=${ARG}) + endforeach() + + if(NOT _SETTINGS OR ARGUMENTS_PROFILE_AUTO STREQUAL "ALL") + set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version + compiler.runtime compiler.libcxx compiler.toolset) + endif() + + # remove any manually specified settings from the autodetected settings + foreach(ARG ${ARGUMENTS_SETTINGS}) + string(REGEX MATCH "[^=]*" MANUAL_SETTING "${ARG}") + message(STATUS "Conan: ${MANUAL_SETTING} was added as an argument. Not using the autodetected one.") + list(REMOVE_ITEM ARGUMENTS_PROFILE_AUTO "${MANUAL_SETTING}") + endforeach() + + # Automatic from CMake + foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) + string(TOUPPER ${ARG} _arg_name) + string(REPLACE "." "_" _arg_name ${_arg_name}) + if(_CONAN_SETTING_${_arg_name}) + set(_SETTINGS ${_SETTINGS} -s ${ARG}=${_CONAN_SETTING_${_arg_name}}) + endif() + endforeach() + + foreach(ARG ${ARGUMENTS_SETTINGS}) + set(_SETTINGS ${_SETTINGS} -s ${ARG}) + endforeach() + + message(STATUS "Conan: Settings= ${_SETTINGS}") + + set(${result} ${_SETTINGS} PARENT_SCOPE) +endfunction() + + +function(conan_cmake_detect_unix_libcxx result) + # Take into account any -stdlib in compile options + get_directory_property(compile_options DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS) + string(GENEX_STRIP "${compile_options}" compile_options) + + # Take into account any _GLIBCXX_USE_CXX11_ABI in compile definitions + get_directory_property(defines DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS) + string(GENEX_STRIP "${defines}" defines) + + foreach(define ${defines}) + if(define MATCHES "_GLIBCXX_USE_CXX11_ABI") + if(define MATCHES "^-D") + set(compile_options ${compile_options} "${define}") + else() + set(compile_options ${compile_options} "-D${define}") + endif() + endif() + endforeach() + + # add additional compiler options ala cmRulePlaceholderExpander::ExpandRuleVariable + set(EXPAND_CXX_COMPILER ${CMAKE_CXX_COMPILER}) + if(CMAKE_CXX_COMPILER_ARG1) + # CMake splits CXX="foo bar baz" into CMAKE_CXX_COMPILER="foo", CMAKE_CXX_COMPILER_ARG1="bar baz" + # without this, ccache, winegcc, or other wrappers might lose all their arguments + separate_arguments(SPLIT_CXX_COMPILER_ARG1 NATIVE_COMMAND ${CMAKE_CXX_COMPILER_ARG1}) + list(APPEND EXPAND_CXX_COMPILER ${SPLIT_CXX_COMPILER_ARG1}) + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_TARGET AND CMAKE_CXX_COMPILER_TARGET) + # without --target= we may be calling the wrong underlying GCC + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}") + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN AND CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}") + endif() + + if(CMAKE_CXX_COMPILE_OPTIONS_SYSROOT) + # without --sysroot= we may find the wrong #include <string> + if(CMAKE_SYSROOT_COMPILE) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT_COMPILE}") + elseif(CMAKE_SYSROOT) + list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}") + endif() + endif() + + separate_arguments(SPLIT_CXX_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS}) + + if(CMAKE_OSX_SYSROOT) + set(xcode_sysroot_option "--sysroot=${CMAKE_OSX_SYSROOT}") + endif() + + execute_process( + COMMAND ${CMAKE_COMMAND} -E echo "#include <string>" + COMMAND ${EXPAND_CXX_COMPILER} ${SPLIT_CXX_FLAGS} -x c++ ${xcode_sysroot_option} ${compile_options} -E -dM - + OUTPUT_VARIABLE string_defines + ) + + if(string_defines MATCHES "#define __GLIBCXX__") + # Allow -D_GLIBCXX_USE_CXX11_ABI=ON/OFF as argument to cmake + if(DEFINED _GLIBCXX_USE_CXX11_ABI) + if(_GLIBCXX_USE_CXX11_ABI) + set(${result} libstdc++11 PARENT_SCOPE) + return() + else() + set(${result} libstdc++ PARENT_SCOPE) + return() + endif() + endif() + + if(string_defines MATCHES "#define _GLIBCXX_USE_CXX11_ABI 1\n") + set(${result} libstdc++11 PARENT_SCOPE) + else() + # Either the compiler is missing the define because it is old, and so + # it can't use the new abi, or the compiler was configured to use the + # old abi by the user or distro (e.g. devtoolset on RHEL/CentOS) + set(${result} libstdc++ PARENT_SCOPE) + endif() + else() + set(${result} libc++ PARENT_SCOPE) + endif() +endfunction() + +function(conan_cmake_detect_vs_runtime result) + + conan_parse_arguments(${ARGV}) + if(ARGUMENTS_BUILD_TYPE) + set(build_type "${ARGUMENTS_BUILD_TYPE}") + elseif(CMAKE_BUILD_TYPE) + set(build_type "${CMAKE_BUILD_TYPE}") + else() + message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)") + endif() + + if(build_type) + string(TOUPPER "${build_type}" build_type) + endif() + + if (DEFINED CMAKE_MSVC_RUNTIME_LIBRARY) + if(${CMAKE_MSVC_RUNTIME_LIBRARY} STREQUAL MultiThreaded) + set(${result} "MT" PARENT_SCOPE) + elseif(${CMAKE_MSVC_RUNTIME_LIBRARY} STREQUAL MultiThreadedDebug) + set(${result} "MTd" PARENT_SCOPE) + elseif(${CMAKE_MSVC_RUNTIME_LIBRARY} STREQUAL MultiThreadedDLL) + set(${result} "MD" PARENT_SCOPE) + elseif(${CMAKE_MSVC_RUNTIME_LIBRARY} STREQUAL MultiThreadedDebugDLL) + set(${result} "MDd" PARENT_SCOPE) + elseif(${CMAKE_MSVC_RUNTIME_LIBRARY} STREQUAL "MultiThreaded$<$<CONFIG:Debug>:Debug>") + if(${build_type} STREQUAL DEBUG) + set(${result} "MTd" PARENT_SCOPE) + else() + set(${result} "MT" PARENT_SCOPE) + endif() + elseif(${CMAKE_MSVC_RUNTIME_LIBRARY} STREQUAL "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL") + if(${build_type} STREQUAL DEBUG) + set(${result} "MDd" PARENT_SCOPE) + else() + set(${result} "MD" PARENT_SCOPE) + endif() + else() + message(FATAL_ERROR "Incorrect CMAKE_MSVC_RUNTIME_LIBRARY value ${CMAKE_MSVC_RUNTIME_LIBRARY}") + endif() + return() + endif() + + set(variables CMAKE_CXX_FLAGS_${build_type} CMAKE_C_FLAGS_${build_type} CMAKE_CXX_FLAGS CMAKE_C_FLAGS) + foreach(variable ${variables}) + if(NOT "${${variable}}" STREQUAL "") + string(REPLACE " " ";" flags "${${variable}}") + foreach (flag ${flags}) + if("${flag}" STREQUAL "/MD" OR "${flag}" STREQUAL "/MDd" OR "${flag}" STREQUAL "/MT" OR "${flag}" STREQUAL "/MTd") + string(SUBSTRING "${flag}" 1 -1 runtime) + set(${result} "${runtime}" PARENT_SCOPE) + return() + endif() + endforeach() + endif() + endforeach() + if("${build_type}" STREQUAL "DEBUG") + set(${result} "MDd" PARENT_SCOPE) + else() + set(${result} "MD" PARENT_SCOPE) + endif() +endfunction() + +function(_collect_settings result) + set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version + compiler.runtime compiler.libcxx compiler.toolset + compiler.cppstd) + foreach(ARG ${ARGUMENTS_PROFILE_AUTO}) + string(TOUPPER ${ARG} _arg_name) + string(REPLACE "." "_" _arg_name ${_arg_name}) + if(_CONAN_SETTING_${_arg_name}) + set(detected_setings ${detected_setings} ${ARG}=${_CONAN_SETTING_${_arg_name}}) + endif() + endforeach() + set(${result} ${detected_setings} PARENT_SCOPE) +endfunction() + +function(conan_cmake_autodetect detected_settings) + _conan_detect_build_type(${ARGV}) + _conan_check_system_name() + _conan_check_language() + _conan_detect_compiler(${ARGV}) + _collect_settings(collected_settings) + set(${detected_settings} ${collected_settings} PARENT_SCOPE) +endfunction() + +macro(conan_parse_arguments) + set(options BASIC_SETUP CMAKE_TARGETS UPDATE KEEP_RPATHS NO_LOAD NO_OUTPUT_DIRS OUTPUT_QUIET NO_IMPORTS SKIP_STD) + set(oneValueArgs CONANFILE ARCH BUILD_TYPE INSTALL_FOLDER CONAN_COMMAND) + set(multiValueArgs DEBUG_PROFILE RELEASE_PROFILE RELWITHDEBINFO_PROFILE MINSIZEREL_PROFILE + PROFILE REQUIRES OPTIONS IMPORTS SETTINGS BUILD ENV GENERATORS PROFILE_AUTO + INSTALL_ARGS CONFIGURATION_TYPES PROFILE_BUILD BUILD_REQUIRES) + cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) +endmacro() + +function(old_conan_cmake_install) + # Calls "conan install" + # Argument BUILD is equivalant to --build={missing, PkgName,...} or + # --build when argument is 'BUILD all' (which builds all packages from source) + # Argument CONAN_COMMAND, to specify the conan path, e.g. in case of running from source + # cmake does not identify conan as command, even if it is +x and it is in the path + conan_parse_arguments(${ARGV}) + + if(CONAN_CMAKE_MULTI) + set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake_multi) + else() + set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake) + endif() + + set(CONAN_BUILD_POLICY "") + foreach(ARG ${ARGUMENTS_BUILD}) + if(${ARG} STREQUAL "all") + set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build) + break() + else() + set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build=${ARG}) + endif() + endforeach() + if(ARGUMENTS_CONAN_COMMAND) + set(CONAN_CMD ${ARGUMENTS_CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + set(CONAN_OPTIONS "") + if(ARGUMENTS_CONANFILE) + if(IS_ABSOLUTE ${ARGUMENTS_CONANFILE}) + set(CONANFILE ${ARGUMENTS_CONANFILE}) + else() + set(CONANFILE ${CMAKE_CURRENT_SOURCE_DIR}/${ARGUMENTS_CONANFILE}) + endif() + else() + set(CONANFILE ".") + endif() + foreach(ARG ${ARGUMENTS_OPTIONS}) + set(CONAN_OPTIONS ${CONAN_OPTIONS} -o=${ARG}) + endforeach() + if(ARGUMENTS_UPDATE) + set(CONAN_INSTALL_UPDATE --update) + endif() + if(ARGUMENTS_NO_IMPORTS) + set(CONAN_INSTALL_NO_IMPORTS --no-imports) + endif() + set(CONAN_INSTALL_FOLDER "") + if(ARGUMENTS_INSTALL_FOLDER) + set(CONAN_INSTALL_FOLDER -if=${ARGUMENTS_INSTALL_FOLDER}) + endif() + foreach(ARG ${ARGUMENTS_GENERATORS}) + set(CONAN_GENERATORS ${CONAN_GENERATORS} -g=${ARG}) + endforeach() + foreach(ARG ${ARGUMENTS_ENV}) + set(CONAN_ENV_VARS ${CONAN_ENV_VARS} -e=${ARG}) + endforeach() + set(conan_args install ${CONANFILE} ${settings} ${CONAN_ENV_VARS} ${CONAN_GENERATORS} ${CONAN_BUILD_POLICY} ${CONAN_INSTALL_UPDATE} ${CONAN_INSTALL_NO_IMPORTS} ${CONAN_OPTIONS} ${CONAN_INSTALL_FOLDER} ${ARGUMENTS_INSTALL_ARGS}) + + string (REPLACE ";" " " _conan_args "${conan_args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_conan_args}") + + if(ARGUMENTS_OUTPUT_QUIET) + execute_process(COMMAND ${CONAN_CMD} ${conan_args} + RESULT_VARIABLE return_code + OUTPUT_VARIABLE conan_output + ERROR_VARIABLE conan_output + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + else() + execute_process(COMMAND ${CONAN_CMD} ${conan_args} + RESULT_VARIABLE return_code + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif() + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan install failed='${return_code}'") + endif() + +endfunction() + +function(conan_cmake_install) + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED) + endif() + + set(installOptions UPDATE NO_IMPORTS OUTPUT_QUIET ERROR_QUIET) + set(installOneValueArgs PATH_OR_REFERENCE REFERENCE REMOTE LOCKFILE LOCKFILE_OUT LOCKFILE_NODE_ID INSTALL_FOLDER) + set(installMultiValueArgs GENERATOR BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE + PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD CONF) + cmake_parse_arguments(ARGS "${installOptions}" "${installOneValueArgs}" "${installMultiValueArgs}" ${ARGN}) + foreach(arg ${installOptions}) + if(ARGS_${arg}) + set(${arg} ${${arg}} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${installOneValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "REMOTE") + set(flag "--remote") + elseif("${arg}" STREQUAL "LOCKFILE") + set(flag "--lockfile") + elseif("${arg}" STREQUAL "LOCKFILE_OUT") + set(flag "--lockfile-out") + elseif("${arg}" STREQUAL "LOCKFILE_NODE_ID") + set(flag "--lockfile-node-id") + elseif("${arg}" STREQUAL "INSTALL_FOLDER") + set(flag "--install-folder") + endif() + set(${arg} ${${arg}} ${flag} ${ARGS_${arg}}) + endif() + endforeach() + foreach(arg ${installMultiValueArgs}) + if(DEFINED ARGS_${arg}) + if("${arg}" STREQUAL "GENERATOR") + set(flag "--generator") + elseif("${arg}" STREQUAL "BUILD") + set(flag "--build") + elseif("${arg}" STREQUAL "ENV") + set(flag "--env") + elseif("${arg}" STREQUAL "ENV_HOST") + set(flag "--env:host") + elseif("${arg}" STREQUAL "ENV_BUILD") + set(flag "--env:build") + elseif("${arg}" STREQUAL "OPTIONS") + set(flag "--options") + elseif("${arg}" STREQUAL "OPTIONS_HOST") + set(flag "--options:host") + elseif("${arg}" STREQUAL "OPTIONS_BUILD") + set(flag "--options:build") + elseif("${arg}" STREQUAL "PROFILE") + set(flag "--profile") + elseif("${arg}" STREQUAL "PROFILE_HOST") + set(flag "--profile:host") + elseif("${arg}" STREQUAL "PROFILE_BUILD") + set(flag "--profile:build") + elseif("${arg}" STREQUAL "SETTINGS") + set(flag "--settings") + elseif("${arg}" STREQUAL "SETTINGS_HOST") + set(flag "--settings:host") + elseif("${arg}" STREQUAL "SETTINGS_BUILD") + set(flag "--settings:build") + elseif("${arg}" STREQUAL "CONF") + set(flag "--conf") + endif() + list(LENGTH ARGS_${arg} numargs) + foreach(item ${ARGS_${arg}}) + if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD") + set(${arg} "--build") + break() + endif() + set(${arg} ${${arg}} ${flag} ${item}) + endforeach() + endif() + endforeach() + if(DEFINED UPDATE) + set(UPDATE --update) + endif() + if(DEFINED NO_IMPORTS) + set(NO_IMPORTS --no-imports) + endif() + set(install_args install ${PATH_OR_REFERENCE} ${REFERENCE} ${UPDATE} ${NO_IMPORTS} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} + ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} + ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD} ${CONF}) + + string(REPLACE ";" " " _install_args "${install_args}") + message(STATUS "Conan executing: ${CONAN_CMD} ${_install_args}") + + if(ARGS_OUTPUT_QUIET) + set(OUTPUT_OPT OUTPUT_QUIET) + endif() + if(ARGS_ERROR_QUIET) + set(ERROR_OPT ERROR_QUIET) + endif() + + execute_process(COMMAND ${CONAN_CMD} ${install_args} + RESULT_VARIABLE return_code + ${OUTPUT_OPT} + ${ERROR_OPT} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + + if(NOT "${return_code}" STREQUAL "0") + if (ARGS_ERROR_QUIET) + message(WARNING "Conan install failed='${return_code}'") + else() + message(FATAL_ERROR "Conan install failed='${return_code}'") + endif() + endif() + +endfunction() + +function(conan_cmake_setup_conanfile) + conan_parse_arguments(${ARGV}) + if(ARGUMENTS_CONANFILE) + get_filename_component(_CONANFILE_NAME ${ARGUMENTS_CONANFILE} NAME) + # configure_file will make sure cmake re-runs when conanfile is updated + configure_file(${ARGUMENTS_CONANFILE} ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk COPYONLY) + file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk) + else() + conan_cmake_generate_conanfile(ON ${ARGV}) + endif() +endfunction() + +function(conan_cmake_configure) + conan_cmake_generate_conanfile(OFF ${ARGV}) +endfunction() + +# Generate, writing in disk a conanfile.txt with the requires, options, and imports +# specified as arguments +# This will be considered as temporary file, generated in CMAKE_CURRENT_BINARY_DIR) +function(conan_cmake_generate_conanfile DEFAULT_GENERATOR) + + conan_parse_arguments(${ARGV}) + + set(_FN "${CMAKE_CURRENT_BINARY_DIR}/conanfile.txt") + file(WRITE ${_FN} "") + + if(DEFINED ARGUMENTS_REQUIRES) + file(APPEND ${_FN} "[requires]\n") + foreach(REQUIRE ${ARGUMENTS_REQUIRES}) + file(APPEND ${_FN} ${REQUIRE} "\n") + endforeach() + endif() + + if (DEFAULT_GENERATOR OR DEFINED ARGUMENTS_GENERATORS) + file(APPEND ${_FN} "[generators]\n") + if (DEFAULT_GENERATOR) + file(APPEND ${_FN} "cmake\n") + endif() + if (DEFINED ARGUMENTS_GENERATORS) + foreach(GENERATOR ${ARGUMENTS_GENERATORS}) + file(APPEND ${_FN} ${GENERATOR} "\n") + endforeach() + endif() + endif() + + if(DEFINED ARGUMENTS_BUILD_REQUIRES) + file(APPEND ${_FN} "[build_requires]\n") + foreach(BUILD_REQUIRE ${ARGUMENTS_BUILD_REQUIRES}) + file(APPEND ${_FN} ${BUILD_REQUIRE} "\n") + endforeach() + endif() + + if(DEFINED ARGUMENTS_IMPORTS) + file(APPEND ${_FN} "[imports]\n") + foreach(IMPORTS ${ARGUMENTS_IMPORTS}) + file(APPEND ${_FN} ${IMPORTS} "\n") + endforeach() + endif() + + if(DEFINED ARGUMENTS_OPTIONS) + file(APPEND ${_FN} "[options]\n") + foreach(OPTION ${ARGUMENTS_OPTIONS}) + file(APPEND ${_FN} ${OPTION} "\n") + endforeach() + endif() + +endfunction() + + +macro(conan_load_buildinfo) + if(CONAN_CMAKE_MULTI) + set(_CONANBUILDINFO conanbuildinfo_multi.cmake) + else() + set(_CONANBUILDINFO conanbuildinfo.cmake) + endif() + if(ARGUMENTS_INSTALL_FOLDER) + set(_CONANBUILDINFOFOLDER ${ARGUMENTS_INSTALL_FOLDER}) + else() + set(_CONANBUILDINFOFOLDER ${CMAKE_CURRENT_BINARY_DIR}) + endif() + # Checks for the existence of conanbuildinfo.cmake, and loads it + # important that it is macro, so variables defined at parent scope + if(EXISTS "${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}") + message(STATUS "Conan: Loading ${_CONANBUILDINFO}") + include(${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}) + else() + message(FATAL_ERROR "${_CONANBUILDINFO} doesn't exist in ${CMAKE_CURRENT_BINARY_DIR}") + endif() +endmacro() + + +macro(conan_cmake_run) + conan_parse_arguments(${ARGV}) + + if(ARGUMENTS_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES) + message(WARNING "CONFIGURATION_TYPES should only be specified for multi-configuration generators") + elseif(ARGUMENTS_CONFIGURATION_TYPES AND ARGUMENTS_BUILD_TYPE) + message(WARNING "CONFIGURATION_TYPES and BUILD_TYPE arguments should not be defined at the same time.") + endif() + + if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE AND NOT CONAN_EXPORTED + AND NOT ARGUMENTS_BUILD_TYPE) + set(CONAN_CMAKE_MULTI ON) + if (NOT ARGUMENTS_CONFIGURATION_TYPES) + set(ARGUMENTS_CONFIGURATION_TYPES "Release;Debug") + endif() + message(STATUS "Conan: Using cmake-multi generator") + else() + set(CONAN_CMAKE_MULTI OFF) + endif() + + if(NOT CONAN_EXPORTED) + conan_cmake_setup_conanfile(${ARGV}) + if(CONAN_CMAKE_MULTI) + foreach(CMAKE_BUILD_TYPE ${ARGUMENTS_CONFIGURATION_TYPES}) + set(ENV{CONAN_IMPORT_PATH} ${CMAKE_BUILD_TYPE}) + conan_cmake_settings(settings ${ARGV}) + old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) + endforeach() + set(CMAKE_BUILD_TYPE) + else() + conan_cmake_settings(settings ${ARGV}) + old_conan_cmake_install(SETTINGS ${settings} ${ARGV}) + endif() + endif() + + if (NOT ARGUMENTS_NO_LOAD) + conan_load_buildinfo() + endif() + + if(ARGUMENTS_BASIC_SETUP) + foreach(_option CMAKE_TARGETS KEEP_RPATHS NO_OUTPUT_DIRS SKIP_STD) + if(ARGUMENTS_${_option}) + if(${_option} STREQUAL "CMAKE_TARGETS") + list(APPEND _setup_options "TARGETS") + else() + list(APPEND _setup_options ${_option}) + endif() + endif() + endforeach() + conan_basic_setup(${_setup_options}) + endif() +endmacro() + +macro(conan_check) + # Checks conan availability in PATH + # Arguments REQUIRED, DETECT_QUIET and VERSION are optional + # Example usage: + # conan_check(VERSION 1.0.0 REQUIRED) + set(options REQUIRED DETECT_QUIET) + set(oneValueArgs VERSION) + cmake_parse_arguments(CONAN "${options}" "${oneValueArgs}" "" ${ARGN}) + if(NOT CONAN_DETECT_QUIET) + message(STATUS "Conan: checking conan executable") + endif() + + find_program(CONAN_CMD conan) + if(NOT CONAN_CMD AND CONAN_REQUIRED) + message(FATAL_ERROR "Conan executable not found! Please install conan.") + endif() + if(NOT CONAN_DETECT_QUIET) + message(STATUS "Conan: Found program ${CONAN_CMD}") + endif() + execute_process(COMMAND ${CONAN_CMD} --version + RESULT_VARIABLE return_code + OUTPUT_VARIABLE CONAN_VERSION_OUTPUT + ERROR_VARIABLE CONAN_VERSION_OUTPUT) + + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan --version failed='${return_code}'") + endif() + + if(NOT CONAN_DETECT_QUIET) + string(STRIP "${CONAN_VERSION_OUTPUT}" _CONAN_VERSION_OUTPUT) + message(STATUS "Conan: Version found ${_CONAN_VERSION_OUTPUT}") + endif() + + if(DEFINED CONAN_VERSION) + string(REGEX MATCH ".*Conan version ([0-9]+\\.[0-9]+\\.[0-9]+)" FOO + "${CONAN_VERSION_OUTPUT}") + if(${CMAKE_MATCH_1} VERSION_LESS ${CONAN_VERSION}) + message(FATAL_ERROR "Conan outdated. Installed: ${CMAKE_MATCH_1}, \ + required: ${CONAN_VERSION}. Consider updating via 'pip \ + install conan==${CONAN_VERSION}'.") + endif() + endif() +endmacro() + +function(conan_add_remote) + # Adds a remote + # Arguments URL and NAME are required, INDEX, COMMAND and VERIFY_SSL are optional + # Example usage: + # conan_add_remote(NAME bincrafters INDEX 1 + # URL https://api.bintray.com/conan/bincrafters/public-conan + # VERIFY_SSL True) + set(oneValueArgs URL NAME INDEX COMMAND VERIFY_SSL) + cmake_parse_arguments(CONAN "" "${oneValueArgs}" "" ${ARGN}) + + if(DEFINED CONAN_INDEX) + set(CONAN_INDEX_ARG "-i ${CONAN_INDEX}") + endif() + if(DEFINED CONAN_COMMAND) + set(CONAN_CMD ${CONAN_COMMAND}) + else() + conan_check(REQUIRED DETECT_QUIET) + endif() + set(CONAN_VERIFY_SSL_ARG "True") + if(DEFINED CONAN_VERIFY_SSL) + set(CONAN_VERIFY_SSL_ARG ${CONAN_VERIFY_SSL}) + endif() + message(STATUS "Conan: Adding ${CONAN_NAME} remote repository (${CONAN_URL}) verify ssl (${CONAN_VERIFY_SSL_ARG})") + execute_process(COMMAND ${CONAN_CMD} remote add ${CONAN_NAME} ${CONAN_INDEX_ARG} -f ${CONAN_URL} ${CONAN_VERIFY_SSL_ARG} + RESULT_VARIABLE return_code) + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan remote failed='${return_code}'") + endif() +endfunction() + +macro(conan_config_install) + # install a full configuration from a local or remote zip file + # Argument ITEM is required, arguments TYPE, SOURCE, TARGET and VERIFY_SSL are optional + # Example usage: + # conan_config_install(ITEM https://github.com/conan-io/cmake-conan.git + # TYPE git SOURCE source-folder TARGET target-folder VERIFY_SSL false) + set(oneValueArgs ITEM TYPE SOURCE TARGET VERIFY_SSL) + set(multiValueArgs ARGS) + cmake_parse_arguments(CONAN "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + find_program(CONAN_CMD conan) + if(NOT CONAN_CMD AND CONAN_REQUIRED) + message(FATAL_ERROR "Conan executable not found!") + endif() + + if(DEFINED CONAN_VERIFY_SSL) + set(CONAN_VERIFY_SSL_ARG "--verify-ssl=${CONAN_VERIFY_SSL}") + endif() + + if(DEFINED CONAN_TYPE) + set(CONAN_TYPE_ARG "--type=${CONAN_TYPE}") + endif() + + if(DEFINED CONAN_ARGS) + set(CONAN_ARGS_ARGS "--args=\"${CONAN_ARGS}\"") + endif() + + if(DEFINED CONAN_SOURCE) + set(CONAN_SOURCE_ARGS "--source-folder=${CONAN_SOURCE}") + endif() + + if(DEFINED CONAN_TARGET) + set(CONAN_TARGET_ARGS "--target-folder=${CONAN_TARGET}") + endif() + + set (CONAN_CONFIG_INSTALL_ARGS ${CONAN_VERIFY_SSL_ARG} + ${CONAN_TYPE_ARG} + ${CONAN_ARGS_ARGS} + ${CONAN_SOURCE_ARGS} + ${CONAN_TARGET_ARGS}) + + message(STATUS "Conan: Installing config from ${CONAN_ITEM}") + execute_process(COMMAND ${CONAN_CMD} config install ${CONAN_ITEM} ${CONAN_CONFIG_INSTALL_ARGS} + RESULT_VARIABLE return_code) + if(NOT "${return_code}" STREQUAL "0") + message(FATAL_ERROR "Conan config failed='${return_code}'") + endif() +endmacro() diff --git a/build/export_generators/hardcoded-cmake/cmake/cuda.cmake b/build/export_generators/hardcoded-cmake/cmake/cuda.cmake new file mode 100644 index 0000000000..5764bb65c3 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/cuda.cmake @@ -0,0 +1,188 @@ +if (HAVE_CUDA) + if(${CMAKE_VERSION} VERSION_LESS "3.17.0") + message(FATAL_ERROR "Build with CUDA requires at least cmake 3.17.0") + endif() + + enable_language(CUDA) + + include(global_flags) + include(common) + + function(quote_if_contains_spaces OutVar Var) + if (Var MATCHES ".*[ ].*") + set(${OutVar} "\"${Var}\"" PARENT_SCOPE) + else() + set(${OutVar} ${Var} PARENT_SCOPE) + endif() + endfunction() + + function(get_cuda_flags_from_cxx_flags OutCudaFlags CxxFlags) + # OutCudaFlags is an output string + # CxxFlags is a string + + set(skipList + -gline-tables-only + # clang coverage + -fprofile-instr-generate + -fcoverage-mapping + /Zc:inline # disable unreferenced functions (kernel registrators) remove + -Wno-c++17-extensions + -flto + -faligned-allocation + -fsized-deallocation + # While it might be reasonable to compile host part of .cu sources with these optimizations enabled, + # nvcc passes these options down towards cicc which lacks x86_64 extensions support. + -msse2 + -msse3 + -mssse3 + -msse4.1 + -msse4.2 + ) + + set(skipPrefixRegexp + "(-fsanitize=|-fsanitize-coverage=|-fsanitize-blacklist=|--system-header-prefix|(/|-)std(:|=)c\\+\\+).*" + ) + + string(FIND "${CMAKE_CUDA_HOST_COMPILER}" clang hostCompilerIsClangPos) + string(COMPARE NOTEQUAL ${hostCompilerIsClangPos} -1 isHostCompilerClang) + + + function(separate_arguments_with_special_symbols Output Src) + string(REPLACE ";" "$<SEMICOLON>" LocalOutput "${Src}") + separate_arguments(LocalOutput NATIVE_COMMAND ${LocalOutput}) + set(${Output} ${LocalOutput} PARENT_SCOPE) + endfunction() + + separate_arguments_with_special_symbols(Separated_CxxFlags "${CxxFlags}") + + if (MSVC) + set(flagPrefixSymbol "/") + else() + set(flagPrefixSymbol "-") + endif() + + set(localCudaCommonFlags "") # non host compiler options + set(localCudaCompilerOptions "") + + while (Separated_CxxFlags) + list(POP_FRONT Separated_CxxFlags cxxFlag) + if ((cxxFlag IN_LIST skipList) OR (cxxFlag MATCHES ${skipPrefixRegexp})) + continue() + endif() + if ((cxxFlag STREQUAL -fopenmp=libomp) AND (NOT isHostCompilerClang)) + list(APPEND localCudaCompilerOptions -fopenmp) + continue() + endif() + if ((NOT isHostCompilerClang) AND (cxxFlag MATCHES "^\-\-target=.*")) + continue() + endif() + if (cxxFlag MATCHES "^${flagPrefixSymbol}(D[^ ]+)=(.+)") + set(key ${CMAKE_MATCH_1}) + quote_if_contains_spaces(safeValue "${CMAKE_MATCH_2}") + list(APPEND localCudaCommonFlags "-${key}=${safeValue}") + continue() + endif() + if (cxxFlag MATCHES "^${flagPrefixSymbol}([DI])(.*)") + set(key ${CMAKE_MATCH_1}) + if (CMAKE_MATCH_2) + set(value ${CMAKE_MATCH_2}) + set(sep "") + else() + list(POP_FRONT Separated_CxxFlags value) + set(sep " ") + endif() + quote_if_contains_spaces(safeValue "${value}") + list(APPEND localCudaCommonFlags "-${key}${sep}${safeValue}") + continue() + endif() + list(APPEND localCudaCompilerOptions ${cxxFlag}) + endwhile() + + if (isHostCompilerClang) + # nvcc concatenates the sources for clang, and clang reports unused + # things from .h files as if they they were defined in a .cpp file. + list(APPEND localCudaCommonFlags -Wno-unused-function -Wno-unused-parameter) + if (CMAKE_CXX_COMPILER_TARGET) + list(APPEND localCudaCompilerOptions "--target=${CMAKE_CXX_COMPILER_TARGET}") + endif() + endif() + + if (CMAKE_SYSROOT) + list(APPEND localCudaCompilerOptions "--sysroot=${CMAKE_SYSROOT}") + endif() + + list(JOIN localCudaCommonFlags " " joinedLocalCudaCommonFlags) + string(REPLACE "$<SEMICOLON>" ";" joinedLocalCudaCommonFlags "${joinedLocalCudaCommonFlags}") + list(JOIN localCudaCompilerOptions , joinedLocalCudaCompilerOptions) + set(${OutCudaFlags} "${joinedLocalCudaCommonFlags} --compiler-options ${joinedLocalCudaCompilerOptions}" PARENT_SCOPE) + endfunction() + + get_cuda_flags_from_cxx_flags(CMAKE_CUDA_FLAGS "${CMAKE_CXX_FLAGS}") + + string(APPEND CMAKE_CUDA_FLAGS + # Allow __host__, __device__ annotations in lambda declaration. + " --expt-extended-lambda" + # Allow host code to invoke __device__ constexpr functions and vice versa + " --expt-relaxed-constexpr" + ) + + set(NVCC_STD_VER 14) + if(MSVC) + set(NVCC_STD "/std:c++${NVCC_STD_VER}") + else() + set(NVCC_STD "-std=c++${NVCC_STD_VER}") + endif() + string(APPEND CMAKE_CUDA_FLAGS " --compiler-options ${NVCC_STD}") + + string(APPEND CMAKE_CUDA_FLAGS " -DTHRUST_IGNORE_CUB_VERSION_CHECK") + + if(MSVC) + # default CMake flags differ from our configuration + set(CMAKE_CUDA_FLAGS_DEBUG "-D_DEBUG --compiler-options /Z7,/Ob0,/Od") + set(CMAKE_CUDA_FLAGS_MINSIZEREL "-DNDEBUG --compiler-options /O1,/Ob1") + set(CMAKE_CUDA_FLAGS_RELEASE "-DNDEBUG --compiler-options /Ox,/Ob2,/Oi") + set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "-DNDEBUG --compiler-options /Z7,/Ox,/Ob1") + endif() + + # use versions from contrib, standard libraries from CUDA distibution are incompatible with MSVC and libcxx + set(CUDA_EXTRA_INCLUDE_DIRECTORIES + ${CMAKE_SOURCE_DIR}/contrib/libs/nvidia/thrust + ${CMAKE_SOURCE_DIR}/contrib/libs/nvidia/cub + ) + + find_package(CUDAToolkit REQUIRED) + + if(${CMAKE_CUDA_COMPILER_VERSION} VERSION_GREATER_EQUAL "11.2") + string(APPEND CMAKE_CUDA_FLAGS " --threads 0") + endif() + + message(VERBOSE "CMAKE_CUDA_FLAGS = \"${CMAKE_CUDA_FLAGS}\"") + + enable_language(CUDA) + + function(target_cuda_flags Tgt) + set_property(TARGET ${Tgt} APPEND PROPERTY + CUDA_FLAGS ${ARGN} + ) + endfunction() + + function(target_cuda_cflags Tgt) + if (NOT ("${ARGN}" STREQUAL "")) + string(JOIN "," OPTIONS ${ARGN}) + set_property(TARGET ${Tgt} APPEND PROPERTY + CUDA_FLAGS --compiler-options ${OPTIONS} + ) + endif() + endfunction() + + function(target_cuda_sources Tgt Scope) + # add include directories on per-CMakeLists file level because some non-CUDA source files may want to include calls to CUDA libs + include_directories(${CUDA_EXTRA_INCLUDE_DIRECTORIES}) + + set_source_files_properties(${ARGN} PROPERTIES + COMPILE_OPTIONS "$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},CUDA_FLAGS>>,;>" + ) + target_sources(${Tgt} ${Scope} ${ARGN}) + endfunction() + +endif() diff --git a/build/export_generators/hardcoded-cmake/cmake/cython.cmake b/build/export_generators/hardcoded-cmake/cmake/cython.cmake new file mode 100644 index 0000000000..d239c2dc58 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/cython.cmake @@ -0,0 +1,41 @@ +function(target_cython_include_directories Tgt) + set_property(TARGET ${Tgt} APPEND PROPERTY + CYTHON_INCLUDE_DIRS ${ARGN} + ) +endfunction() + +function(target_cython_options Tgt) + set_property(TARGET ${Tgt} APPEND PROPERTY + CYTHON_OPTIONS ${ARGN} + ) +endfunction() + +macro(set_python_type_for_cython Tgt Type) + if (${Type} STREQUAL PY3) + find_package(Python3 REQUIRED COMPONENTS Interpreter) + set_property(TARGET ${Tgt} APPEND PROPERTY + CYTHON_PYTHON_INTERPRETER ${Python3_EXECUTABLE} + ) + else() + find_package(Python2 REQUIRED COMPONENTS Interpreter) + set_property(TARGET ${Tgt} APPEND PROPERTY + CYTHON_PYTHON_INTERPRETER ${Python2_EXECUTABLE} + ) + endif() +endmacro() + +function(target_cython_sources Tgt Scope) + foreach(Input ${ARGN}) + get_filename_component(OutputBase ${Input} NAME) + set(CppCythonOutput ${CMAKE_CURRENT_BINARY_DIR}/${OutputBase}.cpp) + add_custom_command( + OUTPUT ${CppCythonOutput} + COMMAND $<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},CYTHON_PYTHON_INTERPRETER>> ${CMAKE_SOURCE_DIR}/contrib/tools/cython/cython.py ${Input} -o ${CppCythonOutput} + "$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},CYTHON_OPTIONS>>,$<SEMICOLON>>" + "-I$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},CYTHON_INCLUDE_DIRS>>,$<SEMICOLON>-I>" + COMMAND_EXPAND_LISTS + DEPENDS ${OUTPUT_INCLUDES} + ) + target_sources(${Tgt} ${Scope} ${CppCythonOutput}) + endforeach() +endfunction() diff --git a/build/export_generators/hardcoded-cmake/cmake/fat_object.cmake b/build/export_generators/hardcoded-cmake/cmake/fat_object.cmake new file mode 100644 index 0000000000..ae81534e81 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/fat_object.cmake @@ -0,0 +1,8 @@ +function(add_fat_object Target) + add_executable(${Target} EXCLUDE_FROM_ALL) + set_property(TARGET ${Target} PROPERTY EchoString "Partial linking ${FAT_OBJECT_PREFIX}${Target}${FAT_OBJECT_SUFFIX}") + set_property(TARGET ${Target} PROPERTY SUFFIX ${FAT_OBJECT_SUFFIX}) + set_property(TARGET ${Target} PROPERTY PREFIX ${FAT_OBJECT_PREFIX}) + set_property(TARGET ${Target} PROPERTY POSITION_INDEPENDENT_CODE Off) + target_link_options(${Target} PRIVATE -Wl,-r -nodefaultlibs -nostartfiles) +endfunction()
\ No newline at end of file diff --git a/build/export_generators/hardcoded-cmake/cmake/fbs.cmake b/build/export_generators/hardcoded-cmake/cmake/fbs.cmake new file mode 100644 index 0000000000..8de30b8f61 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/fbs.cmake @@ -0,0 +1,29 @@ +include(common) + +function(target_fbs_source Tgt Key Src) + get_built_tool_path(flatc_bin flatc_dependency contrib/tools/flatc/bin flatc) + + file(RELATIVE_PATH fbsRel ${CMAKE_SOURCE_DIR} ${Src}) + get_filename_component(OutputBase ${fbsRel} NAME_WLE) + get_filename_component(OutputDir ${CMAKE_BINARY_DIR}/${fbsRel} DIRECTORY) + add_custom_command( + OUTPUT + ${CMAKE_BINARY_DIR}/${fbsRel}.h + ${CMAKE_BINARY_DIR}/${fbsRel}.cpp + ${OutputDir}/${OutputBase}.iter.fbs.h + ${OutputDir}/${OutputBase}.bfbs + COMMAND Python3::Interpreter + ${CMAKE_SOURCE_DIR}/build/scripts/cpp_flatc_wrapper.py + ${flatc_bin} + ${FBS_CPP_FLAGS} ${ARGN} + -o ${CMAKE_BINARY_DIR}/${fbsRel}.h + ${Src} + DEPENDS ${CMAKE_SOURCE_DIR}/build/scripts/cpp_flatc_wrapper.py ${Src} ${flatc_dependency} + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + ) + target_sources(${Tgt} ${Key} + ${CMAKE_BINARY_DIR}/${fbsRel}.cpp + ${CMAKE_BINARY_DIR}/${fbsRel}.h + ${OutputDir}/${OutputBase}.iter.fbs.h + ) +endfunction() diff --git a/build/export_generators/hardcoded-cmake/cmake/global_flags.cmake b/build/export_generators/hardcoded-cmake/cmake/global_flags.cmake new file mode 100644 index 0000000000..e57e9ebcf9 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/global_flags.cmake @@ -0,0 +1,50 @@ +set(CMAKE_C_FLAGS "") +set(CMAKE_CXX_FLAGS "") + +# workaround when old NDK toolchain that does not set CMAKE_ANDROID_NDK_VERSION is used +# See for details: https://gitlab.kitware.com/cmake/cmake/-/issues/24386 +if(ANDROID_NDK_REVISION AND NOT CMAKE_ANDROID_NDK_VERSION) + set(CMAKE_ANDROID_NDK_VERSION "${ANDROID_NDK_REVISION}") +endif() + +if (MSVC) + set(flagPrefixSymbol "/") + include(global_flags.compiler.msvc) + include(global_flags.linker.msvc) +else() + set(flagPrefixSymbol "-") + include(global_flags.compiler.gnu) + include(global_flags.linker.gnu) +endif() + +if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(i686|x86_64|AMD64)$") + set(_ALL_X86_EXTENSIONS_DEFINES "\ + ${flagPrefixSymbol}DSSE_ENABLED=1 \ + ${flagPrefixSymbol}DSSE3_ENABLED=1 \ + ${flagPrefixSymbol}DSSSE3_ENABLED=1 \ + ") + if ((CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$") OR (NOT ANDROID)) + string(APPEND _ALL_X86_EXTENSIONS_DEFINES "\ + ${flagPrefixSymbol}DSSE41_ENABLED=1 \ + ${flagPrefixSymbol}DSSE42_ENABLED=1 \ + ${flagPrefixSymbol}DPOPCNT_ENABLED=1 \ + ") + if (NOT ANDROID) + # older clang versions did not support this feature on Android: + # https://reviews.llvm.org/rGc32d307a49f5255602e7543e64e6c38a7f536abc + string(APPEND _ALL_X86_EXTENSIONS_DEFINES " ${flagPrefixSymbol}DCX16_ENABLED=1") + endif() + endif() + + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_ALL_X86_EXTENSIONS_DEFINES}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_ALL_X86_EXTENSIONS_DEFINES}") +endif() + +message(VERBOSE "CMAKE_C_FLAGS = \"${CMAKE_C_FLAGS}\"") +message(VERBOSE "CMAKE_CXX_FLAGS = \"${CMAKE_CXX_FLAGS}\"") + +if (NOT CMAKE_CROSSCOMPILING) + set(TOOLS_ROOT ${CMAKE_BINARY_DIR}) +elseif(NOT TOOLS_ROOT) + message(FATAL_ERROR "TOOLS_ROOT is required for crosscompilation") +endif() diff --git a/build/export_generators/hardcoded-cmake/cmake/llvm-tools.cmake b/build/export_generators/hardcoded-cmake/cmake/llvm-tools.cmake new file mode 100644 index 0000000000..d743400b96 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/llvm-tools.cmake @@ -0,0 +1,111 @@ +if (REQUIRED_LLVM_TOOLING_VERSION) + if (CMAKE_VERSION VERSION_LESS 3.18) + message(FATAL_ERROR "Forcing LLVM tooling versions requires at least cmake 3.18") + endif() + find_program(CLANGPLUSPLUS clang++-${REQUIRED_LLVM_TOOLING_VERSION} REQUIRED) + find_program(CLANGC clang-${REQUIRED_LLVM_TOOLING_VERSION} REQUIRED) + find_program(LLVMLINK llvm-link-${REQUIRED_LLVM_TOOLING_VERSION} REQUIRED) + find_program(LLVMOPT opt-${REQUIRED_LLVM_TOOLING_VERSION} REQUIRED) + find_program(LLVMLLC llc-${REQUIRED_LLVM_TOOLING_VERSION} REQUIRED) + find_program(LLVMAS llvm-as ${REQUIRED_LLVM_TOOLING_VERSION} REQUIRED) +else() + if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set(CLANGPLUSPLUS ${CMAKE_CXX_COMPILER}) + message(STATUS "Using ${CLANGPLUSPLUS} for c++ to LLVM IR translation") + else() + find_program(CLANGPLUSPLUS NAMES clang++-12 clang++-14 clang++) + if (CLANGPLUSPLUS MATCHES "CLANGPLUSPLUS-NOTFOUND") + message(SEND_ERROR "clang++ not found") + else() + message(STATUS "Using ${CLANGPLUSPLUS} for c++ to LLVM IR translation") + endif() + endif() + + if (CMAKE_C_COMPILER_ID MATCHES "Clang") + set(CLANGC ${CMAKE_C_COMPILER}) + message(STATUS "Using ${CLANGC} for c++ to LLVM IR translation") + else() + find_program(CLANGC NAMES clang-12 clang-14 clang) + if (CLANGC MATCHES "CLANGC-NOTFOUND") + message(SEND_ERROR "clang not found") + else() + message(STATUS "Using ${CLANGC} for c to LLVM IR translation") + endif() + endif() + + find_program(LLVMLINK NAMES llvm-link-12 llvm-link-14 llvm-link) + if (LLVMLINK MATCHES "LLVMLINK-NOTFOUND") + message(SEND_ERROR "llvm-link not found") + else() + message(STATUS "Using ${LLVMLINK} for LLVM IR linking") + endif() + find_program(LLVMOPT NAMES opt-12 opt-14 opt) + if (LLVMOPT MATCHES "LLVMOPT-NOTFOUND") + message(SEND_ERROR "llvm opt tool not found") + else() + message(STATUS "Using ${LLVMOPT} for LLVM IR optimization") + endif() + + find_program(LLVMLLC NAMES llc-12 llc-14 llc) + if (LLVMLLC MATCHES "LLVMLLC-NOTFOUND") + message(SEND_ERROR "llvm llc tool not found") + else() + message(STATUS "Using ${LLVMLLC} for LLVM IR to binary code compilation") + endif() + find_program(LLVMAS NAMES llvm-as-12 llvm-as-14 llvm-as) + if (LLVMAS MATCHES "LLVMAS-NOTFOUND") + message(SEND_ERROR "llvm-as not found") + else() + message(STATUS "Using ${LLVMAS} for LLVM IR -> BC assembling") + endif() +endif() + +function(llvm_compile_cxx Tgt Inpt Out Tool UseC) + list(APPEND TARGET_INCLUDES "-I$<JOIN:$<TARGET_PROPERTY:${Tgt},INCLUDE_DIRECTORIES>,$<SEMICOLON>-I>") + list(APPEND TARGET_COMPILE_OPTIONS "'$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},COMPILE_OPTIONS>>,'$<SEMICOLON>'>'") + list(APPEND TARGET_COMPILE_DEFINITIONS "'-D$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},COMPILE_DEFINITIONS>>,'$<SEMICOLON>'-D>'") + if (${UseC}) + set(STD_FLAG "") + separate_arguments(LANG_FLAGS NATIVE_COMMAND ${CMAKE_C_FLAGS}) + separate_arguments(FLAGSLIST_DEBUG NATIVE_COMMAND ${CMAKE_C_FLAGS_DEBUG}) + separate_arguments(FLAGSLIST_RELEASE NATIVE_COMMAND ${CMAKE_C_FLAGS_RELEASE}) + separate_arguments(FLAGSLIST_MINSIZEREL NATIVE_COMMAND ${CMAKE_C_FLAGS_MINSIZEREL}) + separate_arguments(FLAGSLIST_RELWITHDEBINFO NATIVE_COMMAND ${CMAKE_C_FLAGS_RELWITHDEBINFO}) + else() + get_target_property(TARGET_STANDARD ${Tgt} CXX_STANDARD) + set(STD_FLAG "-std=c++${TARGET_STANDARD}") + separate_arguments(LANG_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS}) + separate_arguments(FLAGSLIST_DEBUG NATIVE_COMMAND ${CMAKE_CXX_FLAGS_DEBUG}) + separate_arguments(FLAGSLIST_RELEASE NATIVE_COMMAND ${CMAKE_CXX_FLAGS_RELEASE}) + separate_arguments(FLAGSLIST_MINSIZEREL NATIVE_COMMAND ${CMAKE_CXX_FLAGS_MINSIZEREL}) + separate_arguments(FLAGSLIST_RELWITHDEBINFO NATIVE_COMMAND ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}) + endif() + + add_custom_command( + OUTPUT ${Out} + COMMAND + ${Tool} + ${TARGET_INCLUDES} + ${LANG_FLAGS} + "$<$<CONFIG:DEBUG>:${FLAGSLIST_DEBUG}>" + "$<$<CONFIG:RELEASE>:${FLAGSLIST_RELEASE}>" + "$<$<CONFIG:MINSIZEREL>:${FLAGSLIST_MINSIZEREL}>" + "$<$<CONFIG:RELWITHDEBINFO>:${FLAGSLIST_RELWITHDEBINFO}>" + ${TARGET_COMPILE_DEFINITIONS} + ${STD_FLAG} + ${TARGET_COMPILE_OPTIONS} + -Wno-unknown-warning-option + -fno-lto + -emit-llvm + -c + ${Inpt} + -o + ${Out} + COMMAND_EXPAND_LISTS + DEPENDS ${Inpt} ${Tool} + ) +endfunction() + +function(llvm_compile_c Tgt Inpt Out Tool) + llvm_compile_cxx(${Tgt} ${Inpt} ${Out} ${Tool} TRUE) +endfunction() diff --git a/build/export_generators/hardcoded-cmake/cmake/masm.cmake b/build/export_generators/hardcoded-cmake/cmake/masm.cmake new file mode 100644 index 0000000000..1b64c71542 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/masm.cmake @@ -0,0 +1,9 @@ +if (MSVC) + +enable_language(ASM_MASM) + +macro(curdir_masm_flags) + set(CMAKE_ASMMASM_FLAGS ${ARGN}) +endmacro() + +endif() diff --git a/build/export_generators/hardcoded-cmake/cmake/protobuf.cmake b/build/export_generators/hardcoded-cmake/cmake/protobuf.cmake new file mode 100644 index 0000000000..774f0c7a3e --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/protobuf.cmake @@ -0,0 +1,111 @@ +include(common) + +function(target_proto_plugin Tgt Name PluginTarget) + set_property(TARGET ${Tgt} APPEND PROPERTY + PROTOC_OPTS --${Name}_out=${CMAKE_BINARY_DIR}/$<TARGET_PROPERTY:${Tgt},PROTO_NAMESPACE> --plugin=protoc-gen-${Name}=$<TARGET_FILE:${PluginTarget}> + ) + set_property(TARGET ${Tgt} APPEND PROPERTY + PROTOC_DEPS ${PluginTarget} + ) +endfunction() + +function(target_proto_addincls Tgt) + set_property(TARGET ${Tgt} APPEND PROPERTY + PROTO_ADDINCL ${ARGN} + ) +endfunction() + +function(target_proto_outs Tgt) + set_property(TARGET ${Tgt} APPEND PROPERTY + PROTO_OUTS ${ARGN} + ) +endfunction() + +function(target_proto_messages Tgt Scope) + get_built_tool_path(protoc_bin protoc_dependency contrib/tools/protoc/bin protoc) + get_built_tool_path(cpp_styleguide_bin cpp_styleguide_dependency contrib/tools/protoc/plugins/cpp_styleguide cpp_styleguide) + + get_property(ProtocExtraOutsSuf TARGET ${Tgt} PROPERTY PROTOC_EXTRA_OUTS) + foreach(proto ${ARGN}) + if(proto MATCHES ${CMAKE_BINARY_DIR}) + file(RELATIVE_PATH protoRel ${CMAKE_BINARY_DIR} ${proto}) + elseif (proto MATCHES ${CMAKE_SOURCE_DIR}) + file(RELATIVE_PATH protoRel ${CMAKE_SOURCE_DIR} ${proto}) + else() + set(protoRel ${proto}) + endif() + get_filename_component(OutputBase ${protoRel} NAME_WLE) + get_filename_component(OutputDir ${CMAKE_BINARY_DIR}/${protoRel} DIRECTORY) + list(TRANSFORM ProtocExtraOutsSuf PREPEND ${OutputDir}/${OutputBase} OUTPUT_VARIABLE ProtocExtraOuts) + add_custom_command( + OUTPUT + ${OutputDir}/${OutputBase}.pb.cc + ${OutputDir}/${OutputBase}.pb.h + ${ProtocExtraOuts} + COMMAND ${protoc_bin} + ${COMMON_PROTOC_FLAGS} + "-I$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},PROTO_ADDINCL>>,;-I>" + "$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},PROTO_OUTS>>,;>" + --plugin=protoc-gen-cpp_styleguide=${cpp_styleguide_bin} + "$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},PROTOC_OPTS>>,;>" + ${protoRel} + DEPENDS + ${proto} + $<TARGET_PROPERTY:${Tgt},PROTOC_DEPS> + ${protoc_dependency} + ${cpp_styleguide_dependency} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + COMMAND_EXPAND_LISTS + ) + target_sources(${Tgt} ${Scope} + ${OutputDir}/${OutputBase}.pb.cc ${OutputDir}/${OutputBase}.pb.h + ${ProtocExtraOuts} + ) + endforeach() +endfunction() + +function(target_ev_messages Tgt Scope) + get_built_tool_path(protoc_bin protoc_dependency contrib/tools/protoc/bin protoc) + get_built_tool_path(cpp_styleguide_bin cpp_styleguide_dependency contrib/tools/protoc/plugins/cpp_styleguide cpp_styleguide) + get_built_tool_path(event2cpp_bin event2cpp_dependency tools/event2cpp/bin event2cpp) + + get_property(ProtocExtraOutsSuf TARGET ${Tgt} PROPERTY PROTOC_EXTRA_OUTS) + foreach(proto ${ARGN}) + if(proto MATCHES ${CMAKE_BINARY_DIR}) + file(RELATIVE_PATH protoRel ${CMAKE_BINARY_DIR} ${proto}) + elseif (proto MATCHES ${CMAKE_SOURCE_DIR}) + file(RELATIVE_PATH protoRel ${CMAKE_SOURCE_DIR} ${proto}) + else() + set(protoRel ${proto}) + endif() + get_filename_component(OutputBase ${protoRel} NAME_WLE) + get_filename_component(OutputDir ${CMAKE_BINARY_DIR}/${protoRel} DIRECTORY) + list(TRANSFORM ProtocExtraOutsSuf PREPEND ${OutputDir}/${OutputBase} OUTPUT_VARIABLE ProtocExtraOuts) + add_custom_command( + OUTPUT + ${OutputDir}/${OutputBase}.ev.pb.cc + ${OutputDir}/${OutputBase}.ev.pb.h + ${ProtocExtraOuts} + COMMAND ${protoc_bin} + ${COMMON_PROTOC_FLAGS} + "-I$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},PROTO_ADDINCL>>,;-I>" + "$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},PROTO_OUTS>>,;>" + --plugin=protoc-gen-cpp_styleguide=${cpp_styleguide_bin} + --plugin=protoc-gen-event2cpp=${event2cpp_bin} + "$<JOIN:$<TARGET_GENEX_EVAL:${Tgt},$<TARGET_PROPERTY:${Tgt},PROTOC_OPTS>>,;>" + ${protoRel} + DEPENDS + ${proto} + $<TARGET_PROPERTY:${Tgt},PROTOC_DEPS> + ${protoc_dependency} + ${cpp_styleguide_dependency} + ${event2cpp_dependency} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + COMMAND_EXPAND_LISTS + ) + target_sources(${Tgt} ${Scope} + ${OutputDir}/${OutputBase}.ev.pb.cc ${OutputDir}/${OutputBase}.ev.pb.h + ${ProtocExtraOuts} + ) + endforeach() +endfunction() diff --git a/build/export_generators/hardcoded-cmake/cmake/recursive_library.cmake b/build/export_generators/hardcoded-cmake/cmake/recursive_library.cmake new file mode 100644 index 0000000000..f3596edcbc --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/recursive_library.cmake @@ -0,0 +1,50 @@ +function(add_recursive_library Target) + if (${CMAKE_VERSION} VERSION_LESS "3.21.0") + message(FATAL_ERROR "add_recursive_library requires at least cmake 3.21.0 (because it uses CXX_LINKER_LAUNCHER)") + endif() + + if (CMAKE_GENERATOR MATCHES "Visual.Studio.*") + message(FATAL_ERROR "add_recursive_library is incompatible with Visual Studio generators") + endif() + + find_package(Python3 REQUIRED) + + # this is not really an executable but we will use it to make CMake collect all dependencies to pass to the custom linking command (because there's no proper way to do it otherwise) + add_executable(${Target} EXCLUDE_FROM_ALL) + if (NOT (DEFINED CMAKE_POSITION_INDEPENDENT_CODE)) + # default should be the same as for usual static libraries - https://cmake.org/cmake/help/latest/prop_tgt/POSITION_INDEPENDENT_CODE.html + set_property(TARGET ${Target} PROPERTY POSITION_INDEPENDENT_CODE Off) + endif() + + set_property(TARGET ${Target} PROPERTY PREFIX ${CMAKE_STATIC_LIBRARY_PREFIX}) + set_property(TARGET ${Target} PROPERTY SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX}) + + # the result will consist of two files at most (if there are no input files of particular type the resulting output files won't be created): + # ${PREFIX}${Target}${SUFFIX} - for objects not requiring global initialization + # ${PREFIX}${Target}${GLOBAL_PART_SUFFIX}${SUFFIX} - for objects requiring global initialization + set(GLOBAL_PART_SUFFIX ".global") + + if (MSVC) + # if this is not disabled CMake generates additional call to mt.exe after the linking command, manifests are needed only for real executables and dlls + target_link_options(${Target} PRIVATE "/MANIFEST:NO") + endif() + string(CONCAT CXX_LINKER_LAUNCHER_CMD "${Python3_EXECUTABLE}" + ";${CMAKE_SOURCE_DIR}/build/scripts/create_recursive_library_for_cmake.py" + ";--cmake-binary-dir;${CMAKE_BINARY_DIR}" + ";--cmake-ar;${CMAKE_AR}" + ";--cmake-ranlib;${CMAKE_RANLIB}" + ";--cmake-host-system-name;${CMAKE_HOST_SYSTEM_NAME}" + ";--global-part-suffix;${GLOBAL_PART_SUFFIX}" + ) + if (CMAKE_CXX_STANDARD_LIBRARIES) + # because they have to be excluded from input + string(APPEND CXX_LINKER_LAUNCHER_CMD ";--cmake-cxx-standard-libraries;${CMAKE_CXX_STANDARD_LIBRARIES}") + endif() + string(APPEND CXX_LINKER_LAUNCHER_CMD ";--linking-cmdline") # this must be the last argument + + set_property(TARGET ${Target} PROPERTY CXX_LINKER_LAUNCHER ${CXX_LINKER_LAUNCHER_CMD}) + set_property(TARGET ${Target} PROPERTY LINK_DEPENDS + "${CMAKE_SOURCE_DIR}/build/scripts/create_recursive_library_for_cmake.py" + ";${CMAKE_SOURCE_DIR}/build/scripts/link_lib.py" + ) +endfunction() diff --git a/build/export_generators/hardcoded-cmake/cmake/shared_libs.cmake b/build/export_generators/hardcoded-cmake/cmake/shared_libs.cmake new file mode 100644 index 0000000000..2c9de143cc --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/shared_libs.cmake @@ -0,0 +1,9 @@ +add_custom_target(all-shared-libs) + +function(add_shared_library Tgt) + add_library(${Tgt} SHARED ${ARGN}) + add_dependencies(all-shared-libs ${Tgt}) + if (NOT CMAKE_POSITION_INDEPENDENT_CODE) + set_property(TARGET ${Tgt} PROPERTY EXCLUDE_FROM_ALL On) + endif() +endfunction() diff --git a/build/export_generators/hardcoded-cmake/cmake/swig.cmake b/build/export_generators/hardcoded-cmake/cmake/swig.cmake new file mode 100644 index 0000000000..d4bb2a2536 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/cmake/swig.cmake @@ -0,0 +1,51 @@ +set(SWIG_EXECUTABLE ${CMAKE_BINARY_DIR}/bin/swig${CMAKE_EXECUTABLE_SUFFIX}) +set(SWIG_SOURCE_FILE_EXTENSIONS .swg) + +function(add_swig_jni_library TgtName) + set(opts "") + set(oneval_args GEN_JAVA_FILES_LIST) + set(multival_args SOURCES) + cmake_parse_arguments(SWIG_JNI_LIB + "${opts}" + "${oneval_args}" + "${multival_args}" + ${ARGN} + ) + + set_property(SOURCE + ${SWIG_JNI_LIB_SOURCES} + PROPERTY + CPLUSPLUS On + ) + + file(RELATIVE_PATH PathInProject ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) + string(REPLACE "/" "." JVMPackageName ${PathInProject}) + string(REPLACE "-" "_" JVMPackageName ${JVMPackageName}) + string(PREPEND JVMPackageName "ru.yandex.") + + string(REPLACE "." "/" OutDir ${JVMPackageName}) + string(CONCAT OutDirAbs ${CMAKE_CURRENT_BINARY_DIR} "/java/" ${OutDir}) + + swig_add_library(${TgtName} + TYPE SHARED + LANGUAGE java + OUTPUT_DIR ${OutDirAbs} + OUTFILE_DIR ${CMAKE_CURRENT_BINARY_DIR}/cpp + SOURCES + ${SWIG_JNI_LIB_SOURCES} + ) + + if(APPLE) + # for some legacy reason swig_add_library uses '.jnilib' suffix which has been replaced with '.dylib' since JDK7 + set_target_properties(${TgtName} PROPERTIES SUFFIX ".dylib") + endif() + + set_property(TARGET ${TgtName} PROPERTY SWIG_COMPILE_OPTIONS -package ${JVMPackageName}) + + add_custom_command(TARGET + ${TgtName} + POST_BUILD COMMAND + ${CMAKE_COMMAND} -DJAVA_SRC_DIR=${OutDirAbs} -DJAVA_LST=${CMAKE_CURRENT_BINARY_DIR}/swig_gen_java.lst -P ${CMAKE_SOURCE_DIR}/build/scripts/gather_swig_java.cmake + BYPRODUCTS ${SWIG_JNI_LIB_GEN_JAVA_FILES_LIST} + ) +endfunction() diff --git a/build/export_generators/hardcoded-cmake/generator.toml b/build/export_generators/hardcoded-cmake/generator.toml index 9800de5177..85b58d9f26 100644 --- a/build/export_generators/hardcoded-cmake/generator.toml +++ b/build/export_generators/hardcoded-cmake/generator.toml @@ -4,17 +4,153 @@ copy=[ "cmake/global_flags.compiler.gnu.cmake", "cmake/global_flags.compiler.msvc.cmake", "cmake/global_flags.linker.gnu.cmake", - "cmake/global_flags.linker.msvc.cmake" + "cmake/global_flags.linker.msvc.cmake", + "cmake/global_flags.cmake", ] +[attrs.root] +includes="list" + [attrs.target] -vcs_info="list" -target_joined_source="list" -target_sources_custom="list" -target_ragel_lexers="list" -target_yasm_source="list" -add_global_library_for="list" [[rules]] -attrs=["vcs_info", "target_joined_source", "target_sources_custom", "target_ragel_lexers", "target_yasm_source", "add_global_library_for"] -copy=["cmake/common.cmake","build/scripts/export_script_gen.py","build/scripts/split_unittest.py","build/scripts/generate_vcs_info.py"] +attrs=["run_antlr"] +copy=["cmake/antlr.cmake"] +add_values=[{attr="includes", values=["cmake/antlr.cmake"]}] + +[[rules]] +attrs=[ + "target_bison_parser", + "target_flex_lexers" +] +copy=["cmake/bison.cmake"] +add_values=[{attr="includes", values=["cmake/bison.cmake"]}] + +[[rules]] +attrs=[ + "conan_add_remote", + "conan_check", + "conan_cmake_autodetect", + "conan_cmake_configure", + "conan_cmake_detect_unix_libcxx", + "conan_cmake_detect_vs_runtime", + "conan_cmake_generate_conanfile", + "conan_cmake_install", + "conan_cmake_run", + "conan_cmake_settings", + "conan_cmake_setup_conanfile", + "conan_config_install", + "conan_load_buildinfo", + "conan_parse_arguments", + "conan_require", + "conan_require_tool", + "old_conan_cmake_install", +] +copy=["cmake/conan.cmake"] +add_values=[{attr="includes", values=["cmake/conan.cmake"]}] + +[[rules]] +attrs=[ + "target_ev_messages", + "target_proto_messages", + "target_proto_plugin", + "target_proto_outs", + "target_proto_addincls", +] +copy=["cmake/protobuf.cmake"] +add_values=[{attr="includes", values=["cmake/protobuf.cmake"]}] + +[[rules]] +attrs=[ + "add_global_library_for", + "archive", + "resources_file", + "generate_enum_serilization", + "copy", + "target_joined_source", + "target_ragel_lexers", + "target_yasm_source", + "vcs_info", + "target_sources_custom", + "use_export_script", + "add_yunittest", + "set_yunittest_property", +] +copy=[ + "cmake/common.cmake", + "build/scripts/export_script_gen.py", + "build/scripts/split_unittest.py", + "build/scripts/generate_vcs_info.py" +] +add_values=[{attr="includes", values=["cmake/common.cmake"]}] + +[[rules]] +attrs=[ + "llvm_compile_c", + "llvm_compile_cxx", +] +copy=["cmake/llvm-tools.cmake"] +add_values=[{attr="includes", values=["cmake/llvm-tools.cmake"]}] + +[[rules]] +attrs=["curdir_masm_flags"] +copy=["cmake/masm.cmake"] +add_values=[{attr="includes", values=["cmake/masm.cmake"]}] + +[[rules]] +attrs=["target_fbs_source"] +copy=["cmake/fbs.cmake"] +add_values=[{attr="includes", values=["cmake/fbs.cmake"]}] + +[[rules]] +attrs=["add_fat_object"] +copy=["cmake/fat_object.cmake"] +add_values=[{attr="includes", values=["cmake/fat_objects.cmake"]}] + +[[rules]] +attrs=["add_recursive_library"] +copy=[ + "cmake/recursive_library.cmake", + "build/scripts/create_recursive_library_for_cmake.py" +] +add_values=[{attr="includes", values=["cmake/recursive_library.cmake"]}] + +[[rules]] +attrs=["add_shared_library"] +copy=["cmake/shared_libs.cmake"] +add_values=[{attr="includes", values=["cmake/shared_libs.cmake"]}] + +[[rules]] +attrs=[ + "target_cuda_flags", + "target_cuda_cflags", + "target_cuda_sources" +] +copy=["cmake/cuda.cmake"] +add_values=[{attr="includes", values=["cmake/cuda.cmake"]}] + +[[rules]] +attrs=["target_rodata_sources"] +copy=["cmake/archive.cmake"] +add_values=[{attr="includes", values=["cmake/archive.cmake"]}] + +[[rules]] +attrs=[ + "target_cython_sources", + "target_cython_options", + "target_cython_include_directories", + "set_python_type_for_cython", +] +copy=["cmake/cython.cmake"] +add_values=[{attr="includes", values=["cmake/cython.cmake"]}] + +[[rules]] +attrs=[ + "swig_add_library", + "add_jar" +] +copy=[ + "cmake/swig.cmake", + "build/scripts/gather_swig_java.cmake" +] +add_values=[{attr="includes", values=["cmake/swig.cmake"]}] diff --git a/build/export_generators/hardcoded-cmake/scripts b/build/export_generators/hardcoded-cmake/scripts new file mode 100644 index 0000000000..8874b8b915 --- /dev/null +++ b/build/export_generators/hardcoded-cmake/scripts @@ -0,0 +1,80 @@ +import argparse +import tempfile +import shlex +import subprocess + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument("--split-factor", type=int, default=0) + parser.add_argument("--shard", type=int, default=0) + parser.add_argument("--fork-mode", type=str, default="SEQUENTIAL") + parser.add_argument("command", nargs=argparse.REMAINDER) + return parser.parse_args() + + +def get_sequential_chunk(tests, modulo, modulo_index): + chunk_size = len(tests) // modulo + not_used = len(tests) % modulo + shift = chunk_size + (modulo_index < not_used) + start = chunk_size * modulo_index + min(modulo_index, not_used) + end = start + shift + return [] if end > len(tests) else tests[start:end] + + +def get_shuffled_chunk(tests, modulo, modulo_index): + result_tests = [] + for i, test in enumerate(tests): + if i % modulo == modulo_index: + result_tests.append(test) + return result_tests + + +def list_tests(binary): + with tempfile.NamedTemporaryFile() as tmpfile: + cmd = [binary, "--list-verbose", "--list-path", tmpfile.name] + subprocess.check_call(cmd) + + with open(tmpfile.name) as afile: + lines = afile.read().strip().split("\n") + lines = [x.strip() for x in lines] + return [x for x in lines if x] + + +def get_shard_tests(args): + test_names = list_tests(args.command[0]) + test_names = sorted(test_names) + + if args.fork_mode == "MODULO": + return get_shuffled_chunk(test_names, args.split_factor, args.shard) + elif args.fork_mode == "SEQUENTIAL": + return get_sequential_chunk(test_names, args.split_factor, args.shard) + else: + raise ValueError("detected unknown partition mode: {}".format(args.fork_mode)) + + +def get_shard_cmd_args(args): + return ["+{}".format(x) for x in get_shard_tests(args)] + + +def main(): + args = parse_args() + + if args.split_factor: + shard_cmd = get_shard_cmd_args(args) + if shard_cmd: + cmd = args.command + shard_cmd + else: + print("No tests for {} shard".format(args.shard)) + return 0 + else: + cmd = args.command + + rc = subprocess.call(cmd) + if rc: + print("Some tests failed. To reproduce run: {}".format(shlex.join(cmd))) + return rc + + +if __name__ == "__main__": + exit(main()) |