Warning, /utilities/okteta/cmake/OktetaInternalMacros.cmake is written in an unsupported language. File is not indexed.
0001 #
0002 # Okteta Private Macros
0003 #
0004 # SPDX-FileCopyrightText: 2018, 2019 Friedrich W. H. Kossebau <kossebau@kde.org>
0005 #
0006 # SPDX-License-Identifier: BSD-3-Clause
0007 #
0008
0009 # ECM
0010 include(ECMGenerateHeaders)
0011 include(ECMGeneratePriFile)
0012 include(ECMGeneratePkgConfigFile)
0013 # CMake
0014 include(CMakePackageConfigHelpers)
0015 include(CheckCXXCompilerFlag)
0016
0017 # helper macros
0018 function(_okteta_target_name _varName _baseName)
0019 string(CONCAT _namespacePrefix ${ARGN})
0020 set(${_varName} "${_namespacePrefix}${_baseName}" PARENT_SCOPE)
0021 endfunction()
0022
0023
0024 function(_okteta_setup_namespace)
0025 set(options
0026 )
0027 set(oneValueArgs
0028 BASE_NAME
0029 NAMESPACEPREFIX_VAR
0030 VERSIONEDNAMESPACEPREFIX_VAR
0031 VERSIONEDNAMESPACE_VAR
0032 )
0033 set(multiValueArgs
0034 NAMESPACE
0035 ABIVERSION
0036 )
0037 cmake_parse_arguments(OKTETA_SETUP_NAMESPACE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0038
0039 string(CONCAT _namespacePrefix ${OKTETA_SETUP_NAMESPACE_NAMESPACE})
0040
0041 if (OKTETA_SETUP_NAMESPACE_ABIVERSION)
0042 list(LENGTH OKTETA_SETUP_NAMESPACE_ABIVERSION _abiversionCount)
0043 list(LENGTH OKTETA_SETUP_NAMESPACE_NAMESPACE _namespaceCount)
0044 if (NOT _abiversionCount EQUAL _namespaceCount)
0045 message(FATAL_ERROR "ABIVERSION needs to have as many elements as NAMESPACE if used")
0046 endif()
0047 math(EXPR _namespaceLastIndex "${_namespaceCount} - 1")
0048
0049 set(_versioned_namespace)
0050 foreach(val RANGE ${_namespaceLastIndex})
0051 list(GET OKTETA_SETUP_NAMESPACE_NAMESPACE ${val} _namespace)
0052 list(GET OKTETA_SETUP_NAMESPACE_ABIVERSION ${val} _abiversion)
0053 list(APPEND _versioned_namespace "${_namespace}${_abiversion}")
0054 endforeach()
0055 string(CONCAT _versionedNamespacePrefix ${_versioned_namespace})
0056 else()
0057 set(_versioned_namespace ${OKTETA_SETUP_NAMESPACE_NAMESPACE})
0058 set(_versionedNamespacePrefix "${_namespacePrefix}")
0059 endif()
0060
0061 if (OKTETA_SETUP_NAMESPACE_NAMESPACEPREFIX_VAR)
0062 set(${OKTETA_SETUP_NAMESPACE_NAMESPACEPREFIX_VAR} ${_namespacePrefix} PARENT_SCOPE)
0063 endif()
0064 if (OKTETA_SETUP_NAMESPACE_VERSIONEDNAMESPACEPREFIX_VAR)
0065 set(${OKTETA_SETUP_NAMESPACE_VERSIONEDNAMESPACEPREFIX_VAR} ${_versionedNamespacePrefix} PARENT_SCOPE)
0066 endif()
0067 if (OKTETA_SETUP_NAMESPACE_VERSIONEDNAMESPACE_VAR)
0068 set(${OKTETA_SETUP_NAMESPACE_VERSIONEDNAMESPACE_VAR} ${_versioned_namespace} PARENT_SCOPE)
0069 endif()
0070 endfunction()
0071
0072 function(_okteta_generate_version_code)
0073 set(options
0074 )
0075 set(oneValueArgs
0076 CODE_VARIABLE
0077 PREFIX
0078 VERSION
0079 )
0080 set(multiValueArgs
0081 )
0082 cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0083
0084 # Omit any leading "0" in extraction, would otherwise yield an octal value string in C++ (08, 09)
0085 string(REGEX REPLACE "^0*([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" _version_major "${ARGS_VERSION}")
0086 string(REGEX REPLACE "^[0-9]+\\.0*([0-9]+)\\.[0-9]+.*" "\\1" _version_minor "${ARGS_VERSION}")
0087 string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.0*([0-9]+).*" "\\1" _version_patch "${ARGS_VERSION}")
0088 math(EXPR _version_hexnumber "${_version_major}*65536 + ${_version_minor}*256 + ${_version_patch}" OUTPUT_FORMAT HEXADECIMAL)
0089
0090 set(_content
0091 "#define ${ARGS_PREFIX}_VERSION_STRING \"${ARGS_VERSION}\"
0092 #define ${ARGS_PREFIX}_VERSION_MAJOR ${_version_major}
0093 #define ${ARGS_PREFIX}_VERSION_MINOR ${_version_minor}
0094 #define ${ARGS_PREFIX}_VERSION_PATCH ${_version_patch}
0095 #define ${ARGS_PREFIX}_VERSION ${_version_hexnumber}
0096 "
0097 )
0098 set(${ARGS_CODE_VARIABLE} "${_content}" PARENT_SCOPE)
0099 endfunction()
0100
0101 function(_okteta_generate_export_code)
0102 set(options
0103 )
0104 set(oneValueArgs
0105 CODE_VARIABLE
0106 PREFIX
0107 TARGET_NAME
0108 )
0109 set(multiValueArgs
0110 )
0111 cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0112
0113 if(NOT WIN32)
0114 check_cxx_compiler_flag("-fvisibility=hidden" COMPILER_SUPPORTS_HIDDEN_VISIBILITY)
0115 endif()
0116
0117 set(_staticlib_macro_name "${ARGS_PREFIX}_STATICLIB")
0118 set(_export_macro_name "${ARGS_PREFIX}_EXPORT")
0119 set(_no_export_macro_name "${ARGS_PREFIX}_NO_EXPORT")
0120 set(_content
0121 "#ifdef ${_staticlib_macro_name}
0122 # define ${_export_macro_name}
0123 # define ${_no_export_macro_name}
0124 #else
0125 # ifndef ${_export_macro_name}
0126 "
0127 )
0128 if(WIN32)
0129 get_target_property(_building_lib_flag ${ARGS_TARGET_NAME} DEFINE_SYMBOL)
0130
0131 if(NOT _building_lib_flag)
0132 # calculate cmake default preprocessor definition set when building a shared library
0133 set(_building_lib_flag ${ARGS_TARGET_NAME}_EXPORTS)
0134 string(MAKE_C_IDENTIFIER ${_building_lib_flag} _building_lib_flag)
0135 endif()
0136
0137 string(APPEND _content
0138 "# ifdef ${_building_lib_flag}
0139 // Library is built
0140 # define ${_export_macro_name} __declspec(dllexport)
0141 # else
0142 // Library is consumed
0143 # define ${_export_macro_name} __declspec(dllimport)
0144 # endif
0145 "
0146 )
0147 else()
0148 if(COMPILER_SUPPORTS_HIDDEN_VISIBILITY)
0149 string(APPEND _content "# define ${_export_macro_name} __attribute__((visibility(\"default\")))\n")
0150 else()
0151 string(APPEND _content "# define ${_export_macro_name}\n")
0152 endif()
0153 endif()
0154 string(APPEND _content "# endif\n")
0155
0156 string(APPEND _content "# ifndef ${_no_export_macro_name}\n")
0157 if(WIN32)
0158 string(APPEND _content "# define ${_no_export_macro_name}\n")
0159 else()
0160 if(COMPILER_SUPPORTS_HIDDEN_VISIBILITY)
0161 string(APPEND _content "# define ${_no_export_macro_name} __attribute__((visibility(\"hidden\")))\n")
0162 else()
0163 string(APPEND _content "# define ${_no_export_macro_name}\n")
0164 endif()
0165 endif()
0166 string(APPEND _content
0167 "# endif
0168 #endif
0169 "
0170 )
0171
0172 set(${ARGS_CODE_VARIABLE} "${_content}" PARENT_SCOPE)
0173 endfunction()
0174
0175 function(_okteta_generate_header_file)
0176 set(options
0177 )
0178 set(oneValueArgs
0179 CODE
0180 INCLUDE_GUARD_NAME
0181 EXPORT_FILE_NAME
0182 )
0183 set(multiValueArgs
0184 )
0185 cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0186
0187 file(GENERATE OUTPUT ${ARGS_EXPORT_FILE_NAME} CONTENT
0188 "#ifndef ${ARGS_INCLUDE_GUARD_NAME}
0189 #define ${ARGS_INCLUDE_GUARD_NAME}
0190
0191 ${ARGS_CODE}
0192 #endif
0193 "
0194 )
0195 endfunction()
0196
0197 # TODO: consider renaming to okteta_add_classes
0198 macro(okteta_add_sublibrary _baseName)
0199 set(options
0200 NO_VERSIONED_INCLUDEDIR
0201 REVERSE_NAMESPACE_INCLUDEDIR
0202 BUILD_INCLUDEDIR
0203 )
0204 set(oneValueArgs
0205 SUBDIR
0206 LIBRARY
0207 )
0208 set(multiValueArgs
0209 NAMESPACE
0210 PUBLIC
0211 PRIVATE
0212 KCFG
0213 UI
0214 QRC
0215 )
0216 cmake_parse_arguments(OKTETA_ADD_SUBLIBRARY "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0217
0218 _okteta_target_name(_targetName ${_baseName} ${OKTETA_ADD_SUBLIBRARY_NAMESPACE})
0219
0220 string(CONCAT _namespaceConcat ${OKTETA_ADD_SUBLIBRARY_NAMESPACE})
0221 string(TOLOWER "${_namespaceConcat}${_baseName}" _libname)
0222 if (OKTETA_ADD_SUBLIBRARY_LIBRARY)
0223 set(_library_target ${OKTETA_ADD_SUBLIBRARY_LIBRARY})
0224 else()
0225 set(_library_target ${_targetName})
0226 endif()
0227 if (OKTETA_ADD_SUBLIBRARY_SUBDIR)
0228 set(_relativePath "${OKTETA_ADD_SUBLIBRARY_SUBDIR}/")
0229 set(_egh_relative_param RELATIVE ${OKTETA_ADD_SUBLIBRARY_SUBDIR})
0230 else()
0231 set(_relativePath)
0232 set(_egh_relative_param)
0233 endif()
0234 set(_srcs )
0235
0236 foreach(_classname ${OKTETA_ADD_SUBLIBRARY_PUBLIC} ${OKTETA_ADD_SUBLIBRARY_PRIVATE})
0237 string(TOLOWER "${_classname}" _lc_classname)
0238
0239 set(_source "${_relativePath}${_lc_classname}.cpp")
0240 set(_actualsource "${CMAKE_CURRENT_SOURCE_DIR}/${_source}")
0241 if (EXISTS ${_actualsource})
0242 list(APPEND _srcs "${_source}")
0243 endif()
0244
0245 set(_source "${_relativePath}${_lc_classname}_p.cpp")
0246 set(_actualsource "${CMAKE_CURRENT_SOURCE_DIR}/${_source}")
0247 if (EXISTS ${_actualsource})
0248 list(APPEND _srcs "${_source}")
0249 endif()
0250 endforeach()
0251
0252 foreach(_kcfg ${OKTETA_ADD_SUBLIBRARY_KCFG})
0253 kconfig_add_kcfg_files(${_library_target} "${_relativePath}${_kcfg}")
0254 endforeach()
0255
0256 foreach(_ui ${OKTETA_ADD_SUBLIBRARY_UI})
0257 ki18n_wrap_ui(${_library_target} "${_relativePath}${_ui}")
0258 endforeach()
0259
0260 foreach(_qrc ${OKTETA_ADD_SUBLIBRARY_QRC})
0261 qt5_add_resources(_srcs "${_relativePath}${_qrc}")
0262 endforeach()
0263
0264 target_sources(${_library_target} PRIVATE ${_srcs})
0265 if (OKTETA_ADD_SUBLIBRARY_PUBLIC)
0266 set(_cc_include_dir ${OKTETA_ADD_SUBLIBRARY_NAMESPACE})
0267 if (OKTETA_ADD_SUBLIBRARY_REVERSE_NAMESPACE_INCLUDEDIR)
0268 list(REVERSE _cc_include_dir)
0269 endif()
0270 string(REPLACE ";" "/" _cc_include_dir "${_cc_include_dir}")
0271
0272 ecm_generate_headers(_cchdrs
0273 HEADER_NAMES
0274 ${OKTETA_ADD_SUBLIBRARY_PUBLIC}
0275 ${_egh_relative_param}
0276 HEADER_EXTENSION hpp
0277 PREFIX ${_cc_include_dir}
0278 REQUIRED_HEADERS _hdrs
0279 )
0280 endif()
0281
0282 if (OKTETA_ADD_SUBLIBRARY_BUILD_INCLUDEDIR)
0283 target_include_directories( ${_library_target}
0284 PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${_relativePath}>
0285 )
0286 endif()
0287
0288 # install
0289 get_property(_include_install_dir TARGET ${_targetName} PROPERTY OKTETA_INSTALL_INCLUDEDIR)
0290 if (_include_install_dir)
0291 get_property(_include_dir TARGET ${_targetName} PROPERTY OKTETA_INSTALL_NORMAL_HEADERS_SUBDIR)
0292 get_property(_cc_include_dir TARGET ${_targetName} PROPERTY OKTETA_INSTALL_CAMELCASE_HEADERS_SUBDIR)
0293 install( FILES ${_hdrs}
0294 DESTINATION "${_include_install_dir}/${_include_dir}"
0295 COMPONENT Devel
0296 )
0297 install( FILES ${_cchdrs}
0298 DESTINATION "${_include_install_dir}/${_cc_include_dir}"
0299 COMPONENT Devel
0300 )
0301 endif()
0302 endmacro()
0303
0304
0305 function(okteta_add_library _baseName)
0306 set(options
0307 NO_TARGET_NAMESPACE
0308 NO_VERSIONED_INCLUDEDIR
0309 NO_VERSIONED_PACKAGE_NAME
0310 NO_VERSIONED_EXPORTED_TARGET_NAME
0311 NO_PACKAGE_NAMESPACED_INCLUDEDIR
0312 REVERSE_NAMESPACE_LIB
0313 REVERSE_NAMESPACE_INCLUDEDIR
0314 LOWERCASE_LIB
0315 NAMELINK_SKIP
0316 )
0317 set(oneValueArgs
0318 INTERNAL_BASENAME
0319 INCLUDEDIR_PACKAGE_NAMESPACE
0320 VERSION
0321 SOVERSION
0322 )
0323 set(multiValueArgs
0324 NAMESPACE
0325 ABIVERSION
0326 PUBLIC
0327 PRIVATE
0328 )
0329 cmake_parse_arguments(OKTETA_ADD_LIBRARY "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0330
0331 if (NOT OKTETA_ADD_LIBRARY_NO_VERSIONED_PACKAGE_NAME)
0332 set(_use_versioned_package_name TRUE)
0333 endif()
0334 if (NOT OKTETA_ADD_LIBRARY_INTERNAL_BASENAME)
0335 set(OKTETA_ADD_LIBRARY_INTERNAL_BASENAME ${_baseName})
0336 endif()
0337
0338 _okteta_setup_namespace(
0339 NAMESPACEPREFIX_VAR _namespacePrefix
0340 VERSIONEDNAMESPACEPREFIX_VAR _versionedNamespacePrefix
0341 VERSIONEDNAMESPACE_VAR _versioned_namespace
0342 BASE_NAME ${_baseName}
0343 NAMESPACE ${OKTETA_ADD_LIBRARY_NAMESPACE}
0344 ABIVERSION ${OKTETA_ADD_LIBRARY_ABIVERSION}
0345 )
0346
0347 set(_fullName "${_namespacePrefix}${_baseName}")
0348 set(_fullInternalName "${_namespacePrefix}${OKTETA_ADD_LIBRARY_INTERNAL_BASENAME}")
0349 set(_fullVersionedName "${_versionedNamespacePrefix}${_baseName}")
0350
0351 set(_targets_export_name "${_fullName}Targets")
0352
0353 set(_libraryName ${_versioned_namespace})
0354 if (OKTETA_ADD_LIBRARY_REVERSE_NAMESPACE_LIB)
0355 list(REVERSE _libraryName)
0356 endif()
0357 string(CONCAT _libraryName ${_libraryName} ${_baseName})
0358 if (OKTETA_ADD_LIBRARY_LOWERCASE_LIB)
0359 string(TOLOWER ${_libraryName} _libraryName)
0360 endif()
0361
0362 set(_targetName ${_fullName})
0363 string(TOLOWER ${_fullInternalName} _lc_fullInternalName)
0364 if (OKTETA_ADD_LIBRARY_NO_VERSIONED_INCLUDEDIR)
0365 set(_cc_include_dir ${OKTETA_ADD_LIBRARY_NAMESPACE})
0366 else()
0367 set(_cc_include_dir ${_versioned_namespace})
0368 endif()
0369 if (OKTETA_ADD_LIBRARY_REVERSE_NAMESPACE_INCLUDEDIR)
0370 list(REVERSE _cc_include_dir)
0371 endif()
0372 string(REPLACE ";" "/" _cc_include_dir "${_cc_include_dir}")
0373 string(TOLOWER ${_cc_include_dir} _include_dir)
0374
0375 add_library(${_targetName} SHARED)
0376
0377 if (OKTETA_ADD_LIBRARY_NO_TARGET_NAMESPACE)
0378 if (OKTETA_ADD_LIBRARY_NO_VERSIONED_EXPORTED_TARGET_NAME)
0379 set(_export_name_args)
0380 else()
0381 add_library("${_fullVersionedName}" ALIAS ${_targetName})
0382 set(_export_name_args EXPORT_NAME ${_fullVersionedName})
0383 endif()
0384 else()
0385 if (OKTETA_ADD_LIBRARY_NO_VERSIONED_EXPORTED_TARGET_NAME)
0386 set(_target_namespacePrefix ${_namespacePrefix})
0387 else()
0388 set(_target_namespacePrefix ${_versionedNamespacePrefix})
0389 endif()
0390 add_library("${_target_namespacePrefix}::${_baseName}" ALIAS ${_targetName})
0391 set(_export_name_args EXPORT_NAME ${_baseName})
0392 endif()
0393
0394 # generate header file with export & version macros
0395 string(TOUPPER "${_fullInternalName}" _definitions_prefix)
0396 _okteta_generate_version_code(
0397 PREFIX ${_definitions_prefix}
0398 VERSION ${OKTETA_ADD_LIBRARY_VERSION}
0399 CODE_VARIABLE _version_code
0400 )
0401 _okteta_generate_export_code(
0402 TARGET_NAME ${_targetName}
0403 PREFIX ${_definitions_prefix}
0404 CODE_VARIABLE _export_code
0405 )
0406
0407 set(_exportHeaderFileName ${_lc_fullInternalName}_export.hpp)
0408 set(_exportHeaderFilePath ${CMAKE_CURRENT_BINARY_DIR}/${_exportHeaderFileName})
0409 string(TOUPPER ${_exportHeaderFileName} _include_guard_name)
0410 string(MAKE_C_IDENTIFIER ${_include_guard_name} _include_guard_name)
0411
0412 _okteta_generate_header_file(
0413 CODE "${_version_code}\n${_export_code}"
0414 INCLUDE_GUARD_NAME ${_include_guard_name}
0415 EXPORT_FILE_NAME ${_exportHeaderFilePath}
0416 )
0417
0418 # Local forwarding header
0419 set(_forwardexportHeaderFilePath ${CMAKE_CURRENT_BINARY_DIR}/${_include_dir}/${_exportHeaderFileName})
0420 if (NOT EXISTS ${_forwardexportHeaderFilePath})
0421 file(WRITE ${_forwardexportHeaderFilePath} "#include \"${_exportHeaderFilePath}\"\n")
0422 endif()
0423
0424 target_link_libraries(${_targetName}
0425 PUBLIC
0426 ${OKTETA_ADD_LIBRARY_PUBLIC}
0427 PRIVATE
0428 ${OKTETA_ADD_LIBRARY_PRIVATE}
0429 )
0430
0431 target_include_directories(${_targetName}
0432 PUBLIC "$<BUILD_INTERFACE:${${_targetName}_BINARY_DIR};${CMAKE_CURRENT_BINARY_DIR}>"
0433 )
0434
0435 set_target_properties(${_targetName} PROPERTIES
0436 ${_export_name_args}
0437 OUTPUT_NAME ${_libraryName}
0438 VERSION ${OKTETA_ADD_LIBRARY_VERSION}
0439 SOVERSION ${OKTETA_ADD_LIBRARY_SOVERSION}
0440 )
0441 set_property(TARGET ${_targetName} PROPERTY OKTETA_FULLNAME ${_fullName})
0442 set_property(TARGET ${_targetName} PROPERTY OKTETA_FULLVERSIONEDNAME ${_fullVersionedName})
0443 set_property(TARGET ${_targetName} PROPERTY OKTETA_NO_TARGETNAMESPACE ${OKTETA_ADD_LIBRARY_NO_TARGET_NAMESPACE})
0444 if (NOT OKTETA_ADD_LIBRARY_NO_TARGET_NAMESPACE)
0445 set_property(TARGET ${_targetName} PROPERTY OKTETA_TARGET_NAMESPACEPREFIX ${_target_namespacePrefix})
0446 endif()
0447 set_property(TARGET ${_targetName} PROPERTY OKTETA_USE_VERSIONED_PACKAGE_NAME ${_use_versioned_package_name})
0448
0449 set(_other_install_targets_args)
0450 if(OKTETA_ADD_LIBRARY_NAMELINK_SKIP)
0451 list(APPEND _other_install_targets_args LIBRARY NAMELINK_SKIP)
0452 endif()
0453 install( TARGETS ${_targetName}
0454 EXPORT ${_targets_export_name}
0455 ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
0456 ${_other_install_targets_args}
0457 )
0458
0459 # TODO: perhaps only do on first PUBLIC usage in okteta_add_sublibrary?
0460 if (OKTETA_ADD_LIBRARY_NO_PACKAGE_NAMESPACED_INCLUDEDIR)
0461 set(_include_install_dir "${KDE_INSTALL_INCLUDEDIR}")
0462 else()
0463 if (OKTETA_ADD_LIBRARY_INCLUDEDIR_PACKAGE_NAMESPACE)
0464 set(_include_dir_package_namespace "${OKTETA_ADD_LIBRARY_INCLUDEDIR_PACKAGE_NAMESPACE}")
0465 else()
0466 if (_use_versioned_package_name)
0467 set(_include_dir_package_namespace "${_fullVersionedName}")
0468 else()
0469 set(_include_dir_package_namespace "${_fullName}")
0470 endif()
0471 endif()
0472 set(_include_install_dir "${KDE_INSTALL_INCLUDEDIR}/${_include_dir_package_namespace}")
0473 endif()
0474 set_property(TARGET ${_targetName} PROPERTY OKTETA_INSTALL_INCLUDEDIR ${_include_install_dir})
0475 set_property(TARGET ${_targetName} PROPERTY OKTETA_INSTALL_NORMAL_HEADERS_SUBDIR ${_include_dir})
0476 set_property(TARGET ${_targetName} PROPERTY OKTETA_INSTALL_CAMELCASE_HEADERS_SUBDIR ${_cc_include_dir})
0477 target_include_directories(${_targetName}
0478 INTERFACE "$<INSTALL_INTERFACE:${_include_install_dir}>"
0479 )
0480 install( FILES ${_exportHeaderFilePath}
0481 DESTINATION "${_include_install_dir}/${_include_dir}"
0482 COMPONENT Devel
0483 )
0484 endfunction()
0485
0486
0487 function(okteta_add_cmakeconfig _baseName)
0488 set(options
0489 )
0490 set(oneValueArgs
0491 COMPATIBILITY
0492 )
0493 set(multiValueArgs
0494 INCLUDES
0495 NAMESPACE
0496 DEPS
0497 VARS
0498 )
0499 cmake_parse_arguments(OKTETA_ADD_CMAKECONFIG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0500
0501 _okteta_target_name(_targetName ${_baseName} ${OKTETA_ADD_CMAKECONFIG_NAMESPACE})
0502
0503 get_property(_fullName TARGET ${_targetName} PROPERTY OKTETA_FULLNAME)
0504
0505 get_property(_use_versioned_package_name TARGET ${_targetName} PROPERTY OKTETA_USE_VERSIONED_PACKAGE_NAME)
0506 if (_use_versioned_package_name)
0507 get_property(_configName TARGET ${_targetName} PROPERTY OKTETA_FULLVERSIONEDNAME)
0508 else()
0509 set(_configName ${_fullName})
0510 endif()
0511
0512 set(_configFileTemplatePath "${CMAKE_CURRENT_BINARY_DIR}/${_configName}Config.cmake.in")
0513 set(_configFileTemplate "@PACKAGE_INIT@\n\ninclude(CMakeFindDependencyMacro)\n\n")
0514 set(dep_package_name)
0515 foreach (dep ${OKTETA_ADD_CMAKECONFIG_DEPS})
0516 if (dep_package_name)
0517 set (dep_package_version ${dep})
0518 else()
0519 set(_dep_fullName)
0520 if (TARGET ${dep})
0521 get_property(_dep_fullName TARGET ${dep} PROPERTY OKTETA_FULLNAME)
0522 endif()
0523 if (_dep_fullName)
0524 get_property(_use_versioned_package_name TARGET ${dep} PROPERTY OKTETA_USE_VERSIONED_PACKAGE_NAME)
0525 if (_use_versioned_package_name)
0526 get_property(dep_package_name TARGET ${dep} PROPERTY OKTETA_FULLVERSIONEDNAME)
0527 else()
0528 set(dep_package_name ${_dep_fullName})
0529 endif()
0530
0531 get_property(dep_package_version TARGET ${dep} PROPERTY VERSION)
0532 else()
0533 set(dep_package_name ${dep})
0534 set(dep_package_version)
0535 endif()
0536 endif()
0537 if (dep_package_version)
0538 string(APPEND _configFileTemplate "find_dependency(${dep_package_name} ${dep_package_version})\n")
0539 set(dep_package_name)
0540 endif()
0541 endforeach()
0542 if (dep_package_name)
0543 message(FATAL_ERROR "DEPS expected to have a version after ${dep_package_name}.")
0544 endif()
0545 string(APPEND _configFileTemplate "\ninclude(\"\${CMAKE_CURRENT_LIST_DIR}/${_configName}Targets.cmake\")\n")
0546 foreach (_include ${OKTETA_ADD_CMAKECONFIG_INCLUDES})
0547 string(APPEND _configFileTemplate "include(\"\${CMAKE_CURRENT_LIST_DIR}/${_include}\")\n")
0548 endforeach()
0549 if (OKTETA_ADD_CMAKECONFIG_VARS)
0550 string(APPEND _configFileTemplate "\n")
0551 foreach (_var ${OKTETA_ADD_CMAKECONFIG_VARS})
0552 string(APPEND _configFileTemplate "@${_var}@\n")
0553 endforeach()
0554 endif()
0555 file(WRITE ${_configFileTemplatePath} "${_configFileTemplate}")
0556
0557 set(_targets_export_name "${_fullName}Targets")
0558
0559 # create a Config.cmake and a ConfigVersion.cmake file and install them
0560 set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/${_configName}")
0561
0562 get_target_property(_version ${_targetName} VERSION)
0563 if (_version)
0564 set(_configVersionFilePath "${CMAKE_CURRENT_BINARY_DIR}/${_configName}ConfigVersion.cmake")
0565 if(NOT OKTETA_ADD_CMAKECONFIG_COMPATIBILITY)
0566 set(OKTETA_ADD_CMAKECONFIG_COMPATIBILITY AnyNewerVersion)
0567 endif()
0568 write_basic_package_version_file("${_configVersionFilePath}"
0569 VERSION ${_version}
0570 COMPATIBILITY ${OKTETA_ADD_CMAKECONFIG_COMPATIBILITY}
0571 )
0572 else()
0573 set(_configVersionFilePath)
0574 endif()
0575
0576 set(_configFilePath "${CMAKE_CURRENT_BINARY_DIR}/${_configName}Config.cmake")
0577 configure_package_config_file(
0578 "${_configFileTemplatePath}"
0579 "${_configFilePath}"
0580 INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR}
0581 )
0582
0583 install( FILES
0584 "${_configFilePath}"
0585 "${_configVersionFilePath}"
0586 DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
0587 COMPONENT Devel
0588 )
0589 get_property(_no_target_namespace TARGET ${_targetName} PROPERTY OKTETA_NO_TARGETNAMESPACE)
0590 if(NOT _no_target_namespace)
0591 get_property(_namespacePrefix TARGET ${_targetName} PROPERTY OKTETA_TARGET_NAMESPACEPREFIX)
0592 set(_namespace_args NAMESPACE "${_namespacePrefix}::")
0593 endif()
0594 install(EXPORT ${_targets_export_name}
0595 FILE "${_configName}Targets.cmake"
0596 ${_namespace_args}
0597 DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
0598 COMPONENT Devel
0599 )
0600 endfunction()
0601
0602
0603 function(okteta_add_qmakeconfig _baseName)
0604 set(options
0605 )
0606 set(oneValueArgs
0607 )
0608 set(multiValueArgs
0609 NAMESPACE
0610 DEPS
0611 )
0612 cmake_parse_arguments(OKTETA_ADD_QMAKECONFIG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0613
0614 _okteta_target_name(_targetName ${_baseName} ${OKTETA_ADD_QMAKECONFIG_NAMESPACE})
0615
0616 get_target_property(_libraryName ${_targetName} OUTPUT_NAME)
0617 get_property(_include_install_dir TARGET ${_targetName} PROPERTY OKTETA_INSTALL_INCLUDEDIR)
0618 get_property(_fullName TARGET ${_targetName} PROPERTY OKTETA_FULLNAME)
0619 get_property(_use_versioned_package_name TARGET ${_targetName} PROPERTY OKTETA_USE_VERSIONED_PACKAGE_NAME)
0620 if (_use_versioned_package_name)
0621 get_property(_configName TARGET ${_targetName} PROPERTY OKTETA_FULLVERSIONEDNAME)
0622 else()
0623 get_property(_configName TARGET ${_targetName} PROPERTY OKTETA_FULLNAME)
0624 endif()
0625
0626 string(REPLACE ";" " " _deps "${OKTETA_ADD_QMAKECONFIG_DEPS}")
0627
0628 get_target_property(_version ${_targetName} VERSION)
0629
0630 ecm_generate_pri_file(
0631 BASE_NAME ${_configName}
0632 LIB_NAME ${_libraryName}
0633 DEPS ${_deps}
0634 VERSION ${_version}
0635 FILENAME_VAR _pri_filename
0636 INCLUDE_INSTALL_DIR ${_include_install_dir}
0637 )
0638 install(FILES ${_pri_filename}
0639 DESTINATION ${ECM_MKSPECS_INSTALL_DIR}
0640 COMPONENT Devel
0641 )
0642 endfunction()
0643
0644 function(okteta_add_pkgconfig _baseName)
0645 set(options
0646 )
0647 set(oneValueArgs
0648 DESCRIPTION
0649 )
0650 set(multiValueArgs
0651 NAMESPACE
0652 DEPS
0653 )
0654 cmake_parse_arguments(OKTETA_ADD_PKGCONFIG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
0655
0656 _okteta_target_name(_targetName ${_baseName} ${OKTETA_ADD_PKGCONFIG_NAMESPACE})
0657
0658 get_target_property(_libraryName ${_targetName} OUTPUT_NAME)
0659 get_property(_include_install_dir TARGET ${_targetName} PROPERTY OKTETA_INSTALL_INCLUDEDIR)
0660 get_property(_use_versioned_package_name TARGET ${_targetName} PROPERTY OKTETA_USE_VERSIONED_PACKAGE_NAME)
0661 if (_use_versioned_package_name)
0662 get_property(_configName TARGET ${_targetName} PROPERTY OKTETA_FULLVERSIONEDNAME)
0663 else()
0664 get_property(_configName TARGET ${_targetName} PROPERTY OKTETA_FULLNAME)
0665 endif()
0666
0667 string(REPLACE ";" " " _deps "${OKTETA_ADD_PKGCONFIG_DEPS}")
0668
0669 get_target_property(PROJECT_VERSION ${_targetName} VERSION)
0670 ecm_generate_pkgconfig_file(
0671 BASE_NAME ${_configName}
0672 LIB_NAME ${_libraryName}
0673 DEPS ${_deps}
0674 INCLUDE_INSTALL_DIR ${_include_install_dir}
0675 DESCRIPTION ${OKTETA_ADD_PKGCONFIG_DESCRIPTION}
0676 INSTALL
0677 )
0678 endfunction()