diff options
| -rw-r--r-- | CMakeLists.txt | 194 | ||||
| -rw-r--r-- | cmake/Anope.cmake | 230 | ||||
| -rw-r--r-- | cmake/FindGettext.cmake | 12 | ||||
| -rw-r--r-- | docs/CMakeLists.txt | 4 | ||||
| -rw-r--r-- | include/CMakeLists.txt | 18 | ||||
| -rw-r--r-- | language/CMakeLists.txt | 6 | ||||
| -rw-r--r-- | modules/CMakeLists.txt | 66 | ||||
| -rw-r--r-- | modules/third/language/CMakeLists.txt | 6 | ||||
| -rw-r--r-- | src/CMakeLists.txt | 40 | ||||
| -rw-r--r-- | src/tools/CMakeLists.txt | 12 |
10 files changed, 294 insertions, 294 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 3f56ae9bc..2ec1bdfaf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,11 +4,11 @@ if(COMMAND cmake_policy) cmake_policy(SET CMP0003 NEW) if(POLICY CMP0026) cmake_policy(SET CMP0026 OLD) - endif(POLICY CMP0026) + endif() if(POLICY CMP0007) cmake_policy(SET CMP0007 OLD) - endif(POLICY CMP0007) -endif(COMMAND cmake_policy) + endif() +endif() # Set the project as C++ primarily, but have C enabled for the checks required later project(Anope CXX) @@ -21,21 +21,21 @@ string(REGEX MATCH "-patch .*$" HAS_PATCH "${ONLY_VERSION}") if(HAS_PATCH) string(REGEX REPLACE "(.*)-patch .*" "\\1" MINOR_VERSION "${ONLY_VERSION}") string(REGEX REPLACE ".*-patch (.*)" "\\1" PATCH_VERSION "${ONLY_VERSION}") -else(HAS_PATCH) +else() string(REGEX MATCH "\\." HAS_DOT "${ONLY_VERSION}") if(HAS_DOT) string(REGEX REPLACE "(.*)\\..*" "\\1" MINOR_VERSION "${ONLY_VERSION}") string(REGEX REPLACE ".*\\.(.*)" "\\1" PATCH_VERSION "${ONLY_VERSION}") - else(HAS_DOT) + else() string(REGEX REPLACE "(.*)-beta" "\\1" MINOR_VERSION "${ONLY_VERSION}") if(MINOR_VERSION STREQUAL "4-1\n") set(PATCH_VERSION 1) - else(MINOR_VERSION STREQUAL "4-1\n") + else() set(PATCH_VERSION 0) - endif(MINOR_VERSION STREQUAL "4-1\n") + endif() set(MINOR_VERSION 4) - endif(HAS_DOT) -endif(HAS_PATCH) + endif() +endif() # Detect is we are using CMake 2.6 or better, these versions include functions that require less work than CMake 2.4 does if(MINOR_VERSION GREATER 5) @@ -43,30 +43,30 @@ if(MINOR_VERSION GREATER 5) set(CMAKE248_OR_BETTER TRUE) set(CMAKE244_OR_BETTER TRUE) set(CMAKE242_OR_BETTER TRUE) -else(MINOR_VERSION GREATER 5) +else() set(CMAKE26_OR_BETTER FALSE) # Also detect if we are using CMake 2.4.8 or better, the FIND sub-command of list() is nonexistent in earlier versions if(PATCH_VERSION GREATER 7) set(CMAKE248_OR_BETTER TRUE) set(CMAKE244_OR_BETTER TRUE) set(CMAKE242_OR_BETTER TRUE) - else(PATCH_VERSION GREATER 7) + else() set(CMAKE248_OR_BETTER FALSE) # Also detect if we are using CMake 2.4.4 or better, the CheckCXXCompilerFlag module and SORT sub-command of list() are nonexistent in earlier versions if(PATCH_VERSION GREATER 3) set(CMAKE244_OR_BETTER TRUE) set(CMAKE242_OR_BETTER TRUE) - else(PATCH_VERSION GREATER 3) + else() set(CMAKE244_OR_BETTER FALSE) # ALSO detect if we are using CMake 2.4.2 or better, the APPEND sub-command of list() is nonexistent in earlier versions if(PATCH_VERSION GREATER 1) set(CMAKE242_OR_BETTER TRUE) - else(PATCH_VERSION GREATER 1) + else() set(CMAKE242_OR_BETTER FALSE) - endif(PATCH_VERSION GREATER 1) - endif(PATCH_VERSION GREATER 3) - endif(PATCH_VERSION GREATER 7) -endif(MINOR_VERSION GREATER 5) + endif() + endif() + endif() +endif() # Override the module include path to include our directory, for our Anope.cmake, as well as we are using our own version of the NSIS template set(CMAKE_MODULE_PATH ${Anope_SOURCE_DIR}/cmake) @@ -86,11 +86,11 @@ if(CMAKE_COMPILER_IS_GNUCXX) string(REGEX REPLACE "^(\\d+\\.\\d+)" "\\1" GCC_VERSION ${GCC_FULL_VERSION}) if(GCC_VERSION LESS 4.2) message(FATAL_ERROR "Your compiler is too old to build Anope. Upgrade to GCC 4.2 or newer!") - endif(GCC_VERSION LESS 4.2) + endif() if(GCC_VERSION GREATER 6.0 OR GCC_VERSION EQUAL 6.0) set(CXXFLAGS "${CXXFLAGS} -fno-delete-null-pointer-checks") - endif(GCC_VERSION GREATER 6.0 OR GCC_VERSION EQUAL 6.0) -endif(CMAKE_COMPILER_IS_GNUCXX) + endif() +endif() # If we are using a GNU compiler (have to use CXX because it seems to fail on C), we will be able to determine it's default paths for libraries and includes if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$") @@ -101,9 +101,9 @@ if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$") # Replace the colons in the list with semicolons (only when not on MinGW, which uses semicolons already), and if on MinGW, just copy the line if(NOT MINGW) string(REGEX REPLACE ":" ";" LIBRARIES ${LINE}) - else(NOT MINGW) + else() set(LIBRARIES "${LINE}") - endif(NOT MINGW) + endif() # Iterate through the libraries foreach(LIBRARY ${LIBRARIES}) # Check if the first character is an equal sign, and skip that library directory as it is (I believe) the primary default and shows up later in the list anyways @@ -112,12 +112,12 @@ if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$") # If the directory had no = in front of it, make sure it's absolute and add it to the list of default library directories get_filename_component(LIBRARY ${LIBRARY} ABSOLUTE) append_to_list(DEFAULT_LIBRARY_DIRS ${LIBRARY}) - endif(NOT FIRST_CHAR STREQUAL "=") - endforeach(LIBRARY) + endif() + endforeach() # Remove duplicate entries from the list if(DEFAULT_LIBRARY_DIRS) remove_list_duplicates(DEFAULT_LIBRARY_DIRS) - endif(DEFAULT_LIBRARY_DIRS) + endif() # Create a temporary file to test for the default include directories FILE(WRITE empty.cpp "") # Next, we look for the compiler's default include directories @@ -134,11 +134,11 @@ if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$") # If the line has the following on it, the next lines will contain directory names if(LINE STREQUAL "#include <...> search starts here:") set(IN_SEARCH TRUE) - else(LINE STREQUAL "#include <...> search starts here:") + else() # If the line has the following on it, we hit the end of the list if(LINE STREQUAL "End of search list.") set(IN_SEARCH FALSE) - else(LINE STREQUAL "End of search list.") + else() # If we are within the block between the above two lines... if(IN_SEARCH) # Get everything but the first character of the line @@ -151,15 +151,15 @@ if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$") get_filename_component(INCLUDE ${INCLUDE} ABSOLUTE) # Add that directory to the list of default include directories append_to_list(DEFAULT_INCLUDE_DIRS ${INCLUDE}) - endif(IN_SEARCH) - endif(LINE STREQUAL "End of search list.") - endif(LINE STREQUAL "#include <...> search starts here:") - endforeach(LINE) + endif() + endif() + endif() + endforeach() # Remove duplicate entries from the list if(DEFAULT_INCLUDE_DIRS) remove_list_duplicates(DEFAULT_INCLUDE_DIRS) - endif(DEFAULT_INCLUDE_DIRS) -endif(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$") + endif() +endif() # If we are using Visual Studio, locate the path of the Windows Server 2008 SDK or Windows Server 2003 Platform SDK, depending on which is installed if(MSVC) @@ -178,19 +178,19 @@ if(MSVC) if(WSDK2003_PATH STREQUAL "/registry") # The SDK was never found, set the path to nothing set(WSDK_PATH "") - else(WSDK2003_PATH STREQUAL "/registry") + else() set(WSDK_PATH "${WSDK2003_PATH}") - endif(WSDK2003_PATH STREQUAL "/registry") - else(WSDK2008_PATH STREQUAL "/registry") + endif() + else() set(WSDK_PATH "${WSDK2008_PATH}") - endif(WSDK2008_PATH STREQUAL "/registry") - else(WSDK2003_PATH STREQUAL "/registry") + endif() + else() set(WSDK_PATH "${WSDK2003_PATH}") - endif(WSDK2003_PATH STREQUAL "/registry") - else(WSDK2008_PATH STREQUAL "/registry") + endif() + else() set(WSDK_PATH "${WSDK2008_PATH}") - endif(WSDK2008_PATH STREQUAL "/registry") -endif(MSVC) + endif() +endif() # If the user specifies -DCMAKE_BUILD_TYPE on the command line, take their definition # and dump it in the cache along with proper documentation, otherwise set CMAKE_BUILD_TYPE @@ -199,17 +199,17 @@ endif(MSVC) if(NOT MSVC) if(CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.") - else(CMAKE_BUILD_TYPE) + else() set(CMAKE_BUILD_TYPE DEBUG CACHE STRING "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.") - endif(CMAKE_BUILD_TYPE) -endif(NOT MSVC) + endif() +endif() # If running under MinGW, we have to force the resource compiler settings (hopefully this will be fixed in a later version of CMake) if(MINGW) set(CMAKE_RC_COMPILER_INIT windres) enable_language(RC) set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> <FLAGS> <DEFINES> -o <OBJECT> <SOURCE>") -endif(MINGW) +endif() # Include the checking functions used later in this CMakeLists.txt include(CheckFunctionExists) @@ -218,19 +218,19 @@ include(CheckTypeSize) include(CheckLibraryExists) if(CMAKE244_OR_BETTER) include(CheckCXXCompilerFlag) -else(CMAKE244_OR_BETTER) +else() include(TestCXXAcceptsFlag) -endif(CMAKE244_OR_BETTER) +endif() # If extra include directories were specified, tell cmake about them. if(EXTRA_INCLUDE) include_directories(${EXTRA_INCLUDE}) -endif(EXTRA_INCLUDE) +endif() # If extra library directories were specified, tell cmake about them. if(EXTRA_LIBS) link_directories(${EXTRA_LIBS}) -endif(EXTRA_LIBS) +endif() # Find gettext find_package(Gettext) @@ -245,14 +245,14 @@ include_directories(${Anope_BINARY_DIR}/include ${Anope_SOURCE_DIR}/include ${An # Pass on REPRODUCIBLE_BUILD if(REPRODUCIBLE_BUILD) add_definitions(-DREPRODUCIBLE_BUILD) -endif(REPRODUCIBLE_BUILD) +endif() # If using Windows, always add the _WIN32 define if(WIN32) add_definitions(-D_WIN32) # And include the windows specific folder for our anope_windows.h include_directories(${Anope_SOURCE_DIR}/src/win32) -endif(WIN32) +endif() # If using Visual Studio, set the C++ flags accordingly if(MSVC) @@ -264,7 +264,7 @@ if(MSVC) set(CXXFLAGS "${CXXFLAGS} /W4 /wd4100 /wd4127 /wd4250 /wd4251 /wd4355 /wd4706 /wd4800 /wd4996 /EHs") add_definitions(-DMSVCPP -D_CRT_SECURE_NO_WARNINGS) # Otherwise, we're not using Visual Studio -else(MSVC) +else() # Set the compile flags to have all warnings on (including shadowed variables) set(CXXFLAGS "${CXXFLAGS} -Wall -Wshadow") # If on a *nix system, also set the compile flags to remove GNU extensions (favor ISO C++) as well as reject non-ISO C++ code, also remove all leading underscores in exported symbols (only on GNU compiler) @@ -272,29 +272,29 @@ else(MSVC) set(CXXFLAGS "${CXXFLAGS} -ansi -pedantic ${CMAKE_CXX_FLAGS}") if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") set(CXXFLAGS "${CXXFLAGS} -Wno-long-long -fno-leading-underscore") - endif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + endif() # If we aren't on a *nix system, we are using MinGW - else(UNIX) + else() # Also, if we are building under MinGW, add another define for MinGW if(MINGW) add_definitions(-DMINGW) - endif(MINGW) - endif(UNIX) -endif(MSVC) + endif() + endif() +endif() # If CMake has found that the given system requires a special library for dl* calls, include it with the linker flags if(CMAKE_DL_LIBS) append_to_list(LINK_LIBS ${CMAKE_DL_LIBS}) -endif(CMAKE_DL_LIBS) +endif() # Under MinGW, the -shared flag isn't properly set in the module-specific linker flags, add it from the C flags for shared libraries if(MINGW) set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS}") -endif(MINGW) +endif() if(NOT PROGRAM_NAME) set(PROGRAM_NAME anope) -endif(NOT PROGRAM_NAME) +endif() # If we are not using Visual Studio, we'll run the following checks if(NOT MSVC) @@ -302,14 +302,14 @@ if(NOT MSVC) if(CMAKE244_OR_BETTER) # If using CMake 2.4.4 or better, we can use check_cxx_compiler_flag check_cxx_compiler_flag(-pipe HAVE_PIPE_FLAG) - else(CMAKE244_OR_BETTER) + else() # If using CMake 2.4.3 or older, we will use check_cxx_accepts_flags instead check_cxx_accepts_flag(-pipe HAVE_PIPE_FLAG) - endif(CMAKE244_OR_BETTER) + endif() # If the flag was accepted, add it to the list of flags if(HAVE_PIPE_FLAG) set(CXXFLAGS "${CXXFLAGS} -pipe") - endif(HAVE_PIPE_FLAG) + endif() # The following are additional library checks, they are not required for Windows if(NOT WIN32) @@ -317,37 +317,37 @@ if(NOT MSVC) check_library_exists(socket socket "" HAVE_SOCKET_LIB) if(HAVE_SOCKET_LIB) append_to_list(LINK_LIBS socket) - endif(HAVE_SOCKET_LIB) + endif() # Check if inet_addr is within the nsl library (if the library exists), and add it to the linker flags if needed check_library_exists(nsl inet_addr "" HAVE_NSL_LIB) if(HAVE_NSL_LIB) append_to_list(LINK_LIBS nsl) - endif(HAVE_NSL_LIB) + endif() # Check if pthread_create is within the pthread library (if the library exists), and add it to the linker flags if needed check_library_exists(pthread pthread_create "" HAVE_PTHREAD) if(HAVE_PTHREAD) if(NOT APPLE) set(LDFLAGS "${LDFLAGS} -pthread") - endif(NOT APPLE) - else(HAVE_PTHREAD) + endif() + else() message(FATAL_ERROR "The pthread library is required to build Anope") - endif(HAVE_PTHREAD) - endif(NOT WIN32) -endif(NOT MSVC) + endif() + endif() +endif() # If DEFUMASK wasn't passed to CMake, set a default depending on if RUNGROUP was passed in or not if(NOT DEFUMASK) if(RUNGROUP) set(DEFUMASK "007") - else(RUNGROUP) + else() set(DEFUMASK "077") - endif(RUNGROUP) -endif(NOT DEFUMASK) + endif() +endif() # Set the DEBUG_BUILD for sysconf.h if(CMAKE_BUILD_TYPE STREQUAL "DEBUG" OR CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO") set(DEBUG_BUILD TRUE) -endif(CMAKE_BUILD_TYPE STREQUAL "DEBUG" OR CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO") +endif() # Check for the existence of the following include files check_include_file(cstdint HAVE_CSTDINT) @@ -364,11 +364,11 @@ check_function_exists(kqueue HAVE_KQUEUE) # Strip the leading and trailing spaces from the compile flags if(CXXFLAGS) strip_string(${CXXFLAGS} CXXFLAGS) -endif(CXXFLAGS) +endif() # Strip the leading and trailing spaces from the linker flags if(LDFLAGS) strip_string(${LDFLAGS} LDFLAGS) -endif(LDFLAGS) +endif() # Search for the following programs find_program(GREP grep) @@ -381,30 +381,30 @@ if(INSTDIR) set(CMAKE_INSTALL_PREFIX "${INSTDIR}") elseif(NOT CMAKE_INSTALL_PREFIX) set(CMAKE_INSTALL_PREFIX "$ENV{HOME}/anope") -endif(INSTDIR) +endif() # Set default paths for various directories if not already defined if(NOT BIN_DIR) set(BIN_DIR "bin") -endif(NOT BIN_DIR) +endif() if(NOT DB_DIR) set(DB_DIR "data") -endif(NOT DB_DIR) +endif() if(NOT DOC_DIR) set(DOC_DIR "doc") -endif(NOT DOC_DIR) +endif() if(NOT CONF_DIR) set(CONF_DIR "conf") -endif(NOT CONF_DIR) +endif() if(NOT LIB_DIR) set(LIB_DIR "lib") -endif(NOT LIB_DIR) +endif() if(NOT LOCALE_DIR) set(LOCALE_DIR "locale") -endif(NOT LOCALE_DIR) +endif() if(NOT LOGS_DIR) set(LOGS_DIR "logs") -endif(NOT LOGS_DIR) +endif() # Version number processing # Find all lines in src/version.sh that start with VERSION_ @@ -418,8 +418,8 @@ foreach(VERSION_STR ${VERSIONS}) if(${VERSION_LEN} GREATER 1) list(GET VERSION_OUT 1 VERSION_DATA) set(VERSION_${VERSION_TYPE} ${VERSION_DATA}) - endif(${VERSION_LEN} GREATER 1) -endforeach(VERSION_STR ${VERSIONS}) + endif() +endforeach() # Default build version to 0 set(VERSION_BUILD 0) @@ -437,8 +437,8 @@ if(EXISTS "${Anope_SOURCE_DIR}/include/version.h") string(SUBSTRING ${VERSION_STR} 22 ${VERSION_NUM_LEN} VERSION) # Set VERSION_BUILD correctly set(VERSION_BUILD ${VERSION}) - endforeach(VERSION_STR ${VERSIONS}) -endif(EXISTS "${Anope_SOURCE_DIR}/include/version.h") + endforeach() +endif() # Set the version variables based on what was found above set(VERSION_COMMA "${VERSION_MAJOR},${VERSION_MINOR},${VERSION_PATCH},${VERSION_BUILD}") @@ -451,7 +451,7 @@ set(VERSION_FULL_NOBUILD "${VERSION_DOTTED_NOBUILD}${VERSION_EXTRA}") if(WIN32) # Generate the win32.rc file using the above variables configure_file(${Anope_SOURCE_DIR}/src/win32/win32.rc.cmake ${Anope_BINARY_DIR}/src/win32/win32.rc) -endif(WIN32) +endif() # Add the initial files to ignore which will be ignored regardless of if you are building in-source or out-of-source add_to_cpack_ignored_files(".git\;config.cache\;CMakeFiles\;sysconf.h$\;build" TRUE) @@ -466,8 +466,8 @@ if(${Anope_SOURCE_DIR} STREQUAL ${Anope_BINARY_DIR}) # If using Visual Studio, add these files as well if(MSVC) add_to_cpack_ignored_files(".vcproj$\;.sln$\;.ncb$\;.suo$\;.dir$\;.ilk$\;.exp$\;.pdb$\;.lib$\;/debug$;/release$;/relwithdebinfo$;/minsizerel$" TRUE) - endif(MSVC) -endif(${Anope_SOURCE_DIR} STREQUAL ${Anope_BINARY_DIR}) + endif() +endif() # Go into the following directories and run their CMakeLists.txt as well add_subdirectory(data) @@ -486,13 +486,13 @@ install(CODE "file(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${DB_ install(CODE "file(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${LOGS_DIR}\")") if(WIN32) install(CODE "file(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${DB_DIR}/runtime\")") -endif(WIN32) +endif() # On non-Windows platforms, if RUNGROUP is set, change the permissions of the below directories, as well as the group of the data directory if(NOT WIN32 AND RUNGROUP) install(CODE "execute_process(COMMAND ${CHMOD} 2775 \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${DB_DIR}/backups\")") install(CODE "execute_process(COMMAND ${CHMOD} 2775 \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${LOGS_DIR}\")") install(CODE "execute_process(COMMAND ${CHGRP} -R ${RUNGROUP} \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}\")") -endif(NOT WIN32 AND RUNGROUP) +endif() # On Windows platforms, install extra files if(WIN32) install(FILES ${Anope_SOURCE_DIR}/src/win32/anope.bat @@ -502,7 +502,7 @@ if(WIN32) # Package any DLLs in src/win/ file(GLOB EXTRA_DLLS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${Anope_SOURCE_DIR}/src/win32/*.dll") install(FILES ${EXTRA_DLLS} DESTINATION ${BIN_DIR}) -endif(WIN32) +endif() install(CODE "file(REMOVE_RECURSE \"$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${LIB_DIR}/modules\")") @@ -543,10 +543,10 @@ if(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake") set(CPACK_NSIS_INSTALLED_ICON_NAME "${SERVICES_BINARY}") set(CPACK_NSIS_URL_INFO_ABOUT "https://www.anope.org/") set(CPACK_NSIS_COMPRESSOR "/SOLID lzma") - endif(WIN32) + endif() set(CPACK_SOURCE_PACKAGE_FILE_NAME "anope-${VERSION_FULL_NOBUILD}-source") set(CPACK_SOURCE_GENERATOR "TGZ") set(CPACK_SOURCE_IGNORE_FILES "$ENV{CPACK_IGNORED_FILES}") set(CPACK_MONOLITHIC_INSTALL TRUE) include(CPack) -endif(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake") +endif() diff --git a/cmake/Anope.cmake b/cmake/Anope.cmake index f93384cc0..459556019 100644 --- a/cmake/Anope.cmake +++ b/cmake/Anope.cmake @@ -9,37 +9,37 @@ macro(strip_string INPUT_STRING OUTPUT_STRING) if(CMAKE26_OR_BETTER) # For CMake 2.6.x or better, we can just use the STRIP sub-command of string() string(STRIP ${INPUT_STRING} ${OUTPUT_STRING}) - else(CMAKE26_OR_BETTER) + else() # For CMake 2.4.x, we will have to use the REGEX REPLACE sub-command of string() instead # First check if the input string is empty or not if (${INPUT_STRING} STREQUAL "") set(${OUTPUT_STRING} "") - else(${INPUT_STRING} STREQUAL "") + else() # Determine if the string is entirely empty or not string(REGEX MATCH "^[ \t]*$" EMPTY_STRING "${INPUT_STRING}") if(EMPTY_STRING) set(${OUTPUT_STRING} "") - else(EMPTY_STRING) + else() # We detect if there is any leading whitespace and remove any if there is string(SUBSTRING "${INPUT_STRING}" 0 1 FIRST_CHAR) if(FIRST_CHAR STREQUAL " " OR FIRST_CHAR STREQUAL "\t") string(REGEX REPLACE "^[ \t]+" "" TEMP_STRING "${INPUT_STRING}") - else(FIRST_CHAR STREQUAL " " OR FIRST_CHAR STREQUAL "\t") + else() set(TEMP_STRING "${INPUT_STRING}") - endif(FIRST_CHAR STREQUAL " " OR FIRST_CHAR STREQUAL "\t") + endif() # Next we detect if there is any trailing whitespace and remove any if there is string(LENGTH "${TEMP_STRING}" STRING_LEN) math(EXPR STRING_LEN "${STRING_LEN} - 1") string(SUBSTRING "${TEMP_STRING}" ${STRING_LEN} 1 LAST_CHAR) if(LAST_CHAR STREQUAL " " OR LAST_CHAR STREQUAL "\t") string(REGEX REPLACE "[ \t]+$" "" ${OUTPUT_STRING} "${TEMP_STRING}") - else(LAST_CHAR STREQUAL " " OR LAST_CHAR STREQUAL "\t") + else() set(${OUTPUT_STRING} "${TEMP_STRING}") - endif(LAST_CHAR STREQUAL " " OR LAST_CHAR STREQUAL "\t") - endif(EMPTY_STRING) - endif(${INPUT_STRING} STREQUAL "") - endif(CMAKE26_OR_BETTER) -endmacro(strip_string) + endif() + endif() + endif() + endif() +endmacro() ############################################################################### # append_to_list(<list> <args>...) @@ -51,11 +51,11 @@ macro(append_to_list LIST) if(CMAKE242_OR_BETTER) # For CMake 2.4.2 or better, we can just use the APPEND sub-command of list() list(APPEND ${LIST} ${ARGN}) - else(CMAKE242_OR_BETTER) + else() # For CMake 2.4.x before 2.4.2, we have to do this manually use set() instead set(${LIST} ${${LIST}} ${ARGN}) - endif(CMAKE242_OR_BETTER) -endmacro(append_to_list) + endif() +endmacro() ############################################################################### # find_in_list(<list> <value> <output variable>) @@ -69,7 +69,7 @@ macro(find_in_list LIST ITEM_TO_FIND FOUND) if(CMAKE248_OR_BETTER) # For CMake 2.4.8 or better, we can use the FIND sub-command of list() list(FIND ${LIST} ${ITEM_TO_FIND} ITEM_FOUND) - else(CMAKE248_OR_BETTER) + else() # For CMake 2.4.x before 2.4.8, we have to do this ourselves (NOTE: This is very slow due to a lack of break() as well) # Firstly we set the position to -1 indicating nothing found, we also use a temporary position set(ITEM_FOUND -1) @@ -79,14 +79,14 @@ macro(find_in_list LIST ITEM_TO_FIND FOUND) # If the item we are looking at is the item we are trying to find, set that we've found the item if(${ITEM} STREQUAL ${ITEM_TO_FIND}) set(ITEM_FOUND ${POS}) - endif(${ITEM} STREQUAL ${ITEM_TO_FIND}) + endif() # Increase the position value by 1 math(EXPR POS "${POS} + 1") - endforeach(ITEM) - endif(CMAKE248_OR_BETTER) + endforeach() + endif() # Set the given FOUND variable to the result set(${FOUND} ${ITEM_FOUND}) -endmacro(find_in_list) +endmacro() ############################################################################### # remove_list_duplicates(<list>) @@ -100,7 +100,7 @@ macro(remove_list_duplicates LIST) if(CMAKE26_OR_BETTER) # For CMake 2.6.x or better, this can be done automatically list(REMOVE_DUPLICATES ${LIST}) - else(CMAKE26_OR_BETTER) + else() # For CMake 2.4.x, we have to do this ourselves, firstly we'll clear a temporary list set(NEW_LIST) # Iterate through the old list @@ -110,12 +110,12 @@ macro(remove_list_duplicates LIST) if(FOUND_ITEM EQUAL -1) # If the item was not found, append it to the list append_to_list(NEW_LIST ${ITEM}) - endif(FOUND_ITEM EQUAL -1) - endforeach(ITEM) + endif() + endforeach() # Replace the old list with the new list set(${LIST} ${NEW_LIST}) - endif(CMAKE26_OR_BETTER) -endmacro(remove_list_duplicates) + endif() +endmacro() ############################################################################### # remove_item_from_list(<list> <value>) @@ -129,7 +129,7 @@ macro(remove_item_from_list LIST VALUE) if(CMAKE242_OR_BETTER) # For CMake 2.4.2 or better, this can be done automatically list(REMOVE_ITEM ${LIST} ${VALUE}) - else(CMAKE242_OR_BETTER) + else() # For CMake 2.4.x before 2.4.2, we have to do this ourselves, firstly we set the index and a variable to indicate if the item was found set(INDEX 0) set(FOUND FALSE) @@ -140,13 +140,13 @@ macro(remove_item_from_list LIST VALUE) if(ITEM STREQUAL ${VALUE}) set(FOUND TRUE) list(REMOVE_ITEM ${LIST} ${INDEX}) - endif(ITEM STREQUAL ${VALUE}) - endif(NOT FOUND) + endif() + endif() # Increase the index value by 1 math(EXPR INDEX "${INDEX} + 1") - endforeach(ITEM) - endif(CMAKE242_OR_BETTER) -endmacro(remove_item_from_list) + endforeach() + endif() +endmacro() ############################################################################### # sort_list(<list>) @@ -159,7 +159,7 @@ macro(sort_list LIST) if(CMAKE244_OR_BETTER) # For CMake 2.4.4 or better, this can be done automatically list(SORT ${LIST}) - else(CMAKE244_OR_BETTER) + else() # For CMake 2.4.x before 2.4.4, we have to do this ourselves, firstly we'll create a teporary list set(NEW_LIST) # Iterate through the old list @@ -174,20 +174,20 @@ macro(sort_list LIST) if(NEW_ITEM STRGREATER "${ITEM}") set(FOUND TRUE) list(INSERT NEW_LIST ${INDEX} ${ITEM}) - endif(NEW_ITEM STRGREATER "${ITEM}") - endif(NOT FOUND) + endif() + endif() # Increase the index value by 1 math(EXPR INDEX "${INDEX} + 1") - endforeach(NEW_ITEM) + endforeach() # If the item was never found, just append it to the end if(NOT FOUND) append_to_list(NEW_LIST ${ITEM}) - endif(NOT FOUND) - endforeach(ITEM) + endif() + endforeach() # Replace the old list with the new list set(${LIST} ${NEW_LIST}) - endif(CMAKE244_OR_BETTER) -endmacro(sort_list) + endif() +endmacro() ############################################################################### # read_from_file(<filename> <regex> <output variable>) @@ -203,10 +203,10 @@ macro(read_from_file FILE REGEX STRINGS) # For CMake 2.6.x or better, we can just use the STRINGS sub-command to get the lines that match the given regular expression (if one is given, otherwise get all lines) if(REGEX STREQUAL "") file(STRINGS ${FILE} RESULT) - else(REGEX STREQUAL "") + else() file(STRINGS ${FILE} RESULT REGEX ${REGEX}) - endif(REGEX STREQUAL "") - else(CMAKE26_OR_BETTER) + endif() + else() # For CMake 2.4.x, we need to do this manually, firstly we read the file in execute_process(COMMAND ${CMAKE_COMMAND} -DFILE:STRING=${FILE} -P ${Anope_SOURCE_DIR}/cmake/ReadFile.cmake ERROR_VARIABLE ALL_STRINGS) # Next we replace all newlines with semicolons @@ -214,7 +214,7 @@ macro(read_from_file FILE REGEX STRINGS) if(REGEX STREQUAL "") # For no regular expression, just set the result to all the lines set(RESULT ${ALL_STRINGS}) - else(REGEX STREQUAL "") + else() # Clear the result list set(RESULT) # Iterate through all the lines of the file @@ -224,13 +224,13 @@ macro(read_from_file FILE REGEX STRINGS) # If we had a match, append the match to the list if(STRING_MATCH) append_to_list(RESULT ${STRING}) - endif(STRING_MATCH) - endforeach(STRING) - endif(REGEX STREQUAL "") - endif(CMAKE26_OR_BETTER) + endif() + endforeach() + endif() + endif() # Set the given STRINGS variable to the result set(${STRINGS} ${RESULT}) -endmacro(read_from_file) +endmacro() ############################################################################### # extract_include_filename(<line> <output variable> [<optional output variable of quote type>]) @@ -243,7 +243,7 @@ macro(extract_include_filename INCLUDE FILENAME) # Make sure to only do the following if there is a string if(INCLUDE_STRIPPED STREQUAL "") set(FILE "") - else(INCLUDE_STRIPPED STREQUAL "") + else() # Extract the filename including the quotes or angle brackets string(REGEX REPLACE "^.*([\"<].*[\">]).*$" "\\1" FILE "${INCLUDE_STRIPPED}") # If an optional 3rd argument is given, we'll store if the quote style was quoted or angle bracketed @@ -251,16 +251,16 @@ macro(extract_include_filename INCLUDE FILENAME) string(SUBSTRING ${FILE} 0 1 QUOTE) if(QUOTE STREQUAL "<") set(${ARGV2} "angle brackets") - else(QUOTE STREQUAL "<") + else() set(${ARGV2} "quotes") - endif(QUOTE STREQUAL "<") - endif(${ARGC} GREATER 2) + endif() + endif() # Now remove the quotes or angle brackets string(REGEX REPLACE "^[\"<](.*)[\">]$" "\\1" FILE "${FILE}") - endif(INCLUDE_STRIPPED STREQUAL "") + endif() # Set the filename to the the given variable set(${FILENAME} "${FILE}") -endmacro(extract_include_filename) +endmacro() ############################################################################### # find_includes(<source filename> <output variable>) @@ -293,17 +293,17 @@ macro(find_includes SRC INCLUDES) # Replace _WIN32 with WIN32, so we can check if the WIN32 variable of CMake is set instead of _WIN32 if(DEFINE STREQUAL "_WIN32") set(DEFINE WIN32) - endif(DEFINE STREQUAL "_WIN32") + endif() # Set the last define to this one, and set the last check to true, so when #else is encountered, we can do an opposing check set(LAST_DEF ${DEFINE}) set(LAST_CHECK TRUE) # If the define is true (it either exists or is a non-false result), the lines following will be checked, otherwise they will be skipped if(${DEFINE}) set(VALID_LINE TRUE) - else(${DEFINE}) + else() set(VALID_LINE FALSE) - endif(${DEFINE}) - else(FOUND_IFDEF) + endif() + else() # If we found a #ifndef on the line, the same thing as #ifdef is done, except with the checks in the opposite direction if(FOUND_IFNDEF) # Extract the define @@ -311,52 +311,52 @@ macro(find_includes SRC INCLUDES) # Replace _WIN32 with WIN32, so we can check if the WIN32 variable of CMake is set instead of _WIN32 if(DEFINE STREQUAL "_WIN32") set(DEFINE WIN32) - endif(DEFINE STREQUAL "_WIN32") + endif() # Set the last define to this one, and set the last check to false, so when #else is encountered, we can do an opposing check set(LAST_DEF ${DEFINE}) set(LAST_CHECK FALSE) # If the define is not true (it either doesn't exists or is a false result), the lines following will be checked, otherwise they will be skipped if(${DEFINE}) set(VALID_LINE FALSE) - else(${DEFINE}) + else() set(VALUE_LINE TRUE) - endif(${DEFINE}) - else(FOUND_IFNDEF) + endif() + else() # If we found a #else on the line, we check the last define in the opposite direction if(FOUND_ELSE) # When LAST_CHECK is true, we were inside a #ifdef, now act as if we are entering a #ifndef section by doing an opposing check if(LAST_CHECK) if(${LAST_DEF}) set(VALID_LINE FALSE) - else(${LAST_DEF}) + else() set(VALID_LINE TRUE) - endif(${LAST_DEF}) + endif() # When LAST_CHECK is false, we were inside a #ifndef, now act as if we are entering a #ifdef section by doing an opposing check - else(LAST_CHECK) + else() if(${LAST_DEF}) set(VALID_LINE TRUE) - else(${LAST_DEF}) + else() set(VALID_LINE FALSE) - endif(${LAST_DEF}) - endif(LAST_CHECK) - else(FOUND_ELSE) + endif() + endif() + else() # If we found a #endif on the line, we'll assume everything following the line is valid until we meet another one of the above lines if(FOUND_ENDIF) set(VALID_LINE TRUE) - else(FOUND_ENDIF) + else() # If we found a #include on the line, add the entire line to the list of includes unless the line isn't valid if(FOUND_INCLUDE) if(VALID_LINE) append_to_list(INCLUDES_LIST "${LINE}") - endif(VALID_LINE) - endif(FOUND_INCLUDE) - endif(FOUND_ENDIF) - endif(FOUND_ELSE) - endif(FOUND_IFNDEF) - endif(FOUND_IFDEF) - endforeach(LINE) + endif() + endif() + endif() + endif() + endif() + endif() + endforeach() set(${INCLUDES} ${INCLUDES_LIST}) -endmacro(find_includes) +endmacro() ############################################################################### # calculate_depends(<source filename> [<optional output variable for includes>]) @@ -370,7 +370,7 @@ macro(calculate_depends SRC) # Check for a third argument if(${ARGC} GREATER 1) set(CHECK_ANGLE_INCLUDES TRUE) - endif(${ARGC} GREATER 1) + endif() # Find all the lines in the given source file that have any form of #include on them, regardless of whitespace, but only if they are valid for the platform we are on find_includes(${SRC} INCLUDES) # Reset the list of headers to empty @@ -385,9 +385,9 @@ macro(calculate_depends SRC) # Find the path of the include file if(DEFAULT_INCLUDE_DIRS OR WSDK_PATH OR DEFINED $ENV{VCINSTALLDIR}) find_path(FOUND_${FILENAME}_INCLUDE NAMES ${FILENAME} PATHS ${DEFAULT_INCLUDE_DIRS} ${WSDK_PATH}/include $ENV{VCINSTALLDIR}/include ${EXTRA_INCLUDE}) - else(DEFAULT_INCLUDE_DIRS OR WSDK_PATH OR DEFINED $ENV{VCINSTALLDIR}) + else() find_path(FOUND_${FILENAME}_INCLUDE NAMES ${FILENAME} ${EXTRA_INCLUDE}) - endif(DEFAULT_INCLUDE_DIRS OR WSDK_PATH OR DEFINED $ENV{VCINSTALLDIR}) + endif() # If the include file was found, add it's path to the list of include paths, but only if it doesn't already exist and isn't in the defaults for the compiler if(FOUND_${FILENAME}_INCLUDE) # This used to be find_in_list, but it was changed to this loop to do a find on each default include directory, this fixes Mac OS X trying to get it's framework directories in here @@ -397,24 +397,24 @@ macro(calculate_depends SRC) string(REGEX MATCH ${DEFAULT_INCLUDE_DIR} FOUND_DEFAULT ${FOUND_${FILENAME}_INCLUDE}) if(FOUND_DEFAULT) set(FOUND_IN_DEFAULTS 0) - endif(FOUND_DEFAULT) - endforeach(DEFAULT_INCLUDE_DIR) + endif() + endforeach() if(FOUND_IN_DEFAULTS EQUAL -1) find_in_list(${ARGV1} "${FOUND_${FILENAME}_INCLUDE}" FOUND_IN_INCLUDES) if(FOUND_IN_INCLUDES EQUAL -1) append_to_list(${ARGV1} "${FOUND_${FILENAME}_INCLUDE}") - endif(FOUND_IN_INCLUDES EQUAL -1) - endif(FOUND_IN_DEFAULTS EQUAL -1) - else(FOUND_${FILENAME}_INCLUDE) + endif() + endif() + else() # XXX if(NOT ${FILENAME} STREQUAL "libintl.h") message(FATAL_ERROR "${SRC} needs header file ${FILENAME} but we were unable to locate that header file! Check that the header file is within the search path of your OS.") - endif(NOT ${FILENAME} STREQUAL "libintl.h") - endif(FOUND_${FILENAME}_INCLUDE) - endif(CHECK_ANGLE_INCLUDES) - endif(QUOTE_TYPE STREQUAL "angle brackets") - endforeach(INCLUDE) -endmacro(calculate_depends) + endif() + endif() + endif() + endif() + endforeach() +endmacro() ############################################################################### # calculate_libraries(<source filename> <output variable for linker flags> <output var |