From a1d6d8f7259ade901a87b33edbef8b31bffb5e26 Mon Sep 17 00:00:00 2001 From: Alex Merry Date: Fri, 6 Feb 2015 11:31:19 +0000 Subject: Document when modules were added to ECM. --- modules/ECMGenerateHeaders.cmake | 2 ++ 1 file changed, 2 insertions(+) (limited to 'modules/ECMGenerateHeaders.cmake') diff --git a/modules/ECMGenerateHeaders.cmake b/modules/ECMGenerateHeaders.cmake index bac50869..5e5615b6 100644 --- a/modules/ECMGenerateHeaders.cmake +++ b/modules/ECMGenerateHeaders.cmake @@ -88,6 +88,8 @@ # install(FILES ${MyLib_HEADERS} # DESTINATION ${CMAKE_INSTALL_PREFIX}/include/mylib # COMPONENT Devel) +# +# Since pre-1.0.0. #============================================================================= # Copyright 2013 Aleix Pol Gonzalez -- cgit v1.2.1 From fc56bfbb62a9438960fec9e5960fde5f3e5c1a46 Mon Sep 17 00:00:00 2001 From: "Friedrich W. H. Kossebau" Date: Sun, 15 Feb 2015 21:45:34 +0100 Subject: Extend ecm_generate_headers macro to also support CamelCase.h headers REVIEW: 122317 Thanks alexmerry and dvratil for review --- modules/ECMGenerateHeaders.cmake | 77 +++++++++++++++++++++++++--------------- 1 file changed, 49 insertions(+), 28 deletions(-) (limited to 'modules/ECMGenerateHeaders.cmake') diff --git a/modules/ECMGenerateHeaders.cmake b/modules/ECMGenerateHeaders.cmake index 5e5615b6..b6290223 100644 --- a/modules/ECMGenerateHeaders.cmake +++ b/modules/ECMGenerateHeaders.cmake @@ -6,26 +6,31 @@ # # :: # -# ecm_generate_headers( -# HEADER_NAMES [ [...]] +# ecm_generate_headers( +# HEADER_NAMES [ [...]] +# [ORIGINAL ] # [OUTPUT_DIR ] # [PREFIX ] # [REQUIRED_HEADERS ] # [RELATIVE ]) # # For each CamelCase header name passed to HEADER_NAMES, a file of that name -# will be generated that will include a lowercased version with ``.h`` appended. -# For example, the header ``ClassA`` will include ``classa.h``. The file -# locations of these generated headers will be stored in -# . -# -# PREFIX places the headers in subdirectories. This should be a CamelCase name -# like KParts, which will cause the CamelCase headers to be placed in the KParts -# directory (eg: KParts/Part). It will also, for the convenience of code in the -# source distribution, generate forwarding lowercase headers, like -# kparts/part.h. This allows includes like "#include " to be -# used before installation, as long as the include_directories are set -# appropriately. +# will be generated that will include a version with ``.h`` appended. +# For example, the generated header ``ClassA`` will include ``classa.h`` (or +# ``ClassA.h``, see ORIGINAL). +# The file locations of these generated headers will be stored in +# . +# +# ORIGINAL specifies how the name of the original header is written: lowercased +# or also camelcased. The default is LOWERCASE. Since 1.8.0. +# +# PREFIX places the generated headers in subdirectories. This should be a +# CamelCase name like ``KParts``, which will cause the CamelCase forwarding +# headers to be placed in the ``KParts`` directory (e.g. ``KParts/Part``). It +# will also, for the convenience of code in the source distribution, generate +# forwarding headers based on the original names (e.g. ``kparts/part.h``). This +# allows includes like ``"#include "`` to be used before +# installation, as long as the include_directories are set appropriately. # # OUTPUT_DIR specifies where the files will be generated; this should be within # the build directory. By default, ``${CMAKE_CURRENT_BINARY_DIR}`` will be used. @@ -35,14 +40,14 @@ # headers will be appended so that they can be installed together with the # generated ones. This is mostly intended as a convenience so that adding a new # header to a project only requires specifying the CamelCase variant in the -# CMakeLists.txt file; the lowercase variant will then be added to this +# CMakeLists.txt file; the original variant will then be added to this # variable. # -# The RELATIVE argument indicates where the lowercase headers can be found +# The RELATIVE argument indicates where the original headers can be found # relative to CMAKE_CURRENT_SOURCE_DIR. It does not affect the generated -# CamelCase files, but ecm_generate_headers() uses it when checking that the -# lowercase header exists, and to generate lowercase forwarding headers when -# PREFIX is set. +# CamelCase forwarding files, but ecm_generate_headers() uses it when checking +# that the original header exists, and to generate originally named forwarding +# headers when PREFIX is set. # # To allow other parts of the source distribution (eg: tests) to use the # generated headers before installation, it may be desirable to set the @@ -107,9 +112,9 @@ include(CMakeParseArguments) -function(ECM_GENERATE_HEADERS camelcase_headers_var) +function(ECM_GENERATE_HEADERS camelcase_forwarding_headers_var) set(options) - set(oneValueArgs OUTPUT_DIR PREFIX REQUIRED_HEADERS RELATIVE) + set(oneValueArgs ORIGINAL OUTPUT_DIR PREFIX REQUIRED_HEADERS RELATIVE) set(multiValueArgs HEADER_NAMES) cmake_parse_arguments(EGH "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) @@ -121,6 +126,14 @@ function(ECM_GENERATE_HEADERS camelcase_headers_var) message(FATAL_ERROR "Missing header_names argument to ECM_GENERATE_HEADERS") endif() + if(NOT EGH_ORIGINAL) + # default + set(EGH_ORIGINAL "LOWERCASE") + endif() + if(NOT EGH_ORIGINAL STREQUAL "LOWERCASE" AND NOT EGH_ORIGINAL STREQUAL "CAMELCASE") + message(FATAL_ERROR "Unexpected value for original argument to ECM_GENERATE_HEADERS: ${EGH_ORIGINAL}") + endif() + if(NOT EGH_OUTPUT_DIR) set(EGH_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}") endif() @@ -134,33 +147,41 @@ function(ECM_GENERATE_HEADERS camelcase_headers_var) if (NOT "${EGH_PREFIX}" MATCHES "^.*/$") set(EGH_PREFIX "${EGH_PREFIX}/") endif() - string(TOLOWER "${EGH_PREFIX}" lowercaseprefix) + if (EGH_ORIGINAL STREQUAL "CAMELCASE") + set(originalprefix "${EGH_PREFIX}") + else() + string(TOLOWER "${EGH_PREFIX}" originalprefix) + endif() endif() foreach(_CLASSNAME ${EGH_HEADER_NAMES}) - string(TOLOWER "${_CLASSNAME}" lowercaseclassname) + if (EGH_ORIGINAL STREQUAL "CAMELCASE") + set(originalclassname "${_CLASSNAME}") + else() + string(TOLOWER "${_CLASSNAME}" originalclassname) + endif() set(FANCY_HEADER_FILE "${EGH_OUTPUT_DIR}/${EGH_PREFIX}${_CLASSNAME}") - set(_actualheader "${CMAKE_CURRENT_SOURCE_DIR}/${EGH_RELATIVE}${lowercaseclassname}.h") + set(_actualheader "${CMAKE_CURRENT_SOURCE_DIR}/${EGH_RELATIVE}${originalclassname}.h") if (NOT EXISTS ${_actualheader}) message(FATAL_ERROR "Could not find \"${_actualheader}\"") endif() if (NOT EXISTS ${FANCY_HEADER_FILE}) - file(WRITE ${FANCY_HEADER_FILE} "#include \"${lowercaseprefix}${lowercaseclassname}.h\"\n") + file(WRITE ${FANCY_HEADER_FILE} "#include \"${originalprefix}${originalclassname}.h\"\n") endif() - list(APPEND ${camelcase_headers_var} "${FANCY_HEADER_FILE}") + list(APPEND ${camelcase_forwarding_headers_var} "${FANCY_HEADER_FILE}") if (EGH_REQUIRED_HEADERS) list(APPEND ${EGH_REQUIRED_HEADERS} "${_actualheader}") endif() if (EGH_PREFIX) # Local forwarding header, for namespaced headers, e.g. kparts/part.h - set(REGULAR_HEADER_NAME ${EGH_OUTPUT_DIR}/${lowercaseprefix}${lowercaseclassname}.h) + set(REGULAR_HEADER_NAME ${EGH_OUTPUT_DIR}/${originalprefix}${originalclassname}.h) if (NOT EXISTS ${REGULAR_HEADER_NAME}) file(WRITE ${REGULAR_HEADER_NAME} "#include \"${_actualheader}\"\n") endif() endif() endforeach() - set(${camelcase_headers_var} ${${camelcase_headers_var}} PARENT_SCOPE) + set(${camelcase_forwarding_headers_var} ${${camelcase_forwarding_headers_var}} PARENT_SCOPE) if (NOT EGH_REQUIRED_HEADERS STREQUAL "") set(${EGH_REQUIRED_HEADERS} ${${EGH_REQUIRED_HEADERS}} PARENT_SCOPE) endif () -- cgit v1.2.1 From 8ef3f474e3a6def47dce36b54fbdce2d98c79342 Mon Sep 17 00:00:00 2001 From: Patrick Spendrin Date: Thu, 20 Aug 2015 21:46:20 +0200 Subject: add COMMON_HEADER option and multiple header functionality This adds a new keyword COMMON_HEADER which generates a new header containing all other headers. Also it is possible now to have multiple dummy headers per header file. It is assumed that the first header is the existing one. REVIEW: 124847 --- modules/ECMGenerateHeaders.cmake | 75 +++++++++++++++++++++++++++++----------- 1 file changed, 54 insertions(+), 21 deletions(-) (limited to 'modules/ECMGenerateHeaders.cmake') diff --git a/modules/ECMGenerateHeaders.cmake b/modules/ECMGenerateHeaders.cmake index b6290223..cefc82df 100644 --- a/modules/ECMGenerateHeaders.cmake +++ b/modules/ECMGenerateHeaders.cmake @@ -12,12 +12,16 @@ # [OUTPUT_DIR ] # [PREFIX ] # [REQUIRED_HEADERS ] +# [COMMON_HEADER ] # [RELATIVE ]) # # For each CamelCase header name passed to HEADER_NAMES, a file of that name # will be generated that will include a version with ``.h`` appended. # For example, the generated header ``ClassA`` will include ``classa.h`` (or # ``ClassA.h``, see ORIGINAL). +# If a CamelCaseName consists of multiple comma-separated files, e.g. +# ``ClassA,ClassB,ClassC``, then multiple camelcase header files will be +# generated which are redirects to the first header file. # The file locations of these generated headers will be stored in # . # @@ -43,6 +47,9 @@ # CMakeLists.txt file; the original variant will then be added to this # variable. # +# COMMON_HEADER generates an additional convenience header which includes all +# other header files. +# # The RELATIVE argument indicates where the original headers can be found # relative to CMAKE_CURRENT_SOURCE_DIR. It does not affect the generated # CamelCase forwarding files, but ecm_generate_headers() uses it when checking @@ -69,6 +76,7 @@ # MLBar # # etc # REQUIRED_HEADERS MyLib_HEADERS +# COMMON_HEADER MLGeneral # ) # install(FILES ${MyLib_FORWARDING_HEADERS} ${MyLib_HEADERS} # DESTINATION ${CMAKE_INSTALL_PREFIX}/include @@ -82,7 +90,9 @@ # MyLib_FORWARDING_HEADERS # HEADERS # Foo -# Bar +# # several classes are contained in bar.h, so generate +# # additional files +# Bar,BarList # # etc # PREFIX MyLib # REQUIRED_HEADERS MyLib_HEADERS @@ -99,6 +109,7 @@ #============================================================================= # Copyright 2013 Aleix Pol Gonzalez # Copyright 2014 Alex Merry +# Copyright 2015 Patrick Spendrin # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file COPYING-CMAKE-SCRIPTS for details. @@ -114,7 +125,7 @@ include(CMakeParseArguments) function(ECM_GENERATE_HEADERS camelcase_forwarding_headers_var) set(options) - set(oneValueArgs ORIGINAL OUTPUT_DIR PREFIX REQUIRED_HEADERS RELATIVE) + set(oneValueArgs ORIGINAL OUTPUT_DIR PREFIX REQUIRED_HEADERS COMMON_HEADER RELATIVE) set(multiValueArgs HEADER_NAMES) cmake_parse_arguments(EGH "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) @@ -154,35 +165,57 @@ function(ECM_GENERATE_HEADERS camelcase_forwarding_headers_var) endif() endif() - foreach(_CLASSNAME ${EGH_HEADER_NAMES}) + foreach(_classnameentry ${EGH_HEADER_NAMES}) + string(REPLACE "," ";" _classnames ${_classnameentry}) + list(GET _classnames 0 _baseclass) + if (EGH_ORIGINAL STREQUAL "CAMELCASE") - set(originalclassname "${_CLASSNAME}") + set(originalbasename "${_baseclass}") else() - string(TOLOWER "${_CLASSNAME}" originalclassname) + string(TOLOWER "${_baseclass}" originalbasename) endif() - set(FANCY_HEADER_FILE "${EGH_OUTPUT_DIR}/${EGH_PREFIX}${_CLASSNAME}") - set(_actualheader "${CMAKE_CURRENT_SOURCE_DIR}/${EGH_RELATIVE}${originalclassname}.h") + + set(_actualheader "${CMAKE_CURRENT_SOURCE_DIR}/${EGH_RELATIVE}${originalbasename}.h") if (NOT EXISTS ${_actualheader}) message(FATAL_ERROR "Could not find \"${_actualheader}\"") endif() - if (NOT EXISTS ${FANCY_HEADER_FILE}) - file(WRITE ${FANCY_HEADER_FILE} "#include \"${originalprefix}${originalclassname}.h\"\n") - endif() - list(APPEND ${camelcase_forwarding_headers_var} "${FANCY_HEADER_FILE}") - if (EGH_REQUIRED_HEADERS) - list(APPEND ${EGH_REQUIRED_HEADERS} "${_actualheader}") - endif() - if (EGH_PREFIX) - # Local forwarding header, for namespaced headers, e.g. kparts/part.h - set(REGULAR_HEADER_NAME ${EGH_OUTPUT_DIR}/${originalprefix}${originalclassname}.h) - if (NOT EXISTS ${REGULAR_HEADER_NAME}) - file(WRITE ${REGULAR_HEADER_NAME} "#include \"${_actualheader}\"\n") + + foreach(_CLASSNAME ${_classnames}) + set(FANCY_HEADER_FILE "${EGH_OUTPUT_DIR}/${EGH_PREFIX}${_CLASSNAME}") + if (NOT EXISTS ${FANCY_HEADER_FILE}) + file(WRITE ${FANCY_HEADER_FILE} "#include \"${originalprefix}${originalbasename}.h\"\n") endif() - endif() + list(APPEND ${camelcase_forwarding_headers_var} "${FANCY_HEADER_FILE}") + if (EGH_PREFIX) + # Local forwarding header, for namespaced headers, e.g. kparts/part.h + if(EGH_ORIGINAL STREQUAL "CAMELCASE") + set(originalclassname "${_CLASSNAME}") + else() + string(TOLOWER "${_CLASSNAME}" originalclassname) + endif() + set(REGULAR_HEADER_NAME ${EGH_OUTPUT_DIR}/${originalprefix}${originalclassname}.h) + if (NOT EXISTS ${REGULAR_HEADER_NAME}) + file(WRITE ${REGULAR_HEADER_NAME} "#include \"${_actualheader}\"\n") + endif() + endif() + endforeach() + + list(APPEND _REQUIRED_HEADERS "${_actualheader}") endforeach() + if(EGH_COMMON_HEADER) + #combine required headers into 1 big convenience header + set(COMMON_HEADER ${EGH_OUTPUT_DIR}/${EGH_PREFIX}${EGH_COMMON_HEADER}) + file(WRITE ${COMMON_HEADER} "// convenience header\n") + foreach(_header ${_REQUIRED_HEADERS}) + get_filename_component(_base ${_header} NAME) + file(APPEND ${COMMON_HEADER} "#include \"${_base}\"\n") + endforeach() + list(APPEND ${camelcase_forwarding_headers_var} "${COMMON_HEADER}") + endif() + set(${camelcase_forwarding_headers_var} ${${camelcase_forwarding_headers_var}} PARENT_SCOPE) if (NOT EGH_REQUIRED_HEADERS STREQUAL "") - set(${EGH_REQUIRED_HEADERS} ${${EGH_REQUIRED_HEADERS}} PARENT_SCOPE) + set(${EGH_REQUIRED_HEADERS} ${${EGH_REQUIRED_HEADERS}} ${_REQUIRED_HEADERS} PARENT_SCOPE) endif () endfunction() -- cgit v1.2.1