diff options
| -rw-r--r-- | CMakeLists.txt | 97 | ||||
| -rw-r--r-- | cmake/Anope.cmake | 268 | ||||
| -rw-r--r-- | cmake/ReadFile.cmake | 5 | ||||
| -rw-r--r-- | include/CMakeLists.txt | 9 | ||||
| -rw-r--r-- | language/CMakeLists.txt | 2 | ||||
| -rw-r--r-- | modules/CMakeLists.txt | 10 | ||||
| -rw-r--r-- | modules/third/language/CMakeLists.txt | 2 | ||||
| -rw-r--r-- | src/CMakeLists.txt | 30 | ||||
| -rw-r--r-- | src/tools/CMakeLists.txt | 2 |
9 files changed, 58 insertions, 367 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 2ec1bdfaf..d56c6bb71 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,60 +14,6 @@ endif() project(Anope CXX) enable_language(C) -# Detect the version of CMake for the later conditional checks -execute_process(COMMAND ${CMAKE_COMMAND} --version OUTPUT_VARIABLE VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) -string(REGEX REPLACE "cmake version 2\\.(.*)" "\\1" ONLY_VERSION "${VERSION}") -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() - 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() - string(REGEX REPLACE "(.*)-beta" "\\1" MINOR_VERSION "${ONLY_VERSION}") - if(MINOR_VERSION STREQUAL "4-1\n") - set(PATCH_VERSION 1) - else() - set(PATCH_VERSION 0) - endif() - set(MINOR_VERSION 4) - 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) - set(CMAKE26_OR_BETTER TRUE) - set(CMAKE248_OR_BETTER TRUE) - set(CMAKE244_OR_BETTER TRUE) - set(CMAKE242_OR_BETTER TRUE) -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() - 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() - 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() - set(CMAKE242_OR_BETTER FALSE) - 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) @@ -82,12 +28,9 @@ set(DEFAULT_INCLUDE_DIRS) # Check that we aren't running on an ancient broken GCC if(CMAKE_COMPILER_IS_GNUCXX) - execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_FULL_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) - string(REGEX REPLACE "^(\\d+\\.\\d+)" "\\1" GCC_VERSION ${GCC_FULL_VERSION}) - if(GCC_VERSION LESS 4.2) + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.2) message(FATAL_ERROR "Your compiler is too old to build Anope. Upgrade to GCC 4.2 or newer!") - endif() - if(GCC_VERSION GREATER 6.0 OR GCC_VERSION EQUAL 6.0) + elseif(CMAKE_CXX_COMPILER_ID VERSION_GREATER_EQUAL 6.0) set(CXXFLAGS "${CXXFLAGS} -fno-delete-null-pointer-checks") endif() endif() @@ -111,12 +54,12 @@ if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$") if(NOT FIRST_CHAR STREQUAL "=") # 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}) + list(APPEND DEFAULT_LIBRARY_DIRS ${LIBRARY}) endif() endforeach() # Remove duplicate entries from the list if(DEFAULT_LIBRARY_DIRS) - remove_list_duplicates(DEFAULT_LIBRARY_DIRS) + list(REMOVE_DUPLICATES DEFAULT_LIBRARY_DIRS) endif() # Create a temporary file to test for the default include directories FILE(WRITE empty.cpp "") @@ -150,14 +93,14 @@ if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$") # Convert the path to an absolute one, just in case it wasn't get_filename_component(INCLUDE ${INCLUDE} ABSOLUTE) # Add that directory to the list of default include directories - append_to_list(DEFAULT_INCLUDE_DIRS ${INCLUDE}) + list(APPEND DEFAULT_INCLUDE_DIRS ${INCLUDE}) endif() endif() endif() endforeach() # Remove duplicate entries from the list if(DEFAULT_INCLUDE_DIRS) - remove_list_duplicates(DEFAULT_INCLUDE_DIRS) + list(REMOVE_DUPLICATES DEFAULT_INCLUDE_DIRS) endif() endif() @@ -216,11 +159,7 @@ include(CheckFunctionExists) include(CheckIncludeFile) include(CheckTypeSize) include(CheckLibraryExists) -if(CMAKE244_OR_BETTER) - include(CheckCXXCompilerFlag) -else() - include(TestCXXAcceptsFlag) -endif() +include(CheckCXXCompilerFlag) # If extra include directories were specified, tell cmake about them. if(EXTRA_INCLUDE) @@ -284,7 +223,7 @@ 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}) + list(APPEND LINK_LIBS ${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 @@ -299,13 +238,7 @@ endif() # If we are not using Visual Studio, we'll run the following checks if(NOT MSVC) # Check if the C++ compiler can accept the -pipe flag, and add it to the compile flags if it works - 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() - # 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() + check_cxx_compiler_flag(-pipe HAVE_PIPE_FLAG) # If the flag was accepted, add it to the list of flags if(HAVE_PIPE_FLAG) set(CXXFLAGS "${CXXFLAGS} -pipe") @@ -316,12 +249,12 @@ if(NOT MSVC) # Check if socket is within the socket library (if the library exists), and add it to the linker flags if needed check_library_exists(socket socket "" HAVE_SOCKET_LIB) if(HAVE_SOCKET_LIB) - append_to_list(LINK_LIBS socket) + list(APPEND LINK_LIBS socket) 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) + list(APPEND LINK_LIBS nsl) 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) @@ -363,11 +296,11 @@ check_function_exists(kqueue HAVE_KQUEUE) # Strip the leading and trailing spaces from the compile flags if(CXXFLAGS) - strip_string(${CXXFLAGS} CXXFLAGS) + string(STRIP ${CXXFLAGS} CXXFLAGS) endif() # Strip the leading and trailing spaces from the linker flags if(LDFLAGS) - strip_string(${LDFLAGS} LDFLAGS) + string(STRIP ${LDFLAGS} LDFLAGS) endif() # Search for the following programs @@ -408,7 +341,7 @@ endif() # Version number processing # Find all lines in src/version.sh that start with VERSION_ -read_from_file(${Anope_SOURCE_DIR}/src/version.sh "^VERSION_" VERSIONS) +file(STRINGS ${Anope_SOURCE_DIR}/src/version.sh VERSIONS REGEX "^VERSION_") # Iterate through the strings found foreach(VERSION_STR ${VERSIONS}) string(REGEX REPLACE "^VERSION_([A-Z]+)=\"?([^\"]*)\"?$" "\\1;\\2" VERSION_OUT ${VERSION_STR}) @@ -427,7 +360,7 @@ set(VERSION_BUILD 0) # Only change the build number if version.h exists if(EXISTS "${Anope_SOURCE_DIR}/include/version.h") # Attempt to read the build number from include/version.h - read_from_file(${Anope_SOURCE_DIR}/include/version.h "^#define VERSION_BUILD" VERSIONS) + file(STRINGS ${Anope_SOURCE_DIR}/src/version.sh VERSIONS REGEX "^#define VERSION_BUILD") foreach(VERSION_STR ${VERSIONS}) # Get the length of the string string(LENGTH ${VERSION_STR} VERSION_LEN) diff --git a/cmake/Anope.cmake b/cmake/Anope.cmake index 459556019..75e2a36dc 100644 --- a/cmake/Anope.cmake +++ b/cmake/Anope.cmake @@ -1,245 +1,11 @@ ############################################################################### -# strip_string(<input string> <output string>) -# -# A macro to handle stripping the leading and trailing spaces from a string, -# uses string(STRIP) if using CMake 2.6.x or better, otherwise uses -# string(REGEX REPLACE). -############################################################################### -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() - # 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() - # Determine if the string is entirely empty or not - string(REGEX MATCH "^[ \t]*$" EMPTY_STRING "${INPUT_STRING}") - if(EMPTY_STRING) - set(${OUTPUT_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() - set(TEMP_STRING "${INPUT_STRING}") - 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() - set(${OUTPUT_STRING} "${TEMP_STRING}") - endif() - endif() - endif() - endif() -endmacro() - -############################################################################### -# append_to_list(<list> <args>...) -# -# A macro to handle appending to lists, uses list(APPEND) if using CMake 2.4.2 -# or better, otherwise uses set() instead. -############################################################################### -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() - # For CMake 2.4.x before 2.4.2, we have to do this manually use set() instead - set(${LIST} ${${LIST}} ${ARGN}) - endif() -endmacro() - -############################################################################### -# find_in_list(<list> <value> <output variable>) -# -# A macro to handle searching within a list, will store the result in the -# given <output variable>, uses list(FIND) if using CMake 2.6.x or better -# (or CMake 2.4.8 or better), otherwise it iterates through the list to find -# the item. -############################################################################### -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() - # 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) - set(POS 0) - # Iterate through the list - foreach(ITEM ${${LIST}}) - # 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() - # Increase the position value by 1 - math(EXPR POS "${POS} + 1") - endforeach() - endif() - # Set the given FOUND variable to the result - set(${FOUND} ${ITEM_FOUND}) -endmacro() - -############################################################################### -# remove_list_duplicates(<list>) -# -# A macro to handle removing duplicates from a list, uses -# list(REMOVE_DUPLICATES) if using CMake 2.6.x or better, otherwise it uses -# a slower method of creating a temporary list and only adding to it when -# a duplicate item hasn't been found. -############################################################################### -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() - # 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 - foreach(ITEM ${${LIST}}) - # Check if the item is in the new list - find_in_list(NEW_LIST ${ITEM} FOUND_ITEM) - if(FOUND_ITEM EQUAL -1) - # If the item was not found, append it to the list - append_to_list(NEW_LIST ${ITEM}) - endif() - endforeach() - # Replace the old list with the new list - set(${LIST} ${NEW_LIST}) - endif() -endmacro() - -############################################################################### -# remove_item_from_list(<list> <value>) -# -# A macro to handle removing a value from a list, uses list(REMOVE_ITEM) in -# both cases, but can remove the value itself using CMake 2.4.2 or better, -# while older versions use a slower method of iterating the list to find the -# index of the value to remove. -############################################################################### -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() - # 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) - # Iterate through the old list - foreach(ITEM ${${LIST}}) - # If the item hasn't been found yet, but the current item is the same, remove it - if(NOT FOUND) - if(ITEM STREQUAL ${VALUE}) - set(FOUND TRUE) - list(REMOVE_ITEM ${LIST} ${INDEX}) - endif() - endif() - # Increase the index value by 1 - math(EXPR INDEX "${INDEX} + 1") - endforeach() - endif() -endmacro() - -############################################################################### -# sort_list(<list>) -# -# A macro to handle sorting a list, uses list(SORT) if using CMake 2.4.4 or -# better, otherwise it uses a slower method of creating a temporary list and -# adding elements in alphabetical order. -############################################################################### -macro(sort_list LIST) - if(CMAKE244_OR_BETTER) - # For CMake 2.4.4 or better, this can be done automatically - list(SORT ${LIST}) - 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 - foreach(ITEM ${${LIST}}) - # Temporary index position for the new list, as well as temporary value to store if the item was ever found - set(INDEX 0) - set(FOUND FALSE) - # Iterate through the new list - foreach(NEW_ITEM ${NEW_LIST}) - # Compare the items, only if nothing was found before - if(NOT FOUND) - if(NEW_ITEM STRGREATER "${ITEM}") - set(FOUND TRUE) - list(INSERT NEW_LIST ${INDEX} ${ITEM}) - endif() - endif() - # Increase the index value by 1 - math(EXPR INDEX "${INDEX} + 1") - endforeach() - # If the item was never found, just append it to the end - if(NOT FOUND) - append_to_list(NEW_LIST ${ITEM}) - endif() - endforeach() - # Replace the old list with the new list - set(${LIST} ${NEW_LIST}) - endif() -endmacro() - -############################################################################### -# read_from_file(<filename> <regex> <output variable>) -# -# A macro to handle reading specific lines from a file, uses file(STRINGS) if -# using CMake 2.6.x or better, otherwise we read in the entire file and -# perform a string(REGEX MATCH) on each line of the file instead. This -# macro can also be used to read in all the lines of a file if REGEX is set -# to "". -############################################################################### -macro(read_from_file FILE REGEX STRINGS) - if(CMAKE26_OR_BETTER) - # 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() - file(STRINGS ${FILE} RESULT REGEX ${REGEX}) - 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 - string(REGEX REPLACE "\n" ";" ALL_STRINGS ${ALL_STRINGS}) - if(REGEX STREQUAL "") - # For no regular expression, just set the result to all the lines - set(RESULT ${ALL_STRINGS}) - else() - # Clear the result list - set(RESULT) - # Iterate through all the lines of the file - foreach(STRING ${ALL_STRINGS}) - # Check for a match against the given regular expression - string(REGEX MATCH ${REGEX} STRING_MATCH ${STRING}) - # If we had a match, append the match to the list - if(STRING_MATCH) - append_to_list(RESULT ${STRING}) - endif() - endforeach() - endif() - endif() - # Set the given STRINGS variable to the result - set(${STRINGS} ${RESULT}) -endmacro() - -############################################################################### # extract_include_filename(<line> <output variable> [<optional output variable of quote type>]) # # This macro will take a #include line and extract the filename. ############################################################################### macro(extract_include_filename INCLUDE FILENAME) # Strip the leading and trailing spaces from the include line - strip_string(${INCLUDE} INCLUDE_STRIPPED) + string(STRIP ${INCLUDE} INCLUDE_STRIPPED) # Make sure to only do the following if there is a string if(INCLUDE_STRIPPED STREQUAL "") set(FILE "") @@ -271,7 +37,7 @@ endmacro() ############################################################################### macro(find_includes SRC INCLUDES) # Read all lines from the file that start with #, regardless of whitespace before the # - read_from_file(${SRC} "^[ \t]*#.*$" LINES) + file(STRINGS ${SRC} LINES REGEX "^[ \t]*#.*$") # Set that any #include lines found are valid, and create temporary variables for the last found #ifdef/#ifndef set(VALID_LINE TRUE) set(LAST_DEF) @@ -347,7 +113,7 @@ macro(find_includes SRC INCLUDES) # 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}") + list(APPEND INCLUDES_LIST "${LINE}") endif() endif() endif() @@ -390,7 +156,7 @@ macro(calculate_depends SRC) 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 + # This used to be list(FIND), 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 set(FOUND_IN_DEFAULTS -1) foreach(DEFAULT_INCLUDE_DIR ${DEFAULT_INCLUDE_DIRS}) string(REGEX REPLACE "\\+" "\\\\+" DEFAULT_INCLUDE_DIR ${DEFAULT_INCLUDE_DIR}) @@ -400,9 +166,8 @@ macro(calculate_depends SRC) 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}") + if("${FOUND_${FILENAME}_INCLUDE}" IN_LIST ARGV1) + list(APPEND ${ARGV1} "${FOUND_${FILENAME}_INCLUDE}") endif() endif() else() @@ -433,9 +198,9 @@ macro(calculate_libraries SRC SRC_LDFLAGS EXTRA_DEPENDS) set(LIBRARIES) # Check to see if there are any lines matching: /* RequiredLibraries: [something] */ if(WIN32) - read_from_file(${SRC} "/\\\\*[ \t]*RequiredWindowsLibraries:[ \t]*.*[ \t]*\\\\*/" REQUIRED_LIBRARIES) + file(STRINGS ${SRC} REQUIRED_LIBRARIES REGEX "/\\\\*[ \t]*RequiredWindowsLibraries:[ \t]*.*[ \t]*\\\\*/") else() - read_from_file(${SRC} "/\\\\*[ \t]*RequiredLibraries:[ \t]*.*[ \t]*\\\\*/" REQUIRED_LIBRARIES) + file(STRINGS ${SRC} REQUIRED_LIBRARIES REGEX "/\\\\*[ \t]*RequiredLibraries:[ \t]*.*[ \t]*\\\\*/") endif() # Iterate through those lines foreach(REQUIRED_LIBRARY ${REQUIRED_LIBRARIES}) @@ -458,11 +223,11 @@ macro(calculate_libraries SRC SRC_LDFLAGS EXTRA_DEPENDS) get_filename_component(LIBRARY_PATH ${FOUND_${LIBRARY}_LIBRARY} PATH) if(MSVC) # For Visual Studio, instead of editing the linker flags, we'll add the library to a separate list of extra dependencies - append_to_list(EXTRA_DEPENDENCIES "${FOUND_${LIBRARY}_LIBRARY}") + list(APPEND EXTRA_DEPENDENCIES "${FOUND_${LIBRARY}_LIBRARY}") else() # For all others, add the library paths and libraries - append_to_list(LIBRARY_PATHS "${LIBRARY_PATH}") - append_to_list(LIBRARIES "${LIBRARY}") + list(APPEND LIBRARY_PATHS "${LIBRARY_PATH}") + list(APPEND LIBRARIES "${LIBRARY}") endif() else() # In the case of the library not being found, we fatally error so CMake stops trying to generate @@ -472,22 +237,21 @@ macro(calculate_libraries SRC SRC_LDFLAGS EXTRA_DEPENDS) endforeach() # Remove duplicates from the library paths if(LIBRARY_PATHS) - remove_list_duplicates(LIBRARY_PATHS) + list(REMOVE_DUPLICATES LIBRARY_PATHS) endif() # Remove diplicates from the libraries if(LIBRARIES) - remove_list_duplicates(LIBRARIES) + list(REMOVE_DUPLICATES LIBRARIES) endif() # Iterate through library paths and add them to the linker flags foreach(LIBRARY_PATH ${LIBRARY_PATHS}) - find_in_list(DEFAULT_LIBRARY_DIRS "${LIBRARY_PATH}" FOUND_IN_DEFAULTS) - if(FOUND_IN_DEFAULTS EQUAL -1) + if(NOT "${LIBRARY_PATH}" IN_LIST DEFAULT_LIBRARY_DIRS) set(THIS_LDFLAGS "${THIS_LDFLAGS} -L${LIBRARY_PATH}") endif() endforeach() # Iterate through libraries and add them to the linker flags foreach(LIBRARY ${LIBRARIES}) - append_to_list(EXTRA_DEPENDENCIES "${LIBRARY}") + list(APPEND EXTRA_DEPENDENCIES "${LIBRARY}") endforeach() set(${SRC_LDFLAGS} "${THIS_LDFLAGS}") set(${EXTRA_DEPENDS} "${EXTRA_DEPENDENCIES}") @@ -503,7 +267,7 @@ macro(check_functions SRC SUCCESS) # Default to true set(${SUCCESS} TRUE) # Check to see if there are any lines matching: /* RequiredFunctions: [something] */ - read_from_file(${SRC} "/\\\\*[ \t]*RequiredFunctions:[ \t]*.*[ \t]*\\\\*/" REQUIRED_FUNCTIONS) + file(STRINGS ${SRC} REQUIRED_FUNCTIONS REGEX "/\\\\*[ \t]*RequiredFunctions:[ \t]*.*[ \t]*\\\\*/") # Iterate through those lines foreach(REQUIRED_FUNCTION ${REQUIRED_FUNCTIONS}) # Strip off the /* RequiredFunctions: and */ from the line diff --git a/cmake/ReadFile.cmake b/cmake/ReadFile.cmake deleted file mode 100644 index be60f1fa7..000000000 --- a/cmake/ReadFile.cmake +++ /dev/null @@ -1,5 +0,0 @@ -# This file is external to the read_from_file macro in Anope.cmake in order to -# get around a possible memory leak in older versions of CMake. - -file(READ "${FILE}" RESULT) -message("${RESULT}") diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt index 2c8ea38a1..a059aadba 100644 --- a/include/CMakeLists.txt +++ b/include/CMakeLists.txt @@ -23,19 +23,18 @@ if(USE_PCH AND CMAKE_COMPILER_IS_GNUCXX) string(REPLACE " " ";" PCH_CXXFLAGS "${CXXFLAGS} ${CMAKE_CXX_FLAGS}") file(GLOB PCH_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.h") - sort_list(PCH_SOURCES) + list(SORT PCH_SOURCES) foreach(PCH_SOURCE ${PCH_SOURCES}) find_includes(${PCH_SOURCE} INCLUDES) set(INCLUDES_LIST) - append_to_list(INCLUDES_LIST ${PCH_SOURCE}) + list(APPEND INCLUDES_LIST ${PCH_SOURCE}) foreach(INCLUDE ${INCLUDES}) # Extract the filename from the #include line extract_include_filename(${INCLUDE} FILENAME QUOTE_TYPE) if(QUOTE_TYPE STREQUAL "quotes") - find_in_list(PCH_SOURCES "${FILENAME}" FOUND) - if(NOT FOUND EQUAL -1) - append_to_list(INCLUDES_LIST ${FILENAME}) + if(NOT ${FILENAME} IN_LIST PCH_SOURCES) + list(APPEND INCLUDES_LIST ${FILENAME}) endif() endif() endforeach() diff --git a/language/CMakeLists.txt b/language/CMakeLists.txt index 811aaf9e0..a5135a273 100644 --- a/language/CMakeLists.txt +++ b/language/CMakeLists.txt @@ -2,7 +2,7 @@ if(GETTEXT_FOUND) # Get all of the .po files file(GLOB LANG_SRCS_PO RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.*.po") - sort_list(LANG_SRCS_PO) + list(SORT LANG_SRCS_PO) foreach(LANG_PO ${LANG_SRCS_PO}) # Get the domain for this language file diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt index 200569e2d..6dbd0d4a1 100644 --- a/modules/CMakeLists.txt +++ b/modules/CMakeLists.txt @@ -29,7 +29,7 @@ macro(build_modules SRC) calculate_depends(${MODULE_SRC} TEMP_INCLUDES) # If there were some extra include directories, add them to the list if(TEMP_INCLUDES) - append_to_list(EXTRA_INCLUDES ${TEMP_INCLUDES}) + list(APPEND EXTRA_INCLUDES ${TEMP_INCLUDES}) endif() # Reset linker flags @@ -84,7 +84,7 @@ endmacro() macro(build_subdir) file(GLOB_RECURSE MODULES_SUBDIR_SRCS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.cpp") - sort_list(MODULES_SUBDIR_SRCS) + list(SORT MODULES_SUBDIR_SRCS) GET_FILENAME_COMPONENT(FOLDER_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME) set(SO "${FOLDER_NAME}.so") @@ -117,7 +117,7 @@ macro(build_subdir) # Append this source file's linker flags to the subdirectoy's linker flags, if there are any to append if(TEMP_DEPENDENCIES) - append_to_list(SUBDIR_EXTRA_DEPENDS ${TEMP_DEPDENCIES}) + list(APPEND SUBDIR_EXTRA_DEPENDS ${TEMP_DEPDENCIES}) endif() endif() endforeach() @@ -126,12 +126,12 @@ macro(build_subdir) if(HAS_FUNCTION) # Remove duplicates from the linker flags if(SUBDIR_LDFLAGS) - remove_list_duplicates(SUBDIR_LDFLAGS) + list(REMOVE_DUPLICATES SUBDIR_LDFLAGS) endif() # Remove duplicates from the extra dependencies if(SUBDIR_EXTRA_DEPENDS) - remove_list_duplicates(SUBDIR_EXTRA_DEPENDS) + list(REMOVE_DUPLICATES SUBDIR_EXTRA_DEPENDS) endif() # For Visual Studio only, include win32_memory static library, required to override Visual Studio's overrides of the new/delete operators diff --git a/modules/third/language/CMakeLists.txt b/modules/third/language/CMakeLists.txt index ce636b539..835b4ee4f 100644 --- a/modules/third/language/CMakeLists.txt +++ b/modules/third/language/CMakeLists.txt @@ -2,7 +2,7 @@ if(GETTEXT_FOUND) # Get all of the .po files file(GLOB LANG_SRCS_PO RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.*.po") - sort_list(LANG_SRCS_PO) + list(SORT LANG_SRCS_PO) foreach(LANG_PO ${LANG_SRCS_PO}) # Get the domain for this language file diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index b3d5e8705..46ca4f2fd 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -2,30 +2,30 @@ file(GLOB SRC_SRCS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.cpp") if(WIN32) - append_to_list(SRC_SRCS win32/dir/dir.cpp) - append_to_list(SRC_SRCS win32/socket.cpp) - append_to_list(SRC_SRCS win32/windows.cpp) - append_to_list(SRC_SRCS win32/dl/dl.cpp) - append_to_list(SRC_SRCS win32/pipe/pipe.cpp) - append_to_list(SRC_SRCS win32/pthread/pthread.cpp) - append_to_list(SRC_SRCS win32/sigaction/sigaction.cpp) + list(APPEND SRC_SRCS win32/dir/dir.cpp) + list(APPEND SRC_SRCS win32/socket.cpp) + list(APPEND SRC_SRCS win32/windows.cpp) + list(APPEND SRC_SRCS win32/dl/dl.cpp) + list(APPEND SRC_SRCS win32/pipe/pipe.cpp) + list(APPEND SRC_SRCS win32/pthread/pthread.cpp) + list(APPEND SRC_SRCS win32/sigaction/sigaction.cpp) endif() if(HAVE_EPOLL) - append_to_list(SRC_SRCS socketengines/socketengine_epoll.cpp) + list(APPEND SRC_SRCS socketengines/socketengine_epoll.cpp) else() if(HAVE_KQUEUE) - append_to_list(SRC_SRCS socketengines/socketengine_kqueue.cpp) + list(APPEND SRC_SRCS socketengines/socketengine_kqueue.cpp) else() if(HAVE_POLL) - append_to_list(SRC_SRCS socketengines/socketengine_poll.cpp) + list(APPEND SRC_SRCS socketengines/socketengine_poll.cpp) else() - append_to_list(SRC_SRCS socketengines/socketengine_select.cpp) + list(APPEND SRC_SRCS socketengines/socketengine_select.cpp) endif() endif() endif() -sort_list(SRC_SRCS) +list(SORT SRC_SRCS) # Set all the files to use C++ as well as set their compile flags (use the module-specific compile flags, though) set_source_files_properties(${SRC_SRCS} PROPERTIES LANGUAGE CXX COMPILE_FLAGS "${CXXFLAGS}") @@ -40,12 +40,12 @@ foreach(SRC ${SRC_SRCS}) calculate_depends(${SRC} TEMP_INCLUDES) # If there were some extra include directories, add them to the list if(TEMP_INCLUDES) - append_to_list(EXTRA_INCLUDES ${TEMP_INCLUDES}) + list(APPEND EXTRA_INCLUDES ${TEMP_INCLUDES}) endif() endforeach() # If there were extra include directories, remove the duplicates and add the directories to the include path if(EXTRA_INCLUDES) - remove_list_duplicates(EXTRA_INCLUDES) + list(REMOVE_DUPLICATES EXTRA_INCLUDES) include_directories(${EXTRA_INCLUDES}) endif() @@ -54,7 +54,7 @@ if(WIN32) # Make sure that the resource file is seen as an RC file to be compiled with a resource compiler, not a C++ compiler set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/win32/win32.rc LANGUAGE RC) # Add the resource file to the list of sources - append_to_list(SRC_SRCS ${CMAKE_CURRENT_BINARY_DIR}/win32/win32.rc) + list(APPEND SRC_SRCS ${CMAKE_CURRENT_BINARY_DIR}/win32/win32.rc) # For MinGW, we have to change the compile flags if(MINGW) set(RC_CFLAGS "-DMINGW -Ocoff -I${Anope_SOURCE_DIR}/include") diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt index b1c5916ca..2e22b575a 100644 --- a/src/tools/CMakeLists.txt +++ b/src/tools/CMakeLists.txt @@ -1,6 +1,6 @@ # Find all the *.cpp files within the current source directory, and sort the list file(GLOB TOOLS_SRCS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.cpp") -sort_list(TOOLS_SRCS) +list(SORT TOOLS_SRCS) # Set all the files to use C++ as well as set their compile flags set_source_files_properties(${TOOLS_SRCS} PROPERTIES LANGUAGE CXX COMPILE_FLAGS "${CXXFLAGS}") |