Rip out compatibility code for now-unsupported CMake versions.

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}")