diff options
Diffstat (limited to 'cmake')
| -rw-r--r-- | cmake/Anope.cmake | 406 | ||||
| -rw-r--r-- | cmake/FindGettext.cmake | 12 | ||||
| -rw-r--r-- | cmake/ReadFile.cmake | 5 |
3 files changed, 91 insertions, 332 deletions
diff --git a/cmake/Anope.cmake b/cmake/Anope.cmake index 1b924bc5d..bda078da9 100644 --- a/cmake/Anope.cmake +++ b/cmake/Anope.cmake @@ -1,249 +1,15 @@ ############################################################################### -# 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(CMAKE26_OR_BETTER) - # 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 "") - # 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) - # 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") - set(TEMP_STRING "${INPUT_STRING}") - endif(FIRST_CHAR STREQUAL " " OR FIRST_CHAR STREQUAL "\t") - # 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") - 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) - -############################################################################### -# 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(CMAKE242_OR_BETTER) - # 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) - -############################################################################### -# 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(CMAKE248_OR_BETTER) - # 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(${ITEM} STREQUAL ${ITEM_TO_FIND}) - # Increase the position value by 1 - math(EXPR POS "${POS} + 1") - endforeach(ITEM) - endif(CMAKE248_OR_BETTER) - # Set the given FOUND variable to the result - set(${FOUND} ${ITEM_FOUND}) -endmacro(find_in_list) - -############################################################################### -# 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(CMAKE26_OR_BETTER) - # 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(FOUND_ITEM EQUAL -1) - endforeach(ITEM) - # Replace the old list with the new list - set(${LIST} ${NEW_LIST}) - endif(CMAKE26_OR_BETTER) -endmacro(remove_list_duplicates) - -############################################################################### -# 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(CMAKE242_OR_BETTER) - # 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(ITEM STREQUAL ${VALUE}) - endif(NOT FOUND) - # Increase the index value by 1 - math(EXPR INDEX "${INDEX} + 1") - endforeach(ITEM) - endif(CMAKE242_OR_BETTER) -endmacro(remove_item_from_list) - -############################################################################### -# 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(CMAKE244_OR_BETTER) - # For CMake 2.4.x before 2.4.4, we have to do this ourselves, firstly we'll create a temporary 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(NEW_ITEM STRGREATER "${ITEM}") - endif(NOT FOUND) - # Increase the index value by 1 - math(EXPR INDEX "${INDEX} + 1") - endforeach(NEW_ITEM) - # 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) - # Replace the old list with the new list - set(${LIST} ${NEW_LIST}) - endif(CMAKE244_OR_BETTER) -endmacro(sort_list) - -############################################################################### -# 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(REGEX STREQUAL "") - file(STRINGS ${FILE} RESULT REGEX ${REGEX}) - endif(REGEX STREQUAL "") - else(CMAKE26_OR_BETTER) - # 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(REGEX STREQUAL "") - # 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(STRING_MATCH) - endforeach(STRING) - endif(REGEX STREQUAL "") - endif(CMAKE26_OR_BETTER) - # Set the given STRINGS variable to the result - set(${STRINGS} ${RESULT}) -endmacro(read_from_file) - -############################################################################### # 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 "") - 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 +17,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>) @@ -271,7 +37,7 @@ endmacro(extract_include_filename) ############################################################################### 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) @@ -293,17 +59,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 +77,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) + list(APPEND INCLUDES_LIST "${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 +136,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,36 +151,35 @@ 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 + # 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}) 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) + if("${FOUND_${FILENAME}_INCLUDE}" IN_LIST ARGV1) + list(APPEND ${ARGV1} "${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 variable for extra depends>) @@ -433,10 +198,10 @@ 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) - else(WIN32) - read_from_file(${SRC} "/\\\\*[ \t]*RequiredLibraries:[ \t]*.*[ \t]*\\\\*/" REQUIRED_LIBRARIES) - endif(WIN32) + file(STRINGS ${SRC} REQUIRED_LIBRARIES REGEX "/\\*[ \t]*RequiredWindowsLibraries:[ \t]*.*[ \t]*\\*/") + else() + file(STRINGS ${SRC} REQUIRED_LIBRARIES REGEX "/\\*[ \t]*RequiredLibraries:[ \t]*.*[ \t]*\\*/") + endif() # Iterate through those lines foreach(REQUIRED_LIBRARY ${REQUIRED_LIBRARIES}) # Strip off the /* RequiredLibraries: and */ from the line @@ -450,56 +215,55 @@ macro(calculate_libraries SRC SRC_LDFLAGS EXTRA_DEPENDS) if (${LIBRARY} MATCHES "^.+\\|.+$") string(REGEX REPLACE ".+\\|(.*)" "\\1" LIBRARY_ALT ${LIBRARY}) string(REGEX REPLACE "(.+)\\|.*" "\\1" LIBRARY ${LIBRARY}) - endif(${LIBRARY} MATCHES "^.+\\|.+$") + endif() # Locate the library to see if it exists if(DEFAULT_LIBRARY_DIRS OR WSDK_PATH OR DEFINED $ENV{VCINSTALLDIR}) find_library(FOUND_${LIBRARY}_LIBRARY NAMES ${LIBRARY} ${LIBRARY_ALT} PATHS ${DEFAULT_LIBRARY_DIRS} ${WSDK_PATH}/lib $ENV{VCINSTALLDIR}/lib ${EXTRA_INCLUDE} ${EXTRA_LIBS}) - else(DEFAULT_LIBRARY_DIRS OR WSDK_PATH OR DEFINED $ENV{VCINSTALLDIR}) + else() find_library(FOUND_${LIBRARY}_LIBRARY NAMES ${LIBRARY} ${LIBRARY_ALT} PATHS ${EXTRA_INCLUDE} ${EXTRA_LIBS} NO_DEFAULT_PATH) find_library(FOUND_${LIBRARY}_LIBRARY NAMES ${LIBRARY} ${LIBRARY_ALT} PATHS ${EXTRA_INCLUDE} ${EXTRA_LIBS}) - endif(DEFAULT_LIBRARY_DIRS OR WSDK_PATH OR DEFINED $ENV{VCINSTALLDIR}) + endif() # If the library was found, we will add it to the linker flags if(FOUND_${LIBRARY}_LIBRARY) 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}") - else(MSVC) + list(APPEND EXTRA_DEPENDENCIES "${FOUND_${LIBRARY}_LIBRARY}") + else() # Get the path only of the library, to add it to library paths. get_filename_component(LIBRARY_PATH ${FOUND_${LIBRARY}_LIBRARY} PATH) - append_to_list(LIBRARY_PATHS "${LIBRARY_PATH}") + list(APPEND LIBRARY_PATHS "${LIBRARY_PATH}") # Extract the library short name, add it to the library path get_filename_component(LIBRARY_NAME ${FOUND_${LIBRARY}_LIBRARY} NAME_WE) string(REGEX REPLACE "^lib" "" LIBRARY_NAME ${LIBRARY_NAME}) - append_to_list(LIBRARIES ${LIBRARY_NAME}) - endif(MSVC) - else(FOUND_${LIBRARY}_LIBRARY) + list(APPEND LIBRARIES ${LIBRARY_NAME}) + endif() + else() # In the case of the library not being found, we fatally error so CMake stops trying to generate message(FATAL_ERROR "${SRC} needs library ${LIBRARY} but we were unable to locate that library! Check that the library is within the search path of your OS.") - endif(FOUND_${LIBRARY}_LIBRARY) - endforeach(LIBRARY) - endforeach(REQUIRED_LIBRARY) + endif() + endforeach() + endforeach() # Remove duplicates from the library paths if(LIBRARY_PATHS) - remove_list_duplicates(LIBRARY_PATHS) - endif(LIBRARY_PATHS) + list(REMOVE_DUPLICATES LIBRARY_PATHS) + endif() # Remove diplicates from the libraries if(LIBRARIES) - remove_list_duplicates(LIBRARIES) - endif(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(FOUND_IN_DEFAULTS EQUAL -1) - endforeach(LIBRARY_PATH) + endif() + endforeach() # Iterate through libraries and add them to the linker flags foreach(LIBRARY ${LIBRARIES}) - append_to_list(EXTRA_DEPENDENCIES "${LIBRARY}") - endforeach(LIBRARY) + list(APPEND EXTRA_DEPENDENCIES "${LIBRARY}") + endforeach() set(${SRC_LDFLAGS} "${THIS_LDFLAGS}") set(${EXTRA_DEPENDS} "${EXTRA_DEPENDENCIES}") -endmacro(calculate_libraries) +endmacro() ############################################################################### # check_functions(<source filename> <output variable set to TRUE on success>) @@ -511,7 +275,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 @@ -526,10 +290,10 @@ macro(check_functions SRC SUCCESS) if(NOT HAVE_${REQUIRED_FUNCTION}) message("${SRC} needs function ${REQUIRED_FUNCTION} but we were unable to locate that function!") set(${SUCCESS} FALSE) - endif(NOT HAVE_${REQUIRED_FUNCTION}) - endforeach(FUNCTION) - endforeach(REQUIRED_FUNCTION) -endmacro(check_functions) + endif() + endforeach() + endforeach() +endmacro() ############################################################################### # add_to_cpack_ignored_files(<item> [TRUE]) @@ -544,12 +308,12 @@ macro(add_to_cpack_ignored_files ITEM) # If we have 2+ arguments, assume that the second one was something like TRUE (doesn't matter really) and convert periods so they will be \\. for CPack if(${ARGC} GREATER 1) string(REPLACE "." "\\\\." REAL_ITEM ${REAL_ITEM}) - endif(${ARGC} GREATER 1) + endif() # If the environment variable is already defined, just tack the item to the end if(DEFINED ENV{CPACK_IGNORED_FILES}) set(ENV{CPACK_IGNORED_FILES} "$ENV{CPACK_IGNORED_FILES};${REAL_ITEM}") # Otherwise set the environment variable to the item - else(DEFINED ENV{CPACK_IGNORED_FILES}) + else() set(ENV{CPACK_IGNORED_FILES} "${REAL_ITEM}") - endif(DEFINED ENV{CPACK_IGNORED_FILES}) -endmacro(add_to_cpack_ignored_files) + endif() +endmacro() diff --git a/cmake/FindGettext.cmake b/cmake/FindGettext.cmake index 975294d21..b0f4f9486 100644 --- a/cmake/FindGettext.cmake +++ b/cmake/FindGettext.cmake @@ -7,20 +7,20 @@ if(NOT WIN32) set(GETTEXT_FOUND TRUE) if(GETTEXT_LIBRARY) set(GETTEXT_LIBRARIES ${GETTEXT_LIBRARY}) - endif(GETTEXT_LIBRARY) - endif(GETTEXT_INCLUDE AND GETTEXT_MSGFMT) -else(NOT WIN32) + endif() + endif() +else() find_path(GETTEXT_INCLUDE libintl.h ${DEFAULT_INCLUDE_DIRS} ${WSDK_PATH}/include $ENV{VCINSTALLDIR}/include gettext/include ${EXTRA_INCLUDE}) find_library(GETTEXT_LIBRARY libintl PATHS ${DEFAULT_LIBRARY_DIRS} ${WSDK_PATH}/lib $ENV{VCINSTALLDIR}/lib gettext/lib ${EXTRA_LIBS}) find_program(GETTEXT_MSGFMT msgfmt PATHS ${DEFAULT_INCLUDE_DIRS} ${WSDK_PATH}/bin $ENV{VCINSTALLDIR}/bin gettext/bin ${EXTRA_INCLUDE}) if(GETTEXT_INCLUDE AND GETTEXT_LIBRARY AND GETTEXT_MSGFMT) set(GETTEXT_FOUND TRUE) set(GETTEXT_LIBRARIES ${GETTEXT_LIBRARY}) - endif(GETTEXT_INCLUDE AND GETTEXT_LIBRARY AND GETTEXT_MSGFMT) -endif(NOT WIN32) + endif() +endif() # If we found everything we need set variables correctly for lang/CMakeLists.txt to use if(GETTEXT_FOUND) include_directories("${GETTEXT_INCLUDE}") set(GETTEXT_MSGFMT_EXECUTABLE ${GETTEXT_MSGFMT}) -endif(GETTEXT_FOUND) +endif() 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}") |