# Split a list into named arguments in the current scope. # # Example: # ~~~ # set(_mylist foo bar baz 1 2 3) # EXPLODE(_mylist _var1 _var2 _var3) # message(" var1: ${_var1}\n" " var2: ${_var2}\n" " var3: ${_var3}\n") # ~~~ # # Which will output: # ~~~ # var1: foo # var2: bar # var3: baz # ~~~ macro(EXPLODE listname) set(_args ${ARGN}) list(LENGTH "${listname}" _list_len) list(LENGTH _args _args_len) if("${_args_len}" LESS "${_list_len}") message( FATAL_ERROR " Can't EXPLODE ${_args_len} elements into ${_list_len} elements:\n" " ${_args}") endif() set(_idx "0") foreach(varname ${ARGN}) list(GET ${listname} ${_idx} ${varname}) math(EXPR _idx "${_idx} + 1}") endforeach() endmacro() # Join a list of strings into a single string # # usage: # ~~~ # join( [GLUE ] [arg1 [arg2 [arg3 [...]]]]) # ~~~ function(join outvar) cmake_parse_arguments(args "" "GLUE" "" ${ARGN}) set(joined) foreach(part ${args_UNPARSED_ARGUMENTS}) set(joined "${joined}${args_GLUE}${part}") endforeach() set(${outvar} "${joined}" PARENT_SCOPE) endfunction() # Backport list(FILTER ...) to cmake < 3.6 function(list_filter listname) set(localcopy ${${listname}}) if("${CMAKE_VERSION}" VERSION_GREATER "3.5.999") # cmake-lint: disable=E1120 list(FILTER localcopy ${ARGN}) else() cmake_parse_arguments(_args "" "REGEX" "" ${ARGN}) explode(_args_UNPARSED_ARGUMENTS _mode) set(buffer) if("${_mode}" STREQUAL "INCLUDE") foreach(elem ${localcopy}) if("${elem}" MATCHES "${_args_REGEX}") list(APPEND buffer "${elem}") endif() endforeach() else() foreach(elem ${localcopy}) if(NOT "${elem}" MATCHES "${_args_REGEX}") list(APPEND buffer "${elem}") endif() endforeach() endif() set(localcopy ${buffer}) endif() set(${listname} ${localcopy} PARENT_SCOPE) endfunction() # Wraps `execute_process` and reports error if any command in the list of # commands fails. function(check_call) cmake_parse_arguments(_args "" "OUTPUT_VARIABLE;ERROR_VARIABLE" "" ${ARGN}) set(request_results_list) if("${CMAKE_VERSION}" VERSION_GREATER "3.9.999") set(request_results_list RESULTS_VARIABLE results) endif() set(results) execute_process( ${_args_UNPARSED_ARGUMENTS} OUTPUT_VARIABLE stdout ERROR_VARIABLE stderr RESULT_VARIABLE result ${request_results_list}) set(kwargs COMMAND WORKING_DIRECTORY TIMEOUT RESULT_VARIABLE RESULTS_VARIABLE OUTPUT_VARIABLE ERROR_VARIABLE INPUT_FILE OUTPUT_FILE ERROR_FILE OUTPUT_QUIET ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE ENCODING) string(REPLACE ";" "|" kwargs "${kwargs}") set(buffer ${_args_UNPARSED_ARGUMENTS}) # Turn the cmake list into a regular string with '%' as an item separator string(REPLACE ";" "%" buffer "${buffer}") # Split the string at keyword boundaries string(REGEX REPLACE "\\%(${kwargs})\\%" ";\\1%" buffer "${buffer}") # Remove list items that aren't COMMAND set(buffer2 ${buffer}) list_filter(buffer2 INCLUDE REGEX "COMMAND%.*") # Save the list of commands set(cmds "${buffer2}") set(idx "0") foreach(result ${results}) if(NOT "${result}" EQUAL "0") list(GET cmds ${idx} cmdstr) string(REPLACE "COMMAND%" "" cmdstr "${cmdstr}") string(REPLACE "%" " " cmdstr "${cmdstr}") message(FATAL_ERROR " Failed to execute command ${idx}:\n" " ${cmdstr}\n ${stderr}") endif() math(EXPR idx "${idx} + 1}") endforeach() if(NOT "${result}" EQUAL "0") string(REPLACE "COMMAND%" "\n " cmdlines "${cmds}") string(REPLACE "%" " " cmdlines "${cmdlines}") message(FATAL_ERROR " Failed to execute one or more command:\n" " ${cmdlines}\n" " ${stderr}") endif() if(_args_OUTPUT_VARIABLE) set(${_args_OUTPUT_VARIABLE} ${stdout} PARENT_SCOPE) endif() if(_args_ERROR_VARIABLE) set(${_args_ERROR_VARIABLE} ${stderr} PARENT_SCOPE) endif() endfunction() # Executes a python oneline using `execute_process` and reports error if the # command failed function(check_pyoneline) cmake_parse_arguments(_args "" "OUTPUT_VARIABLE;ERROR_VARIABLE" "" ${ARGN}) # Escape semicolons in the cmake list, the resulting string will contain \\\; # for each semicolon. When we pass this into check_call the escape sequences # will be interpreted, resulting in \; within the `COMMAND` argument to # execute_process. string(REPLACE ";" "\\\\\\;" _oneline "${_args_UNPARSED_ARGUMENTS}") set(_pyonline ${ARGN}) check_call( # NOTE(josh): cmake concats lines using semicolon, which is the same # separator that python expects, so we don't need to do any special # processing. The cmake list-concat gives us a python oneliner for free. COMMAND python -Bc "${_oneline}" OUTPUT_VARIABLE stdout ERROR_VARIABLE stderr OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE) if(_args_OUTPUT_VARIABLE) set(${_args_OUTPUT_VARIABLE} ${stdout} PARENT_SCOPE) endif() if(_args_ERROR_VARIABLE) set(${_args_ERROR_VARIABLE} ${stderr} PARENT_SCOPE) endif() endfunction() # Get a list of all known properties check_call(COMMAND ${CMAKE_COMMAND} --help-property-list OUTPUT_VARIABLE _propslist) # Replace newlines with list separator string(REGEX REPLACE "[\n ]+" ";" _propslist "${_propslist}") set(KNOWN_PROPERTIES ${_propslist}) function(tangent_addtest) cmake_parse_arguments(_args "" "NAME;WORKING_DIRECTORY" "COMMAND;CONFIGURATIONS;DEPENDS" ${ARGN}) add_test( NAME ${_args_NAME} COMMAND ${_args_COMMAND} WORKING_DIRECTORY ${_args_WORKING_DIRECTORY} CONFIGURATIONS ${_args_CONFIGURATIONS}) add_custom_target( runtest.${_args_NAME} DEPENDS ${_args_DEPENDS} COMMAND ${_args_COMMAND} WORKING_DIRECTORY ${_args_WORKING_DIRECTORY}) add_dependencies(best-test runtest.${_args_NAME}) endfunction() # Wraps add_library and provides additional keyword options that translate into # additional calls to target_link_libraries, target_set_properties, etc. Usage: # ~~~ # cc_library( [STATIC|SHARED] # SRCS src1.cc src2.cc src3.cc # DEPS lib1 lib2 lib3) # ~~~ # # Keyword Arguments: # # *INCS*: a list of include directories that should be added using # target_include_dirs # # *SRCS*: a list of source files that go into compilation. These translate to # the positional arguments of add_library(). # # *DEPS*: a list of libraries to link against. These should be names that cmake # understands. They are passed as the positional arguments to # target_link_libraires # # *PKGDEPS*: A list of pkg-config names that are dependencies of this # executable. They are passed as positional arguments to target_pkg_depends function(cc_library target_name) set(flags) set(oneargs) set(multiargs INC SRCS DEPS PKGDEPS PROPERTIES) cmake_parse_arguments(_args "${flags}" "${oneargs}" "${multiargs}" ${ARGN}) add_library(${target_name} ${_args_UNPARSED_ARGUMENTS} ${_args_SRCS}) if(_args_INC) target_include_directories(${target_name} ${_args_INC}) endif() if(_args_DEPS) list(GET _args_DEPS 0 dep0) if(NOT "${_dep0}" MATCHES "(PUBLIC)|(PRIVATE)|(INTERFACE)") list(INSERT _args_DEPS 0 "PUBLIC") endif() target_link_libraries(${target_name} ${_args_DEPS}) endif() if(_args_PKGDEPS) target_pkg_depends(${target_name} ${_args_PKGDEPS}) endif() if(_args_PROPERTIES) # cmake-lint: disable=E1120 set_target_properties(${target_name} PROPERTIES ${_args_PROPERTIES}) endif() endfunction() # Wraps add_executable and provides additional keyword options that translate # into additional calls to target_link_libraries, target_set_properties, etc. # Usage: # ~~~ # cc_binary( # SRCS src1.cc src2.cc src3.cc # DEPS lib1 lib2 lib3) # ~~~ # # Keyword Arguments: # # *SRCS*: a list of source files that go into compilation. These translate to # the positional arguments of add_executable(). # # *DEPS*: a list of libraries to link against. These should be names that cmake # understands. They are passed as the positional arguments to # target_link_libraires # # *PKGDEPS*: A list of pkg-config names that are dependencies of this # executable. They are passed as positional arguments to target_pkg_depends function(cc_binary target_name) set(flags ADD_RUNTARGET) set(oneargs) set(multiargs SRCS DEFS DEPS PKGDEPS PROPERTIES) cmake_parse_arguments(_args "${flags}" "${oneargs}" "${multiargs}" ${ARGN}) add_executable(${target_name} ${_args_UNPARSED_ARGUMENTS} ${_args_SRCS}) if(_args_DEPS) target_link_libraries(${target_name} PUBLIC ${_args_DEPS}) endif() if(_args_PKGDEPS) target_pkg_depends(${target_name} ${_args_PKGDEPS}) endif() if(_args_PROPERTIES) # cmake-lint: disable=E1120 set_target_properties(${target_name} PROPERTIES ${_args_PROPERTIES}) endif() if(_args_DEFS) target_compile_definitions(${target_name} ${_args_DEFS}) endif() if(_args_ADD_RUNTARGET) add_custom_target( run.${target_name} COMMAND ${target_name} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) endif() endfunction() # Wraps a pair of calls to cc_binary and add_test and provides additional # keyword options that translate to additional calls to set_property # # Usage: # ~~~ # cc_test( # ARGV --flag1 --flag2 # TEST_DEPS file1 file2 # WORKING_DIRECTORY # LABELS label1 label2) # ~~~ # # In addition to creating the executable, this command will also create a target # `run.` which can be specified as a target to the build system. When # specified as a build target, will ensure that all the depenencies are up-to- # date before executing the test. # # The name of the test will match the name of the executable target. # # Keyword Arguments: # # *ARGV*: a list of additional command line options added to the command used # for the test # # *TEST_DEPS*: additional file-level dependencies required to execute the test, # such as golden data or resource files. # # *WORKING_DIRECTORY*: working directory where to execute the command # # *LABELS*: a list of ctest labels pased to set_property(TEST ...) function(cc_test target_name) set(flags) set(oneargs WORKING_DIRECTORY) set(multiargs ARGV TEST_DEPS LABELS) cmake_parse_arguments(args "${flags}" "${oneargs}" "${multiargs}" ${ARGN}) set(cmd $ ${args_ARGV}) cc_binary(${target_name} ${args_UNPARSED_ARGUMENTS}) if(NOT args_WORKING_DIRECTORY) set(args_WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}) endif() if(args_TEST_DEPS) add_custom_target(testdeps.${target_name} DEPENDS ${TEST_DEPS}) add_dependencies(testdeps testdeps.${target_name}) endif() add_custom_target( run.${target_name} COMMAND ${cmd} DEPENDS ${args_TEST_DEPS} WORKING_DIRECTORY ${args_WORKING_DIRECTORY}) add_test( NAME ${target_name} COMMAND ${cmd} WORKING_DIRECTORY ${args_WORKING_DIRECTORY}) if(args_LABELS) set_property( TEST ${target_name} APPEND PROPERTY LABELS ${args_LABELS}) endif() endfunction() # Given a list of variables in the current scope, assign their value to a # variable of the same name in the parent scope macro(RETURNVARS) foreach(varname ${ARGN}) set(${varname} "${${varname}}" PARENT_SCOPE) endforeach() endmacro() set_property(GLOBAL PROPERTY SEMVER_INCLUDENO 0) # Get the version string by parsing a C++ header file. The version is expected # to be in the form of: # # ~~~ # define FOO_VERSION \ # { 0, 1, 0, "dev", 0 } # ~~~ # # Usage: # ~~~ # get_version_from_header( ) # ~~~ # # Assigns into the calling scope a variable with the same name as `${macro}` the # value of the version function(get_version_from_header headerpath macro) get_property(_includeno GLOBAL PROPERTY SEMVER_INCLUDENO) math(EXPR _includeno "${_includeno} + 1") set_property(GLOBAL PROPERTY SEMVER_INCLUDENO ${_includeno}) set(stubfile ${CMAKE_CURRENT_BINARY_DIR}/semver-${_includeno}.cmake) if(NOT IS_ABSOLUTE ${headerpath}) set(headerpath ${CMAKE_CURRENT_SOURCE_DIR}/${headerpath}) endif() execute_process( COMMAND python -B ${TANGENT_TOOLING}/get_version_from_header.py # --outfile ${stubfile} ${macro} ${headerpath} WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} RESULT_VARIABLE _retcode OUTPUT_VARIABLE _stdout ERROR_VARIABLE _stderr) if(NOT "${_retcode}" EQUAL "0") message( FATAL_ERROR " Failed to extract version number from" " ${headerpath}: ${_retcode}\n" " ${_stdout}\n" " ${_stderr}") endif() include(${stubfile} RESULT_VARIABLE _result) if(_result STREQUAL NOTFOUND) message(FATAL_ERROR "Failed to include stubfile ${stubfile}") endif() string(REGEX MATCH "(.*)_VERSION" _match "${macro}") if(_match) set(prefix ${CMAKE_MATCH_1}) else() message( FATAL_ERROR "Header version macro '${macro}' does not end in _VERSION") endif() returnvars(${prefix}_VERSION ${prefix}_API_VERSION ${prefix}_SO_VERSION) endfunction() # map package name to source directory set(_package_pairs "argue\;argue" # "libtangent-util\;tangent/util" # "libtangent-json\;tangent/json" # "gtangent\;gtangent" # "gtangentmm\;gtangentmm" # ) foreach(pair ${_package_pairs}) explode(pair _package_name _repodir) set(TANGENT_PACKAGE_SOURCEDIR_${_package_name} ${_repodir}) endforeach() # Wraps a call to find_package() for a tangent supplied cmake package and # pre-empt the call to find_package() if the package exists locally in the # sparse checkout, function(find_tangent_package package_name) set(repodir ${TANGENT_PACKAGE_SOURCEDIR_${package_name}}) if(EXISTS ${CMAKE_SOURCE_DIR}/${repodir}) return() endif() find_package(${package_name} ${ARGN}) endfunction() # Tunable verbose logging function(vlog level) if(NOT DEFINED TANGENT_VERBOSE_LEVEL) return() endif() if("${level}" GREATER ${TANGENT_VERBOSE_LEVEL}) return() endif() message(STATUS ${ARGN}) endfunction() # Glob the current source directory for any children that have listfiles, and # add them. function(glob_subdirs) # NOTE(josh): search through the list of child directories and add any that # actually contain a listfile. While globs are evil, this is necessary for # sparse checkouts. We can and should correctly add dependencies for this glob # in order to retrigger cmake. file( GLOB children RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*) foreach(child ${children}) set(candidate ${CMAKE_CURRENT_SOURCE_DIR}/${child}/CMakeLists.txt) if(EXISTS ${candidate}) file(RELATIVE_PATH relpath_candidate "${CMAKE_SOURCE_DIR}" "${candidate}") vlog(1 "Enabling subdirectory ${relpath_candidate}") add_subdirectory(${child}) endif() endforeach() endfunction() # If this build system was generated on travis, the include a rule to decrypt # the given file to the given location. function(travis_decrypt tgtfile srcfile keyid) get_filename_component(_filename ${tgtfile} NAME) if(IS_TRAVIS_CI) add_custom_command( OUTPUT ${tgtfile} DEPENDS ${srcfile} COMMAND # cmake-format: off openssl aes-256-cbc # NOTE(josh): we could use $ENV{...} but then we end up with the # actual encryption key in the command line... which might show up # in logs or error messages. -K "\$\${encrypted_${keyid}_key}" -iv "\$\${encrypted_${keyid}_iv}" -in ${srcfile} -out ${tgtfile} -d # cmake-format: on COMMAND chmod 0600 ${tgtfile} COMMENT "Decrypting ${_filename}") endif() endfunction()