Remove the repeated conditions in cmake endif/else statements.

2 files changed, 121 insertions, 121 deletions

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 variable for extra depends>)
@@ -434,9 +434,9 @@ macro(calculate_libraries SRC SRC_LDFLAGS EXTRA_DEPENDS)
   # 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)
+  else()
     read_from_file(${SRC} "/\\\\*[ \t]*RequiredLibraries:[ \t]*.*[ \t]*\\\\*/" REQUIRED_LIBRARIES)
-  endif(WIN32)
+  endif()
   # Iterate through those lines
   foreach(REQUIRED_LIBRARY ${REQUIRED_LIBRARIES})
     # Strip off the /* RequiredLibraries: and */ from the line
@@ -448,10 +448,10 @@ macro(calculate_libraries SRC SRC_LDFLAGS EXTRA_DEPENDS)
       # 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} 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} PATHS ${EXTRA_INCLUDE} ${EXTRA_LIBS} NO_DEFAULT_PATH)
         find_library(FOUND_${LIBRARY}_LIBRARY NAMES ${LIBRARY} 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)
         # Get the path only of the library, to add it to linker flags
@@ -459,39 +459,39 @@ macro(calculate_libraries SRC SRC_LDFLAGS EXTRA_DEPENDS)
         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)
+        else()
           # For all others, add the library paths and libraries
           append_to_list(LIBRARY_PATHS "${LIBRARY_PATH}")
           append_to_list(LIBRARIES "${LIBRARY}")
-        endif(MSVC)
-      else(FOUND_${LIBRARY}_LIBRARY)
+        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)
+  endif()
   # Remove diplicates from the libraries
   if(LIBRARIES)
     remove_list_duplicates(LIBRARIES)
-  endif(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)
       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)
+  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>)
@@ -518,10 +518,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])
@@ -536,12 +536,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()