Codechange: Make codestyle for CMake files consistent for 'control' statements

25 files changed, 486 insertions, 486 deletions

diff --git a/cmake/AddCustomXXXTimestamp.cmake b/cmake/AddCustomXXXTimestamp.cmake
index ca9398873..c8d134e08 100644
--- a/cmake/AddCustomXXXTimestamp.cmake
+++ b/cmake/AddCustomXXXTimestamp.cmake
@@ -9,7 +9,7 @@ macro(_parse_arguments_with_multi_hack ORIGINAL_COMMAND_LINE)
 
     foreach(MULTI IN LISTS MULTIS)
         string(REPLACE "${MULTI}" "${MULTI};:::" COMMAND_LINE "${COMMAND_LINE}")
-    endforeach(MULTI)
+    endforeach()
 
     cmake_parse_arguments(PARAM "${OPTIONS}" "${SINGLES}" "${MULTIS}" ${COMMAND_LINE})
 endmacro()
@@ -19,25 +19,25 @@ macro(_reassemble_command_line)
     set(NEW_COMMAND_LINE ${PARAM_UNPARSED_ARGUMENTS})
 
     foreach(OPTION IN LISTS OPTIONS)
-        if (PARAM_${OPTION})
+        if(PARAM_${OPTION})
             list(APPEND NEW_COMMAND_LINE "${OPTION}")
-        endif (PARAM_${OPTION})
-    endforeach(OPTION)
+        endif()
+    endforeach()
 
     foreach(SINGLE IN LISTS SINGLES)
-        if (PARAM_${SINGLE})
+        if(PARAM_${SINGLE})
             list(APPEND NEW_COMMAND_LINE "${SINGLE}" "${PARAM_${SINGLE}}")
-        endif (PARAM_${SINGLE})
-    endforeach(SINGLE)
+        endif()
+    endforeach()
 
     foreach(MULTI IN LISTS MULTIS)
-        if (PARAM_${MULTI})
+        if(PARAM_${MULTI})
             # Replace our special marker with the name of the MULTI again. This
             # restores for example multiple COMMANDs again.
             string(REPLACE ":::" "${MULTI}" PARAM_${MULTI} "${PARAM_${MULTI}}")
             list(APPEND NEW_COMMAND_LINE "${PARAM_${MULTI}}")
-        endif (PARAM_${MULTI})
-    endforeach(MULTI)
+        endif()
+    endforeach()
 endmacro()
 
 # Generated files can be older than their dependencies, causing useless
@@ -72,9 +72,9 @@ function(add_custom_command_timestamp)
     # Reset the OUTPUT and BYPRODUCTS as an empty list (if needed).
     # Because they are MULTIS, we need to add our special marker here.
     set(PARAM_OUTPUT ":::")
-    if (NOT PARAM_BYPRODUCTS)
+    if(NOT PARAM_BYPRODUCTS)
         set(PARAM_BYPRODUCTS ":::")
-    endif ()
+    endif()
 
     foreach(OUTPUT IN LISTS OUTPUTS)
         # For every output, we add a 'cmake -E touch' entry to update the
@@ -91,12 +91,12 @@ function(add_custom_command_timestamp)
         # add_custom_target_timestamp() to know if we should point to the
         # '.timestamp' variant or not.
         set_source_files_properties(${OUTPUT} PROPERTIES BYPRODUCT ${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_FILENAME}.timestamp)
-    endforeach(OUTPUT)
+    endforeach()
 
     # Reassemble and call the wrapped command
     _reassemble_command_line()
     add_custom_command(${NEW_COMMAND_LINE})
-endfunction(add_custom_command_timestamp)
+endfunction()
 
 # Generated files can be older than their dependencies, causing useless
 # regenerations. This function adds a .timestamp file for each file in DEPENDS
@@ -130,16 +130,16 @@ function(add_custom_target_timestamp)
         # Check if the output is produced by add_custom_command_timestamp()
         get_source_file_property(BYPRODUCT ${DEPEND} BYPRODUCT)
 
-        if (BYPRODUCT STREQUAL "NOTFOUND")
+        if(BYPRODUCT STREQUAL "NOTFOUND")
             # If it is not, just keep it as DEPEND
             list(APPEND PARAM_DEPENDS "${DEPEND}")
-        else (BYPRODUCT STREQUAL "NOTFOUND")
+        else()
             # If it is, the BYPRODUCT property points to the timestamp we want to depend on
             list(APPEND PARAM_DEPENDS "${BYPRODUCT}")
-        endif (BYPRODUCT STREQUAL "NOTFOUND")
-    endforeach(DEPEND)
+        endif()
+    endforeach()
 
     # Reassemble and call the wrapped command
     _reassemble_command_line()
     add_custom_target(${NEW_COMMAND_LINE})
-endfunction(add_custom_target_timestamp)
+endfunction()
diff --git a/cmake/CompileFlags.cmake b/cmake/CompileFlags.cmake
index 49ae1d767..f371353ae 100644
--- a/cmake/CompileFlags.cmake
+++ b/cmake/CompileFlags.cmake
@@ -3,7 +3,7 @@
 # compile_flags()
 #
 macro(compile_flags)
-    if (MSVC)
+    if(MSVC)
         # Switch to MT (static) instead of MD (dynamic) binary
 
         # For MSVC two generators are available
@@ -23,14 +23,14 @@ macro(compile_flags)
         # C++11 standard". We need C++11 for the way we use threads.
         add_compile_options(/Zc:rvalueCast)
 
-        if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
             # Enable multi-threaded compilation.
             add_compile_options(/MP)
-        endif(NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        endif()
 
         # Add DPI manifest to project; other WIN32 targets get this via ottdres.rc
         list(APPEND GENERATED_SOURCE_FILES "${CMAKE_SOURCE_DIR}/os/windows/openttd.manifest")
-    endif (MSVC)
+    endif()
 
     # Add some -D flags for Debug builds. We cannot use add_definitions(), because
     # it does not appear to support the $<> tags.
@@ -38,19 +38,19 @@ macro(compile_flags)
         "$<$<CONFIG:Debug>:-D_DEBUG>"
         "$<$<NOT:$<CONFIG:Debug>>:-D_FORTIFY_SOURCE=2>" # FORTIFY_SOURCE should only be used in non-debug builds (requires -O1+)
     )
-    if (MINGW)
+    if(MINGW)
         add_link_options(
             "$<$<NOT:$<CONFIG:Debug>>:-fstack-protector>" # Prevent undefined references when _FORTIFY_SOURCE > 0
         )
-    endif (MINGW)
+    endif()
 
     # Prepare a generator that checks if we are not a debug, and don't have asserts
     # on. We need this later on to set some compile options for stable releases.
     set(IS_STABLE_RELEASE "$<AND:$<NOT:$<CONFIG:Debug>>,$<NOT:$<BOOL:${OPTION_USE_ASSERTS}>>>")
 
-    if (MSVC)
+    if(MSVC)
         add_compile_options(/W3)
-    elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
         add_compile_options(
             -W
             -Wall
@@ -81,33 +81,33 @@ macro(compile_flags)
         # When we are a stable release (Release build + USE_ASSERTS not set),
         # assertations are off, which trigger a lot of warnings. We disable
         # these warnings for these releases.
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
             add_compile_options(
                 "$<${IS_STABLE_RELEASE}:-Wno-unused-variable>"
                 "$<${IS_STABLE_RELEASE}:-Wno-unused-but-set-parameter>"
                 "$<${IS_STABLE_RELEASE}:-Wno-unused-but-set-variable>"
             )
-        else (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        else()
             add_compile_options(
                 "$<${IS_STABLE_RELEASE}:-Wno-unused-variable>"
                 "$<${IS_STABLE_RELEASE}:-Wno-unused-parameter>"
             )
-        endif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        endif()
 
         # Ninja processes the output so the output from the compiler
         # isn't directly to a terminal; hence, the default is
         # non-coloured output. We can override this to get nicely
         # coloured output, but since that might yield odd results with
         # IDEs, we extract it to an option.
-        if (OPTION_FORCE_COLORED_OUTPUT)
-            if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        if(OPTION_FORCE_COLORED_OUTPUT)
+            if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
                 add_compile_options (-fdiagnostics-color=always)
-            elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+            elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
                 add_compile_options (-fcolor-diagnostics)
-            endif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        endif (OPTION_FORCE_COLORED_OUTPUT)
+            endif()
+        endif()
 
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
             include(CheckCXXCompilerFlag)
             check_cxx_compiler_flag("-flifetime-dse=1" LIFETIME_DSE_FOUND)
 
@@ -126,8 +126,8 @@ macro(compile_flags)
                 # well with our custom pool item allocator
                 "$<$<BOOL:${LIFETIME_DSE_FOUND}>:-flifetime-dse=1>"
             )
-        endif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+        endif()
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
         add_compile_options(
             -Wall
             # warning #873: function ... ::operator new ... has no corresponding operator delete ...
@@ -139,12 +139,12 @@ macro(compile_flags)
             # warning #2160: anonymous union qualifier is ignored
             -wd2160
         )
-    else ()
+    else()
         message(FATAL_ERROR "No warning flags are set for this compiler yet; please consider creating a Pull Request to add support for this compiler.")
-    endif ()
+    endif()
 
-    if (NOT WIN32)
+    if(NOT WIN32)
         # rdynamic is used to get useful stack traces from crash reports.
         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -rdynamic")
-    endif (NOT WIN32)
+    endif()
 endmacro()
diff --git a/cmake/CreateGrfCommand.cmake b/cmake/CreateGrfCommand.cmake
index 25e599f56..4ad973419 100644
--- a/cmake/CreateGrfCommand.cmake
+++ b/cmake/CreateGrfCommand.cmake
@@ -26,7 +26,7 @@ function(create_grf_command)
         )
 
         list(APPEND GRF_PNG_BINARY_FILES ${GRF_PNG_BINARY_FILE})
-    endforeach(GRF_PNG_SOURCE_FILE)
+    endforeach()
 
     add_custom_command(OUTPUT ${GRF_BINARY_FILE}
             COMMAND ${CMAKE_COMMAND}
diff --git a/cmake/CreateRegression.cmake b/cmake/CreateRegression.cmake
index 443332368..3da3438b4 100644
--- a/cmake/CreateRegression.cmake
+++ b/cmake/CreateRegression.cmake
@@ -13,9 +13,9 @@ macro(create_regression)
         string(REGEX REPLACE "^${CMAKE_SOURCE_DIR}/regression/" "${CMAKE_BINARY_DIR}/ai/" REGRESSION_BINARY_FILE "${REGRESSION_SOURCE_FILE}")
         string(REGEX REPLACE "^${CMAKE_SOURCE_DIR}/regression/" "" REGRESSION_SOURCE_FILE_NAME "${REGRESSION_SOURCE_FILE}")
 
-        if ("${REGRESSION_SOURCE_FILE_NAME}" STREQUAL "regression.cfg")
+        if("${REGRESSION_SOURCE_FILE_NAME}" STREQUAL "regression.cfg")
             continue()
-        endif ("${REGRESSION_SOURCE_FILE_NAME}" STREQUAL "regression.cfg")
+        endif()
 
         add_custom_command(OUTPUT ${REGRESSION_BINARY_FILE}
                 COMMAND ${CMAKE_COMMAND} -E copy
@@ -26,7 +26,7 @@ macro(create_regression)
         )
 
         list(APPEND REGRESSION_BINARY_FILES ${REGRESSION_BINARY_FILE})
-    endforeach(REGRESSION_SOURCE_FILE)
+    endforeach()
 
     # Copy the regression configuration in a special folder, so all autogenerated
     # folders end up in the same place after running regression.
@@ -53,9 +53,9 @@ macro(create_regression)
     foreach(REGRESSION_TEST IN LISTS REGRESSION_TESTS)
         get_filename_component(REGRESSION_TEST_NAME "${REGRESSION_TEST}" NAME)
 
-        if ("${REGRESSION_TEST_NAME}" STREQUAL "regression.cfg")
+        if("${REGRESSION_TEST_NAME}" STREQUAL "regression.cfg")
             continue()
-        endif ("${REGRESSION_TEST_NAME}" STREQUAL "regression.cfg")
+        endif()
 
         add_custom_target(regression_${REGRESSION_TEST_NAME}
                 COMMAND ${CMAKE_COMMAND}
@@ -78,7 +78,7 @@ macro(create_regression)
                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
 
         list(APPEND REGRESSION_TARGETS regression_${REGRESSION_TEST_NAME})
-    endforeach(REGRESSION_TEST)
+    endforeach()
 
     # Create a new target which runs the regression
     add_custom_target(regression
diff --git a/cmake/Endian.cmake b/cmake/Endian.cmake
index 00cb97544..3bfba653c 100644
--- a/cmake/Endian.cmake
+++ b/cmake/Endian.cmake
@@ -6,9 +6,9 @@ function(add_endian_definition)
     include(TestBigEndian)
     TEST_BIG_ENDIAN(IS_BIG_ENDIAN)
 
-    if (IS_BIG_ENDIAN)
+    if(IS_BIG_ENDIAN)
         add_definitions(-DTTD_ENDIAN=TTD_BIG_ENDIAN)
-    else (IS_BIG_ENDIAN)
+    else()
         add_definitions(-DTTD_ENDIAN=TTD_LITTLE_ENDIAN)
-    endif (IS_BIG_ENDIAN)
+    endif()
 endfunction()
diff --git a/cmake/FindAllegro.cmake b/cmake/FindAllegro.cmake
index 85b2ffd39..3c90d2c4e 100644
--- a/cmake/FindAllegro.cmake
+++ b/cmake/FindAllegro.cmake
@@ -54,10 +54,10 @@ find_package_handle_standard_args(Allegro
     VERSION_VAR Allegro_VERSION
 )
 
-if (Allegro_FOUND)
+if(Allegro_FOUND)
     set(Allegro_LIBRARIES ${Allegro_LIBRARY})
     set(Allegro_INCLUDE_DIRS ${Allegro_INCLUDE_DIR})
-endif ()
+endif()
 
 mark_as_advanced(
     Allegro_INCLUDE_DIR
diff --git a/cmake/FindEditbin.cmake b/cmake/FindEditbin.cmake
index 8ed30599f..f4d55d7cb 100644
--- a/cmake/FindEditbin.cmake
+++ b/cmake/FindEditbin.cmake
@@ -1,15 +1,15 @@
 # Autodetect editbin. Only useful for MSVC.
 
-if (NOT EDITBIN_DIRECTORY)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+if(NOT EDITBIN_DIRECTORY)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
         get_filename_component(MSVC_COMPILE_DIRECTORY ${CMAKE_CXX_COMPILER} DIRECTORY)
         set(EDITBIN_DIRECTORY ${MSVC_COMPILE_DIRECTORY})
-    else (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    else()
         # For clang-cl build
         # find editbin.exe from environmental variable VCToolsInstallDir
         set(EDITBIN_DIRECTORY "$ENV{VCToolsInstallDir}/bin/Hostx64/x64")
-    endif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-endif (NOT EDITBIN_DIRECTORY)
+    endif()
+endif()
 
 message(CHECK_START "Finding editbin.exe")
 find_program(
@@ -17,11 +17,11 @@ find_program(
     HINTS ${EDITBIN_DIRECTORY}
 )
 
-if (EDITBIN_EXECUTABLE)
+if(EDITBIN_EXECUTABLE)
     message(CHECK_PASS "found")
-else (EDITBIN_EXECUTABLE)
+else()
     message(CHECK_FAIL "not found , please manually specify EDITBIN_DIRECTORY")
-endif (EDITBIN_EXECUTABLE)
+endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Editbin
diff --git a/cmake/FindFluidsynth.cmake b/cmake/FindFluidsynth.cmake
index 063726dbe..0ac4931d7 100644
--- a/cmake/FindFluidsynth.cmake
+++ b/cmake/FindFluidsynth.cmake
@@ -54,10 +54,10 @@ find_package_handle_standard_args(Fluidsynth
     VERSION_VAR Fluidsynth_VERSION
 )
 
-if (Fluidsynth_FOUND)
+if(Fluidsynth_FOUND)
     set(Fluidsynth_LIBRARIES ${Fluidsynth_LIBRARY})
     set(Fluidsynth_INCLUDE_DIRS ${Fluidsynth_INCLUDE_DIR})
-endif ()
+endif()
 
 mark_as_advanced(
     Fluidsynth_INCLUDE_DIR
diff --git a/cmake/FindFontconfig.cmake b/cmake/FindFontconfig.cmake
index a6f0180b3..68c557b82 100644
--- a/cmake/FindFontconfig.cmake
+++ b/cmake/FindFontconfig.cmake
@@ -55,7 +55,7 @@ find_library( Fontconfig_LIBRARY
     ${PKG_FONTCONFIG_LIBRARY_DIRS}
 )
 
-if (Fontconfig_INCLUDE_DIR AND NOT Fontconfig_VERSION)
+if(Fontconfig_INCLUDE_DIR AND NOT Fontconfig_VERSION)
   file(STRINGS ${Fontconfig_INCLUDE_DIR}/fontconfig/fontconfig.h _contents REGEX "^#define[ \t]+FC_[A-Z]+[ \t]+[0-9]+$")
   unset(Fontconfig_VERSION)
   foreach(VPART MAJOR MINOR REVISION)
@@ -70,7 +70,7 @@ if (Fontconfig_INCLUDE_DIR AND NOT Fontconfig_VERSION)
       endif()
     endforeach()
   endforeach()
-endif ()
+endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Fontconfig
diff --git a/cmake/FindICU.cmake b/cmake/FindICU.cmake
index 471e43c1d..b110dbf40 100644
--- a/cmake/FindICU.cmake
+++ b/cmake/FindICU.cmake
@@ -29,7 +29,7 @@ find_package(PkgConfig QUIET)
 set(ICU_KNOWN_COMPONENTS "uc" "i18n" "le" "lx" "io")
 
 foreach(MOD_NAME IN LISTS ICU_FIND_COMPONENTS)
-    if (NOT MOD_NAME IN_LIST ICU_KNOWN_COMPONENTS)
+    if(NOT MOD_NAME IN_LIST ICU_KNOWN_COMPONENTS)
         message(FATAL_ERROR "Unknown ICU component: ${MOD_NAME}")
     endif()
     pkg_check_modules(PC_ICU_${MOD_NAME} QUIET icu-${MOD_NAME})
@@ -39,14 +39,14 @@ foreach(MOD_NAME IN LISTS ICU_FIND_COMPONENTS)
     foreach(LIBRARY IN LISTS PC_ICU_${MOD_NAME}_LIBRARIES)
         unset(PC_LIBRARY CACHE)
         find_library(PC_LIBRARY NAMES ${LIBRARY})
-        if (NOT PC_LIBRARY)
+        if(NOT PC_LIBRARY)
             unset(PC_ICU_${MOD_NAME}_FOUND)
         endif()
         list(APPEND PC_LIBRARIES ${PC_LIBRARY})
     endforeach()
     unset(PC_LIBRARY CACHE)
 
-    if (${PC_ICU_${MOD_NAME}_FOUND})
+    if(${PC_ICU_${MOD_NAME}_FOUND})
         set(ICU_COMPONENT_FOUND TRUE)
         set(ICU_${MOD_NAME}_FOUND TRUE)
         set(ICU_${MOD_NAME}_LIBRARIES ${PC_LIBRARIES})
diff --git a/cmake/FindLZO.cmake b/cmake/FindLZO.cmake
index 9a409002d..dacd9387d 100644
--- a/cmake/FindLZO.cmake
+++ b/cmake/FindLZO.cmake
@@ -55,8 +55,8 @@ find_library(LZO_LIBRARY
 # name as the optimized file. This is not always the case, but so far
 # experiences has shown that in those case vcpkg CMake files do the right
 # thing.
-if (VCPKG_TOOLCHAIN AND LZO_LIBRARY)
-    if (LZO_LIBRARY MATCHES "/debug/")
+if(VCPKG_TOOLCHAIN AND LZO_LIBRARY)
+    if(LZO_LIBRARY MATCHES "/debug/")
         set(LZO_LIBRARY_DEBUG ${LZO_LIBRARY})
         string(REPLACE "/debug/lib/" "/lib/" LZO_LIBRARY_RELEASE ${LZO_LIBRARY})
     else()
@@ -78,10 +78,10 @@ find_package_handle_standard_args(LZO
     VERSION_VAR LZO_VERSION
 )
 
-if (LZO_FOUND)
+if(LZO_FOUND)
     set(LZO_LIBRARIES ${LZO_LIBRARY})
     set(LZO_INCLUDE_DIRS ${LZO_INCLUDE_DIR})
-endif ()
+endif()
 
 mark_as_advanced(
     LZO_INCLUDE_DIR
diff --git a/cmake/FindSSE.cmake b/cmake/FindSSE.cmake
index d0a57ccbb..e8dc243d9 100644
--- a/cmake/FindSSE.cmake
+++ b/cmake/FindSSE.cmake
@@ -4,9 +4,9 @@
 include(CheckCXXSourceCompiles)
 set(CMAKE_REQUIRED_FLAGS "")
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
     set(CMAKE_REQUIRED_FLAGS "-msse4.1")
-endif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+endif()
 
 check_cxx_source_compiles("
     #include <xmmintrin.h>
diff --git a/cmake/FindXDG_basedir.cmake b/cmake/FindXDG_basedir.cmake
index 913b425e2..a33e9760d 100644
--- a/cmake/FindXDG_basedir.cmake
+++ b/cmake/FindXDG_basedir.cmake
@@ -54,10 +54,10 @@ find_package_handle_standard_args(XDG_basedir
     VERSION_VAR XDG_basedir_VERSION
 )
 
-if (XDG_basedir_FOUND)
+if(XDG_basedir_FOUND)
     set(XDG_basedir_LIBRARIES ${XDG_basedir_LIBRARY})
     set(XDG_basedir_INCLUDE_DIRS ${XDG_basedir_INCLUDE_DIR})
-endif ()
+endif()
 
 mark_as_advanced(
     XDG_basedir_INCLUDE_DIR
diff --git a/cmake/InstallAndPackage.cmake b/cmake/InstallAndPackage.cmake
index c8cd6b44a..eafcfc21b 100644
--- a/cmake/InstallAndPackage.cmake
+++ b/cmake/InstallAndPackage.cmake
@@ -1,17 +1,17 @@
 include(GNUInstallDirs)
 
 # If requested, use FHS layout; otherwise fall back to a flat layout.
-if (OPTION_INSTALL_FHS)
+if(OPTION_INSTALL_FHS)
     set(BINARY_DESTINATION_DIR "${CMAKE_INSTALL_BINDIR}")
     set(DATA_DESTINATION_DIR "${CMAKE_INSTALL_DATADIR}/${BINARY_NAME}")
     set(DOCS_DESTINATION_DIR "${CMAKE_INSTALL_DOCDIR}")
     set(MAN_DESTINATION_DIR "${CMAKE_INSTALL_MANDIR}")
-else (OPTION_INSTALL_FHS)
+else()
     set(BINARY_DESTINATION_DIR ".")
     set(DATA_DESTINATION_DIR ".")
     set(DOCS_DESTINATION_DIR ".")
     set(MAN_DESTINATION_DIR ".")
-endif (OPTION_INSTALL_FHS)
+endif()
 
 install(TARGETS openttd
         RUNTIME
@@ -39,7 +39,7 @@ install(FILES
 
 # A Linux manual only makes sense when using FHS. Otherwise it is a very odd
 # file with little context to what it is.
-if (OPTION_INSTALL_FHS)
+if(OPTION_INSTALL_FHS)
     set(MAN_SOURCE_FILE ${CMAKE_SOURCE_DIR}/docs/openttd.6)
     set(MAN_BINARY_FILE ${CMAKE_BINARY_DIR}/docs/${BINARY_NAME}.6)
     install(CODE
@@ -52,26 +52,26 @@ if (OPTION_INSTALL_FHS)
                     ${MAN_BINARY_FILE}.gz
             DESTINATION ${MAN_DESTINATION_DIR}/man6
             COMPONENT manual)
-endif (OPTION_INSTALL_FHS)
+endif()
 
 # TODO -- Media files
 # TODO -- Menu files
 
-if (CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
     set(ARCHITECTURE "amd64")
-else (CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+else()
     string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" ARCHITECTURE)
-endif (CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+endif()
 
 # Windows is a bit more annoying to detect; using the size of void pointer
 # seems to be the most robust.
-if (WIN32)
-    if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+if(WIN32)
+    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
         set(ARCHITECTURE "win64")
-    else (CMAKE_SIZEOF_VOID_P EQUAL 8)
+    else()
         set(ARCHITECTURE "win32")
-    endif (CMAKE_SIZEOF_VOID_P EQUAL 8)
-endif (WIN32)
+    endif()
+endif()
 
 set(CPACK_SYSTEM_NAME "${ARCHITECTURE}")
 
@@ -90,33 +90,33 @@ set(CPACK_PACKAGE_EXECUTABLES "openttd;OpenTTD")
 set(CPACK_STRIP_FILES YES)
 set(CPACK_OUTPUT_FILE_PREFIX "bundles")
 
-if (APPLE)
+if(APPLE)
     set(CPACK_GENERATOR "Bundle")
     include(PackageBundle)
 
     set(CPACK_PACKAGE_FILE_NAME "openttd-#CPACK_PACKAGE_VERSION#-macosx")
-elseif (WIN32)
+elseif(WIN32)
     set(CPACK_GENERATOR "ZIP")
-    if (OPTION_USE_NSIS)
+    if(OPTION_USE_NSIS)
         list(APPEND CPACK_GENERATOR "NSIS")
         include(PackageNSIS)
-    endif (OPTION_USE_NSIS)
+    endif()
 
     set(CPACK_PACKAGE_FILE_NAME "openttd-#CPACK_PACKAGE_VERSION#-windows-${CPACK_SYSTEM_NAME}")
-elseif (UNIX)
+elseif(UNIX)
     # With FHS, we can create deb/rpm/... Without it, they would be horribly broken
     # and not work. The other way around is also true; with FHS they are not
     # usable, and only flat formats work.
-    if (OPTION_INSTALL_FHS)
+    if(OPTION_INSTALL_FHS)
         set(CPACK_GENERATOR "DEB")
         include(PackageDeb)
-    else (OPTION_INSTALL_FHS)
+    else()
         set(CPACK_GENERATOR "TXZ")
-    endif (OPTION_INSTALL_FHS)
+    endif()
 
     set(CPACK_PACKAGE_FILE_NAME "openttd-#CPACK_PACKAGE_VERSION#-linux-${CPACK_SYSTEM_NAME}")
-else ()
+else()
     message(FATAL_ERROR "Unknown OS found for packaging; please consider creating a Pull Request to add support for this OS.")
-endif ()
+endif()
 
 include(CPack)
diff --git a/cmake/LinkPackage.cmake b/cmake/LinkPackage.cmake
index f64ccfd51..9977ecc45 100644
--- a/cmake/LinkPackage.cmake
+++ b/cmake/LinkPackage.cmake
@@ -1,10 +1,10 @@
 function(link_package NAME)
     cmake_parse_arguments(LP "ENCOURAGED" "TARGET" "" ${ARGN})
 
-    if (${NAME}_FOUND)
+    if(${NAME}_FOUND)
         string(TOUPPER "${NAME}" UCNAME)
         add_definitions(-DWITH_${UCNAME})
-        if (LP_TARGET AND TARGET ${LP_TARGET})
+        if(LP_TARGET AND TARGET ${LP_TARGET})
             target_link_libraries(openttd ${LP_TARGET})
             message(STATUS "${NAME} found -- -DWITH_${UCNAME} -- ${LP_TARGET}")
         else()
@@ -12,7 +12,7 @@ function(link_package NAME)
             target_link_libraries(openttd ${${NAME}_LIBRARIES} ${${NAME}_LIBRARY})
             message(STATUS "${NAME} found -- -DWITH_${UCNAME} -- ${${NAME}_INCLUDE_DIRS} ${${NAME}_INCLUDE_DIR} -- ${${NAME}_LIBRARIES} ${${NAME}_LIBRARY}")
         endif()
-    elseif (LP_ENCOURAGED)
+    elseif(LP_ENCOURAGED)
         message(WARNING "${NAME} not found; compiling OpenTTD without ${NAME} is strongly disencouraged")
     endif()
 endfunction()
diff --git a/cmake/Options.cmake b/cmake/Options.cmake
index 4f2404b2d..0167ad0a6 100644
--- a/cmake/Options.cmake
+++ b/cmake/Options.cmake
@@ -5,36 +5,36 @@ include(GNUInstallDirs)
 # set_directory_options()
 #
 function(set_directory_options)
-    if (APPLE)
+    if(APPLE)
         set(DEFAULT_PERSONAL_DIR "Documents/OpenTTD")
         set(DEFAULT_SHARED_DIR "/Library/Application Support/OpenTTD")
         set(DEFAULT_GLOBAL_DIR "(not set)")
-    elseif (WIN32)
+    elseif(WIN32)
         set(DEFAULT_PERSONAL_DIR "OpenTTD")
         set(DEFAULT_SHARED_DIR "(not set)")
         set(DEFAULT_GLOBAL_DIR "(not set)")
-    elseif (UNIX)
+    elseif(UNIX)
         set(DEFAULT_PERSONAL_DIR ".${BINARY_NAME}")
         set(DEFAULT_SHARED_DIR "(not set)")
         set(DEFAULT_GLOBAL_DIR "${CMAKE_INSTALL_FULL_DATADIR}/${BINARY_NAME}")
-    else ()
+    else()
         message(FATAL_ERROR "Unknown OS found; please consider creating a Pull Request to add support for this OS.")
-    endif ()
+    endif()
 
-    if (NOT PERSONAL_DIR)
+    if(NOT PERSONAL_DIR)
         set(PERSONAL_DIR "${DEFAULT_PERSONAL_DIR}" CACHE STRING "Personal directory")
         message(STATUS "Detecting Personal Data directory - ${PERSONAL_DIR}")
-    endif (NOT PERSONAL_DIR)
+    endif()
 
-    if (NOT SHARED_DIR)
+    if(NOT SHARED_DIR)
         set(SHARED_DIR "${DEFAULT_SHARED_DIR}" CACHE STRING "Shared directory")
         message(STATUS "Detecting Shared Data directory - ${SHARED_DIR}")
-    endif (NOT SHARED_DIR)
+    endif()
 
-    if (NOT GLOBAL_DIR)
+    if(NOT GLOBAL_DIR)
         set(GLOBAL_DIR "${DEFAULT_GLOBAL_DIR}" CACHE STRING "Global directory")
         message(STATUS "Detecting Global Data directory - ${GLOBAL_DIR}")
-    endif (NOT GLOBAL_DIR)
+    endif()
 endfunction()
 
 # Set some generic options that influence what is being build.
@@ -42,11 +42,11 @@ endfunction()
 # set_options()
 #
 function(set_options)
-    if (UNIX AND NOT APPLE)
+    if(UNIX AND NOT APPLE)
         set(DEFAULT_OPTION_INSTALL_FHS ON)
-    else (UNIX AND NOT APPLE)
+    else()
         set(DEFAULT_OPTION_INSTALL_FHS OFF)
-    endif (UNIX AND NOT APPLE)
+    endif()
 
     option(OPTION_FORCE_COLORED_OUTPUT "Always produce ANSI-colored output (GNU/Clang only)." OFF)
 
@@ -74,17 +74,17 @@ endfunction()
 # add_definitions_based_on_options()
 #
 function(add_definitions_based_on_options)
-    if (OPTION_DEDICATED)
+    if(OPTION_DEDICATED)
         add_definitions(-DDEDICATED)
-    endif (OPTION_DEDICATED)
+    endif()
 
-    if (NOT OPTION_USE_THREADS)
+    if(NOT OPTION_USE_THREADS)
         add_definitions(-DNO_THREADS)
-    endif (NOT OPTION_USE_THREADS)
+    endif()
 
-    if (OPTION_USE_ASSERTS)
+    if(OPTION_USE_ASSERTS)
         add_definitions(-DWITH_ASSERT)
-    else (OPTION_USE_ASSERTS)
+    else()
         add_definitions(-DNDEBUG)
-    endif (OPTION_USE_ASSERTS)
+    endif()
 endfunction()
diff --git a/cmake/SourceList.cmake b/cmake/SourceList.cmake
index 6300a19a4..6e95be201 100644
--- a/cmake/SourceList.cmake
+++ b/cmake/SourceList.cmake
@@ -10,16 +10,16 @@ function(add_files)
     cmake_parse_arguments(PARAM "" "" "CONDITION" ${ARGN})
     set(PARAM_FILES "${PARAM_UNPARSED_ARGUMENTS}")
 
-    if (PARAM_CONDITION)
-        if (NOT (${PARAM_CONDITION}))
+    if(PARAM_CONDITION)
+        if(NOT (${PARAM_CONDITION}))
             return()
-        endif (NOT (${PARAM_CONDITION}))
-    endif (PARAM_CONDITION)
+        endif()
+    endif()
 
     foreach(FILE IN LISTS PARAM_FILES)
         target_sources(openttd PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/${FILE})
     endforeach()
-endfunction(add_files)
+endfunction()
 
 # This function works around an 'issue' with CMake, where
 # set_source_files_properties() only works in the scope of the file. We want
@@ -42,7 +42,7 @@ function(set_compile_flags)
     endforeach()
 
     set_property(GLOBAL PROPERTY source_properties "${SOURCE_PROPERTIES}")
-endfunction(set_compile_flags)
+endfunction()
 
 # Call this macro in the same CMakeLists.txt and after add_executable().
 # This makes sure all the COMPILE_FLAGS of set_compile_flags() are set
@@ -60,4 +60,4 @@ function(process_compile_flags)
 
         set_source_files_properties(${FILE} PROPERTIES COMPILE_FLAGS ${PROPERTIES})
     endforeach()
-endfunction(process_compile_flags)
+endfunction()
diff --git a/cmake/Static.cmake b/cmake/Static.cmake
index 7648d05e7..682527aff 100644
--- a/cmake/Static.cmake
+++ b/cmake/Static.cmake
@@ -3,7 +3,7 @@
 # set_static()
 #
 function(set_static_if_needed)
-     if (MINGW)
+     if(MINGW)
         # Let exectutables run outside MinGW environment
         # Force searching static libs
         set(CMAKE_FIND_LIBRARY_SUFFIXES ".a" PARENT_SCOPE)
diff --git a/cmake/scripts/Baseset.cmake b/cmake/scripts/Baseset.cmake
index 4329dbdf8..7cf60629d 100644
--- a/cmake/scripts/Baseset.cmake
+++ b/cmake/scripts/Baseset.cmake
@@ -12,13 +12,13 @@ set(ARG_READ NO)
 while(ARGC LESS CMAKE_ARGC)
     set(ARG ${CMAKE_ARGV${ARGC}})
 
-    if (ARG_READ)
+    if(ARG_READ)
         list(APPEND LANG_SOURCE_FILES "${ARG}")
-    endif (ARG_READ)
+    endif()
 
-    if (ARG STREQUAL "--")
+    if(ARG STREQUAL "--")
         set(ARG_READ YES)
-    endif (ARG STREQUAL "--")
+    endif()
 
     math(EXPR ARGC "${ARGC} + 1")
 endwhile()
@@ -33,17 +33,17 @@ string(REGEX REPLACE "@(.*)@" "\\1" PLACE_HOLDER "${PLACE_HOLDER}")
 foreach(LANGFILE IN LISTS LANG_SOURCE_FILES)
     file(STRINGS "${LANGFILE}" LANGLINES REGEX "^(##isocode|${STR_ID})" ENCODING UTF-8)
     string(FIND "${LANGLINES}" "${STR_ID}" HAS_STR_ID)
-    if (HAS_STR_ID LESS 0)
+    if(HAS_STR_ID LESS 0)
         continue()
-    endif (HAS_STR_ID LESS 0)
+    endif()
     string(REGEX REPLACE "##isocode ([^;]+).*" "\\1" ISOCODE "${LANGLINES}")
-    if ("${ISOCODE}" STREQUAL "en_GB")
+    if("${ISOCODE}" STREQUAL "en_GB")
         string(REGEX REPLACE "[^:]*:(.*)" "${INI_KEY}       = \\1" LANGLINES "${LANGLINES}")
     else()
         string(REGEX REPLACE "[^:]*:(.*)" "${INI_KEY}.${ISOCODE} = \\1" LANGLINES "${LANGLINES}")
     endif()
     list(APPEND ${PLACE_HOLDER} ${LANGLINES})
-endforeach(LANGFILE)
+endforeach()
 list(SORT ${PLACE_HOLDER})
 string(REPLACE ";" "\n" ${PLACE_HOLDER} "${${PLACE_HOLDER}}")
 
diff --git a/cmake/scripts/CreateGRF.cmake b/cmake/scripts/CreateGRF.cmake
index f5811daf9..8631284f3 100644
--- a/cmake/scripts/CreateGRF.cmake
+++ b/cmake/scripts/CreateGRF.cmake
@@ -5,18 +5,18 @@ cmake_minimum_required(VERSION 3.5)
 # files.
 #
 
-if (NOT NFORENUM_EXECUTABLE)
+if(NOT NFORENUM_EXECUTABLE)
     message(FATAL_ERROR "Script needs NFORENUM_EXECUTABLE defined")
-endif (NOT NFORENUM_EXECUTABLE)
-if (NOT GRFCODEC_EXECUTABLE)
+endif()
+if(NOT GRFCODEC_EXECUTABLE)
     message(FATAL_ERROR "Script needs GRFCODEC_EXECUTABLE defined")
-endif (NOT GRFCODEC_EXECUTABLE)
-if (NOT GRF_SOURCE_FOLDER)
+endif()
+if(NOT GRF_SOURCE_FOLDER)
     message(FATAL_ERROR "Script needs GRF_SOURCE_FOLDER defined")
-endif (NOT GRF_SOURCE_FOLDER)
-if (NOT GRF_BINARY_FILE)
+endif()
+if(NOT GRF_BINARY_FILE)
     message(FATAL_ERROR "Script needs GRF_BINARY_FILE defined")
-endif (NOT GRF_BINARY_FILE)
+endif()
 
 get_filename_component(GRF_SOURCE_FOLDER_NAME "${GRF_SOURCE_FOLDER}" NAME)
 
@@ -30,14 +30,14 @@ foreach(NFO_LINE IN LISTS NFO_LINES)
     # Recover the ; that was really in the text (and not a newline)
     string(REPLACE "\\;" ";" NFO_LINE "${NFO_LINE}")
 
-    if (NFO_LINE MATCHES "^#include")
+    if(NFO_LINE MATCHES "^#include")
         string(REGEX REPLACE "^#include \"(.*)\"$" "\\1" INCLUDE_FILE ${NFO_LINE})
         file(READ ${GRF_SOURCE_FOLDER}/${INCLUDE_FILE} INCLUDE_LINES)
         file(APPEND sprites/${GRF_SOURCE_FOLDER_NAME}.nfo "${INCLUDE_LINES}")
-    else (NFO_LINE MATCHES "^#include")
+    else()
         file(APPEND sprites/${GRF_SOURCE_FOLDER_NAME}.nfo "${NFO_LINE}\n")
-    endif (NFO_LINE MATCHES "^#include")
-endforeach(NFO_LINE)
+    endif()
+endforeach()
 
 execute_process(COMMAND ${NFORENUM_EXECUTABLE} -s sprites/${GRF_SOURCE_FOLDER_NAME}.nfo)
 execute_process(COMMAND ${GRFCODEC_EXECUTABLE} -n -s -e -p1 ${GRF_SOURCE_FOLDER_NAME}.grf)
diff --git a/cmake/scripts/FindVersion.cmake b/cmake/scripts/FindVersion.cmake
index b53f77032..bb754fc5b 100644
--- a/cmake/scripts/FindVersion.cmake
+++ b/cmake/scripts/FindVersion.cmake
@@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5)
 
 find_package(Git QUIET)
 # ${CMAKE_SOURCE_DIR}/.git may be a directory or a regular file
-if (GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
     # Make sure LC_ALL is set to something desirable
     set(SAVED_LC_ALL "$ENV{LC_ALL}")
     set(ENV{LC_ALL} C)
@@ -26,7 +26,7 @@ if (GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
                     OUTPUT_STRIP_TRAILING_WHITESPACE
                     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
     )
-    if (NOT IS_MODIFIED STREQUAL "")
+    if(NOT IS_MODIFIED STREQUAL "")
         set(REV_MODIFIED 2)
     endif()
 
@@ -69,34 +69,34 @@ if (GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
     )
     string(REGEX REPLACE "\^0$" "" TAG "${TAG}")
 
-    if (REV_MODIFIED EQUAL 0)
+    if(REV_MODIFIED EQUAL 0)
         set(HASHPREFIX "-g")
-    elseif (REV_MODIFIED EQUAL 2)
+    elseif(REV_MODIFIED EQUAL 2)
         set(HASHPREFIX "-m")
-    else ()
+    else()
         set(HASHPREFIX "-u")
     endif()
 
     # Set the version string
-    if (NOT TAG STREQUAL "")
+    if(NOT TAG STREQUAL "")
         set(REV_VERSION "${TAG}")
         set(REV_ISTAG 1)
 
         string(REGEX REPLACE "^[0-9.]+$" "" STABLETAG "${TAG}")
-        if (NOT STABLETAG STREQUAL "")
+        if(NOT STABLETAG STREQUAL "")
             set(REV_ISSTABLETAG 1)
-        else ()
+        else()
             set(REV_ISSTABLETAG 0)
-        endif ()
-    else ()
+        endif()
+    else()
         set(REV_VERSION "${REV_ISODATE}-${BRANCH}${HASHPREFIX}${SHORTHASH}")
         set(REV_ISTAG 0)
         set(REV_ISSTABLETAG 0)
-    endif ()
+    endif()
 
     # Restore LC_ALL
     set(ENV{LC_ALL} "${SAVED_LC_ALL}")
-elseif (EXISTS "${CMAKE_SOURCE_DIR}/.ottdrev")
+elseif(EXISTS "${CMAKE_SOURCE_DIR}/.ottdrev")
     file(READ "${CMAKE_SOURCE_DIR}/.ottdrev" OTTDREV)
     string(REPLACE "\n" "" OTTDREV "${OTTDREV}")
     string(REPLACE "\t" ";" OTTDREV "${OTTDREV}")
@@ -107,7 +107,7 @@ elseif (EXISTS "${CMAKE_SOURCE_DIR}/.ottdrev")
     list(GET OTTDREV 4 REV_ISTAG)
     list(GET OTTDREV 5 REV_ISSTABLETAG)
     list(GET OTTDREV 6 REV_YEAR)
-else ()
+else()
     message(WARNING "No version detected; this build will NOT be network compatible")
     set(REV_VERSION "norev0000")
     set(REV_ISODATE "19700101")
@@ -116,25 +116,25 @@ else ()
     set(REV_ISTAG 0)
     set(REV_ISSTABLETAG 0)
     set(REV_YEAR "1970")
-endif ()
+endif()
 
 message(STATUS "Version string: ${REV_VERSION}")
 
-if (GENERATE_OTTDREV)
+if(GENERATE_OTTDREV)
     message(STATUS "Generating .ottdrev")
     file(WRITE ${CMAKE_SOURCE_DIR}/.ottdrev "${REV_VERSION}\t${REV_ISODATE}\t${REV_MODIFIED}\t${REV_HASH}\t${REV_ISTAG}\t${REV_ISSTABLETAG}\t${REV_YEAR}\n")
-else (GENERATE_OTTDREV)
+else()
     message(STATUS "Generating rev.cpp")
     configure_file("${CMAKE_SOURCE_DIR}/src/rev.cpp.in"
             "${FIND_VERSION_BINARY_DIR}/rev.cpp")
 
-    if (WIN32)
+    if(WIN32)
         message(STATUS "Generating ottdres.rc")
         configure_file("${CMAKE_SOURCE_DIR}/src/os/windows/ottdres.rc.in"
                 "${FIND_VERSION_BINARY_DIR}/ottdres.rc")
-    endif (WIN32)
+    endif()
 
     message(STATUS "Generating CPackProperties.cmake")
     configure_file("${CMAKE_SOURCE_DIR}/CPackProperties.cmake.in"
             "${CPACK_BINARY_DIR}/CPackProperties.cmake" @ONLY)
-endif (GENERATE_OTTDREV)
+endif()
diff --git a/cmake/scripts/GenerateWidget.cmake b/cmake/scripts/GenerateWidget.cmake
index 0bb349095..f46a67e69 100644
--- a/cmake/scripts/GenerateWidget.cmake
+++ b/cmake/scripts/GenerateWidget.cmake
@@ -15,12 +15,12 @@ cmake_minimum_required(VERSION 3.5)
 #
 #
 
-if (NOT GENERATE_SOURCE_FILE)
+if(NOT GENERATE_SOURCE_FILE)
     message(FATAL_ERROR "Script needs GENERATE_SOURCE_FILE defined")
-endif (NOT GENERATE_SOURCE_FILE)
-if (NOT GENERATE_BINARY_FILE)
+endif()
+if(NOT GENERATE_BINARY_FILE)
     message(FATAL_ERROR "Script needs GENERATE_BINARY_FILE defined")
-endif (NOT GENERATE_BINARY_FILE)
+endif()
 
 file(STRINGS ${GENERATE_SOURCE_FILE} ENUM_LINES REGEX "@enum")
 
@@ -46,38 +46,38 @@ foreach(ENUM IN LISTS ENUM_LINES)
             string(REPLACE "${RM_INDENT}" "" LINE "${LINE}")
 
             # Remember possible doxygen comment before enum declaration
-            if ((NOT ACTIVE) AND "${LINE}" MATCHES "/\\*\\*")
+            if((NOT ACTIVE) AND "${LINE}" MATCHES "/\\*\\*")
                 set(COMMENT "${ADD_INDENT}${LINE}")
                 set(ACTIVE_COMMENT 1)
-            elseif (ACTIVE_COMMENT EQUAL 1)
+            elseif(ACTIVE_COMMENT EQUAL 1)
                 string(APPEND COMMENT "\n${ADD_INDENT}${LINE}")
             endif()
 
             # Check for enum match
-            if ("${LINE}" MATCHES "^	*enum *${ENUM_PATTERN} *\{")
+            if("${LINE}" MATCHES "^	*enum *${ENUM_PATTERN} *\{")
                 # REGEX REPLACE does a REGEX MATCHALL and fails if an empty string is matched
                 string(REGEX MATCH "[^	]*" RESULT "${LINE}")
                 string(REPLACE "${RESULT}" "" RM_INDENT "${LINE}")
 
                 set(ACTIVE 1)
-                if (ACTIVE_COMMENT GREATER 0)
+                if(ACTIVE_COMMENT GREATER 0)
                      string(APPEND ${PLACE_HOLDER} "\n${COMMENT}")
-                endif (ACTIVE_COMMENT GREATER 0)
+                endif()
                 unset(ACTIVE_COMMENT)
                 unset(COMMENT)
-            endif ("${LINE}" MATCHES "^	*enum *${ENUM_PATTERN} *\{")
+            endif()
 
             # Forget doxygen comment, if no enum follows
-            if (ACTIVE_COMMENT EQUAL 2 AND NOT "${LINE}" STREQUAL "")
+            if(ACTIVE_COMMENT EQUAL 2 AND NOT "${LINE}" STREQUAL "")
                 unset(ACTIVE_COMMENT)
                 unset(COMMENT)
-            endif (ACTIVE_COMMENT EQUAL 2 AND NOT "${LINE}" STREQUAL "")
-            if (ACTIVE_COMMENT EQUAL 1 AND "${LINE}" MATCHES "\\*/")
+            endif()
+            if(ACTIVE_COMMENT EQUAL 1 AND "${LINE}" MATCHES "\\*/")
                 set(ACTIVE_COMMENT 2)
-            endif (ACTIVE_COMMENT EQUAL 1 AND "${LINE}" MATCHES "\\*/")
+            endif()
 
-            if (ACTIVE)
-                if ("${LINE}" MATCHES "^	*[A-Za-z0-9_]* *[,=]")
+            if(ACTIVE)
+                if("${LINE}" MATCHES "^	*[A-Za-z0-9_]* *[,=]")
                     # Transform enum values
                     # REGEX REPLACE does a REGEX MATCHALL and replaces too much
                     string(REGEX MATCH " *=[^,]*" RESULT "${LINE}")
@@ -92,28 +92,28 @@ foreach(ENUM IN LISTS ENUM_LINES)
                     unset(SPACES)
                     foreach(i RANGE ${LEN})
                         string(APPEND SPACES " ")
-                    endforeach(i)
+                    endforeach()
 
-                    if (CMAKE_MATCH_3)
+                    if(CMAKE_MATCH_3)
                         string(APPEND ${PLACE_HOLDER} "\n${ADD_INDENT}${CMAKE_MATCH_1}${CMAKE_MATCH_2}${SPACES} = ::${CMAKE_MATCH_2},${SPACES}${CMAKE_MATCH_3}")
-                    else (CMAKE_MATCH_3)
+                    else()
                         string(APPEND ${PLACE_HOLDER} "\n${ADD_INDENT}${CMAKE_MATCH_1}${CMAKE_MATCH_2}${SPACES} = ::${CMAKE_MATCH_2},")
-                    endif (CMAKE_MATCH_3)
-                elseif ("${LINE}" STREQUAL "")
+                    endif()
+                elseif("${LINE}" STREQUAL "")
                     string(APPEND ${PLACE_HOLDER} "\n")
-                else ()
+                else()
                     string(APPEND ${PLACE_HOLDER} "\n${ADD_INDENT}${LINE}")
-                endif ()
-            endif (ACTIVE)
+                endif()
+            endif()
 
-            if ("${LINE}" MATCHES "^	*\};")
-                if (ACTIVE)
+            if("${LINE}" MATCHES "^	*\};")
+                if(ACTIVE)
                     string(APPEND ${PLACE_HOLDER} "\n")
-                endif (ACTIVE)
+                endif()
                 unset(ACTIVE)
-            endif ("${LINE}" MATCHES "^	*\};")
-         endforeach(LINE)
-    endforeach(FILE)
- endforeach(ENUM)
+            endif()
+         endforeach()
+    endforeach()
+ endforeach()
 
 configure_file(${GENERATE_SOURCE_FILE} ${GENERATE_BINARY_FILE})
diff --git a/cmake/scripts/Regression.cmake b/cmake/scripts/Regression.cmake
index 9984396ea..af473ea9f 100644
--- a/cmake/scripts/Regression.cmake
+++ b/cmake/scripts/Regression.cmake
@@ -4,26 +4,26 @@ cmake_minimum_required(VERSION 3.5)
 # Runs a single regressoion test
 #
 
-if (NOT REGRESSION_TEST)
+if(NOT REGRESSION_TEST)
     message(FATAL_ERROR "Script needs REGRESSION_TEST defined (tip: use -DREGRESSION_TEST=..)")
-endif (NOT REGRESSION_TEST)
-if (NOT OPENTTD_EXECUTABLE)
+endif()
+if(NOT OPENTTD_EXECUTABLE)
     message(FATAL_ERROR "Script needs OPENTTD_EXECUTABLE defined (tip: use -DOPENTTD_EXECUTABLE=..)")
-endif (NOT OPENTTD_EXECUTABLE)
+endif()
 
-if (NOT EXISTS ai/${REGRESSION_TEST}/test.sav)
+if(NOT EXISTS ai/${REGRESSION_TEST}/test.sav)
     message(FATAL_ERROR "Regression test ${REGRESSION_TEST} does not exist (tip: check regression folder for the correct spelling)")
-endif ()
+endif()
 
 # If editbin is given, copy the executable to a new folder, and change the
 # subsystem to console. The copy is needed as multiple regressions can run
 # at the same time.
-if (EDITBIN_EXECUTABLE)
+if(EDITBIN_EXECUTABLE)
     execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${OPENTTD_EXECUTABLE} regression/${REGRESSION_TEST}.exe)
     set(OPENTTD_EXECUTABLE "regression/${REGRESSION_TEST}.exe")
 
     execute_process(COMMAND ${EDITBIN_EXECUTABLE} /nologo /subsystem:console ${OPENTTD_EXECUTABLE})
-endif (EDITBIN_EXECUTABLE)
+endif()
 
 # Run the regression test
 execute_process(COMMAND ${OPENTTD_EXECUTABLE}
@@ -40,13 +40,13 @@ execute_process(COMMAND ${OPENTTD_EXECUTABLE}
                 OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 
-if (REGRESSION_OUTPUT)
+if(REGRESSION_OUTPUT)
     message(FATAL_ERROR "Unexpected output: ${REGRESSION_OUTPUT}")
-endif (REGRESSION_OUTPUT)
+endif()
 
-if (NOT REGRESSION_RESULT)
+if(NOT REGRESSION_RESULT)
     message(FATAL_ERROR "Regression did not output anything; did the compilation fail?")
-endif (NOT REGRESSION_RESULT)
+endif()
 
 # For some reason pointer can be printed as '0x(nil)', '0x0000000000000000', or '0x0x0'
 string(REPLACE "0x(nil)" "0x00000000" REGRESSION_RESULT "${REGRESSION_RESULT}")
@@ -76,21 +76,21 @@ list(LENGTH REGRESSION_EXPECTED REGRESSION_EXPECTED_LENGTH)
 foreach(RESULT IN LISTS REGRESSION_RESULT)
     list(GET REGRESSION_EXPECTED ${ARGC} EXPECTED)
 
-    if (NOT RESULT STREQUAL EXPECTED)
+    if(NOT RESULT STREQUAL EXPECTED)
         message("${ARGC}: - ${EXPECTED}")
         message("${ARGC}: + ${RESULT}'")
         set(ERROR YES)
-    endif (NOT RESULT STREQUAL EXPECTED)
+    endif()
 
     math(EXPR ARGC "${ARGC} + 1")
-endforeach(RESULT)
+endforeach()
 
-if (NOT REGRESSION_EXPECTED_LENGTH EQUAL ARGC)
+if(NOT REGRESSION_EXPECTED_LENGTH EQUAL ARGC)
     math(EXPR MISSING "${REGRESSION_EXPECTED_LENGTH} - ${ARGC}")
     message("(${MISSING} more lines were expected than found)")
     set(ERROR YES)
-endif (NOT REGRESSION_EXPECTED_LENGTH EQUAL ARGC)
+endif()
 
-if (ERROR)
+if(ERROR)
     message(FATAL_ERROR "Regression failed")
-endif (ERROR)
+endif()
diff --git a/cmake/scripts/SquirrelExport.cmake b/cmake/scripts/SquirrelExport.cmake
index 315be36c5..3b230de00 100644
--- a/cmake/scripts/SquirrelExport.cmake
+++ b/cmake/scripts/SquirrelExport.cmake
@@ -1,29 +1,29 @@
 cmake_minimum_required(VERSION 3.5)
 
-if (NOT SCRIPT_API_SOURCE_FILE)
+if(NOT SCRIPT_API_SOURCE_FILE)
     message(FATAL_ERROR "Script needs SCRIPT_API_SOURCE_FILE defined")
-endif (NOT SCRIPT_API_SOURCE_FILE)
-if (NOT SCRIPT_API_BINARY_FILE)
+endif()
+if(NOT SCRIPT_API_BINARY_FILE)
     message(FATAL_ERROR "Script needs SCRIPT_API_BINARY_FILE defined")
-endif (NOT SCRIPT_API_BINARY_FILE)
-if (NOT SCRIPT_API_FILE)
+endif()
+if(NOT SCRIPT_API_FILE)
     message(FATAL_ERROR "Script needs SCRIPT_API_FILE defined")
-endif (NOT SCRIPT_API_FILE)
-if (NOT APIUC)
+endif()
+if(NOT APIUC)
     message(FATAL_ERROR "Script needs APIUC defined")
-endif (NOT APIUC)
-if (NOT APILC)
+endif()
+if(NOT APILC)
     message(FATAL_ERROR "Script needs APILC defined")
-endif (NOT APILC)
+endif()
 
 macro(dump_fileheader)
     get_filename_component(SCRIPT_API_FILE_NAME "${SCRIPT_API_FILE}" NAME)
     string(APPEND SQUIRREL_EXPORT "\n#include \"../${SCRIPT_API_FILE_NAME}\"")
-    if (NOT "${APIUC}" STREQUAL "Template")
+    if(NOT "${APIUC}" STREQUAL "Template")
         string(REPLACE "script_" "template_" SCRIPT_API_FILE_NAME "${SCRIPT_API_FILE_NAME}")
         string(APPEND SQUIRREL_EXPORT "\n#include \"../template/${SCRIPT_API_FILE_NAME}.sq\"")
-    endif (NOT "${APIUC}" STREQUAL "Template")
-endmacro(dump_fileheader)
+    endif()
+endmacro()
 
 macro(dump_class_templates NAME)
     string(REGEX REPLACE "^Script" "" REALNAME ${NAME})
@@ -32,9 +32,9 @@ macro(dump_class_templates NAME)
     string(APPEND SQUIRREL_EXPORT "\n	template <> inline ${NAME} &GetParam(ForceType<${NAME} &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(${NAME} *)instance; }")
     string(APPEND SQUIRREL_EXPORT "\n	template <> inline const ${NAME} *GetParam(ForceType<const ${NAME} *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (${NAME} *)instance; }")
     string(APPEND SQUIRREL_EXPORT "\n	template <> inline const ${NAME} &GetParam(ForceType<const ${NAME} &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(${NAME} *)instance; }")
-    if ("${NAME}" STREQUAL "ScriptEvent")
+    if("${NAME}" STREQUAL "ScriptEvent")
         string(APPEND SQUIRREL_EXPORT "\n	template <> inline int Return<${NAME} *>(HSQUIRRELVM vm, ${NAME} *res) { if (res == nullptr) { sq_pushnull(vm); return 1; } Squirrel::CreateClassInstanceVM(vm, \"${REALNAME}\", res, nullptr, DefSQDestructorCallback<${NAME}>, true); return 1; }")
-    elseif ("${NAME}" STREQUAL "ScriptText")
+    elseif("${NAME}" STREQUAL "ScriptText")
         string(APPEND SQUIRREL_EXPORT "\n")
         string(APPEND SQUIRREL_EXPORT "\n	template <> inline Text *GetParam(ForceType<Text *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) {")
         string(APPEND SQUIRREL_EXPORT "\n		if (sq_gettype(vm, index) == OT_INSTANCE) {")
@@ -45,10 +45,10 @@ macro(dump_class_templates NAME)
         string(APPEND SQUIRREL_EXPORT "\n		}")
         string(APPEND SQUIRREL_EXPORT "\n		return nullptr;")
         string(APPEND SQUIRREL_EXPORT "\n	}")
-    else ()
+    else()
         string(APPEND SQUIRREL_EXPORT "\n	template <> inline int Return<${NAME} *>(HSQUIRRELVM vm, ${NAME} *res) { if (res == nullptr) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, \"${REALNAME}\", res, nullptr, DefSQDestructorCallback<${NAME}>, true); return 1; }")
-    endif ()
-endmacro(dump_class_templates)
+    endif()
+endmacro()
 
 macro(reset_reader)
     unset(ENUMS)
@@ -63,7 +63,7 @@ macro(reset_reader)
     unset(START_SQUIRREL_DEFINE_ON_NEXT_LINE)
     set(CLS_LEVEL 0)
     unset(CLS_IN_API)
-endmacro(reset_reader)
+endmacro()
 
 reset_reader()
 
@@ -71,80 +71,80 @@ file(STRINGS "${SCRIPT_API_FILE}" SOURCE_LINES)
 
 foreach(LINE IN LISTS SOURCE_LINES)
     # Ignore special doxygen blocks
-    if ("${LINE}" MATCHES "^#ifndef DOXYGEN_API")
+    if("${LINE}" MATCHES "^#ifndef DOXYGEN_API")
         set(DOXYGEN_SKIP "next")
         continue()
-    endif ()
-    if ("${LINE}" MATCHES "^#ifdef DOXYGEN_API")
+    endif()
+    if("${LINE}" MATCHES "^#ifdef DOXYGEN_API")
         set(DOXYGEN_SKIP "true")
         continue()
-    endif ()
-    if ("${LINE}" MATCHES "^#endif /\\* DOXYGEN_API \\*/")
+    endif()
+    if("${LINE}" MATCHES "^#endif /\\* DOXYGEN_API \\*/")
         unset(DOXYGEN_SKIP)
         continue()
-    endif ()
-    if ("${LINE}" MATCHES "^#else")
-        if ("${DOXYGEN_SKIP}" STREQUAL "next")
+    endif()
+    if("${LINE}" MATCHES "^#else")
+        if("${DOXYGEN_SKIP}" STREQUAL "next")
             set(DOXYGEN_SKIP "true")
         else()
             unset(DOXYGEN_SKIP)
         endif()
         continue()
-    endif ()
-    if ("${DOXYGEN_SKIP}" STREQUAL "true")
+    endif()
+    if("${DOXYGEN_SKIP}" STREQUAL "true")
         continue()
     endif()
 
-    if ("${LINE}" MATCHES "^([	 ]*)\\* @api (.*)$")
+    if("${LINE}" MATCHES "^([	 ]*)\\* @api (.*)$")
         set(LINE ${CMAKE_MATCH_2})
         # By default, classes are not selected
-        if (NOT CLS_LEVEL)
+        if(NOT CLS_LEVEL)
             set(API_SELECTED FALSE)
-        endif (NOT CLS_LEVEL)
+        endif()
 
-        if ("${APIUC}" STREQUAL "Template")
+        if("${APIUC}" STREQUAL "Template")
             set(API_SELECTED TRUE)
-            if ("${LINE}" STREQUAL "none" OR "${LINE}" STREQUAL "-all")
+            if("${LINE}" STREQUAL "none" OR "${LINE}" STREQUAL "-all")
                 set(API_SELECTED FALSE)
-            endif ("${LINE}" STREQUAL "none" OR "${LINE}" STREQUAL "-all")
+            endif()
             continue()
-        endif("${APIUC}" STREQUAL "Template")
+        endif()
 
-        if ("${LINE}" STREQUAL "none" OR "${LINE}" STREQUAL "-all")
+        if("${LINE}" STREQUAL "none" OR "${LINE}" STREQUAL "-all")
             set(API_SELECTED FALSE)
-        elseif ("${LINE}" MATCHES "-${APILC}")
+        elseif("${LINE}" MATCHES "-${APILC}")
             set(API_SELECTED FALSE)
-        elseif ("${LINE}" MATCHES "${APILC}")
+        elseif("${LINE}" MATCHES "${APILC}")
             set(API_SELECTED TRUE)
-        endif ()
+        endif()
         continue()
-    endif ("${LINE}" MATCHES "^([	 ]*)\\* @api (.*)$")
+    endif()
 
     # Remove the old squirrel stuff
-    if ("${LINE}" MATCHES "#ifdef DEFINE_SQUIRREL_CLASS")
+    if("${LINE}" MATCHES "#ifdef DEFINE_SQUIRREL_CLASS")
         set(SQUIRREL_STUFF TRUE)
         continue()
-    endif ("${LINE}" MATCHES "#ifdef DEFINE_SQUIRREL_CLASS")
-    if ("${LINE}" MATCHES "^#endif /\\* DEFINE_SQUIRREL_CLASS \\*/")
+    endif()
+    if("${LINE}" MATCHES "^#endif /\\* DEFINE_SQUIRREL_CLASS \\*/")
         unset(SQUIRREL_STUFF)
         continue()
-    endif ("${LINE}" MATCHES "^#endif /\\* DEFINE_SQUIRREL_CLASS \\*/")
-    if (SQUIRREL_STUFF)
+    endif()
+    if(SQUIRREL_STUFF)
         continue()
-    endif (SQUIRREL_STUFF)
+    endif()
 
     # Ignore forward declarations of classes
-    if ("${LINE}" MATCHES "^(	*)class(.*);")
+    if("${LINE}" MATCHES "^(	*)class(.*);")
         continue()
-    endif ("${LINE}" MATCHES "^(	*)class(.*);")
+    endif()
 
     # We only want to have public functions exported for now
-    if ("${LINE}" MATCHES "^(	*)class (.*) (: public|: protected|: private|:) ([^ ]*)")
-        if (NOT CLS_LEVEL)
-            if (NOT DEFINED API_SELECTED)
+    if("${LINE}" MATCHES "^(	*)class (.*) (: public|: protected|: private|:) ([^ ]*)")
+        if(NOT CLS_LEVEL)
+            if(NOT DEFINED API_SELECTED)
                 message(WARNING "Class '${CMAKE_MATCH_2}' has no @api. It won't be published to any API.")
                 set(API_SELECTED FALSE)
-            endif (NOT DEFINED API_SELECTED)
+            endif()
             unset(IS_PUBLIC)
             unset(CLS_PARAM_0)
             set(CLS_PARAM_1 1)
@@ -153,132 +153,132 @@ foreach(LINE IN LISTS SOURCE_LINES)
             unset(API_SELECTED)
             set(CLS "${CMAKE_MATCH_2}")
             set(SUPER_CLS "${CMAKE_MATCH_4}")
-        elseif (CLS_LEVEL EQUAL 1)
-            if (NOT DEFINED API_SELECTED)
+        elseif(CLS_LEVEL EQUAL 1)
+            if(NOT DEFINED API_SELECTED)
                 set(API_SELECTED ${CLS_IN_API})
-            endif (NOT API_SELECTED)
+            endif()
 
-            if (API_SELECTED)
+            if(API_SELECTED)
                 list(APPEND STRUCTS "${CLS}::${CMAKE_MATCH_2}")
-            endif (API_SELECTED)
+            endif()
             unset(API_SELECTED)
-        endif ()
+        endif()
         math(EXPR CLS_LEVEL "${CLS_LEVEL} + 1")
         continue()
-    endif ("${LINE}" MATCHES "^(	*)class (.*) (: public|: protected|: private|:) ([^ ]*)")
-    if ("${LINE}" MATCHES "^(	*)public")
-        if (CLS_LEVEL EQUAL 1)
+    endif()
+    if("${LINE}" MATCHES "^(	*)public")
+        if(CLS_LEVEL EQUAL 1)
             set(IS_PUBLIC TRUE)
-        endif (CLS_LEVEL EQUAL 1)
+        endif()
         continue()
-    endif ("${LINE}" MATCHES "^(	*)public")
-    if ("${LINE}" MATCHES "^(	*)protected")
-        if (CLS_LEVEL EQUAL 1)
+    endif()
+    if("${LINE}" MATCHES "^(	*)protected")
+        if(CLS_LEVEL EQUAL 1)
             unset(IS_PUBLIC)
-        endif (CLS_LEVEL EQUAL 1)
+        endif()
         continue()
-    endif ("${LINE}" MATCHES "^(	*)protected")
-    if ("${LINE}" MATCHES "^(	*)private")
-        if (CLS_LEVEL EQUAL 1)
+    endif()
+    if("${LINE}" MATCHES "^(	*)private")
+        if(CLS_LEVEL EQUAL 1)
             unset(IS_PUBLIC)
-        endif (CLS_LEVEL EQUAL 1)
+        endif()
         continue()
-    endif ("${LINE}" MATCHES "^(	*)private")
+    endif()
 
     # Ignore the comments
-    if ("${LINE}" MATCHES "^#")
+    if("${LINE}" MATCHES "^#")
         continue()
-    endif ("${LINE}" MATCHES "^#")
-    if ("${LINE}" MATCHES "/\\*.*\\*/")
+    endif()
+    if("${LINE}" MATCHES "/\\*.*\\*/")
         unset(COMMENT)
         continue()
-    endif ("${LINE}" MATCHES "/\\*.*\\*/")
-    if ("${LINE}" MATCHES "/\\*")
+    endif()
+    if("${LINE}" MATCHES "/\\*")
         set(COMMENT TRUE)
         continue()
-    endif ("${LINE}" MATCHES "/\\*")
-    if ("${LINE}" MATCHES "\\*/")
+    endif()
+    if("${LINE}" MATCHES "\\*/")
         unset(COMMENT)
         continue()
-    endif ("${LINE}" MATCHES "\\*/")
-    if (COMMENT)
+    endif()
+    if(COMMENT)
         continue()
-    endif (COMMENT)
+    endif()
 
     # We need to make specialized conversions for structs
-    if ("${LINE}" MATCHES "^(	*)struct ([^ ]*)")
+    if("${LINE}" MATCHES "^(	*)struct ([^ ]*)")
         math(EXPR CLS_LEVEL "${CLS_LEVEL} + 1")
 
         # Check if we want to publish this struct
-        if (NOT DEFINED API_SELECTED)
+        if(NOT DEFINED API_SELECTED)
             set(API_SELECTED ${CLS_IN_API})
-        endif (NOT DEFINED API_SELECTED)
-        if (NOT API_SELECTED)
+        endif()
+        if(NOT API_SELECTED)
             unset(API_SELECTED)
             continue()
-        endif (NOT API_SELECTED)
+        endif()
         unset(API_SELECTED)
 
-        if (NOT IS_PUBLIC OR NOT CLS_LEVEL EQUAL 1)
+        if(NOT IS_PUBLIC OR NOT CLS_LEVEL EQUAL 1)
             continue()
-        endif (NOT IS_PUBLIC OR NOT CLS_LEVEL EQUAL 1)
+        endif()
 
         list(APPEND STRUCTS "${CLS}::${CMAKE_MATCH_2}")
         continue()
-    endif ("${LINE}" MATCHES "^(	*)struct ([^ ]*)")
+    endif()
 
     # We need to make specialized conversions for enums
-    if ("${LINE}" MATCHES "^(	*)enum ([^ ]*)")
+    if("${LINE}" MATCHES "^(	*)enum ([^ ]*)")
         math(EXPR CLS_LEVEL "${CLS_LEVEL} + 1")
 
         # Check if we want to publish this enum
-        if (NOT DEFINED API_SELECTED)
+        if(NOT DEFINED API_SELECTED)
             set(API_SELECTED ${CLS_IN_API})
-        endif (NOT DEFINED API_SELECTED)
-        if (NOT API_SELECTED)
+        endif()
+        if(NOT API_SELECTED)
             unset(API_SELECTED)
             continue()
-        endif (NOT API_SELECTED)
+        endif()
         unset(API_SELECTED)
 
-        if (NOT IS_PUBLIC)
+        if(NOT IS_PUBLIC)
             continue()
-        endif (NOT IS_PUBLIC)
+        endif()
 
         set(IN_ENUM TRUE)
         list(APPEND ENUMS "${CLS}::${CMAKE_MATCH_2}")
         continue()
-    endif ("${LINE}" MATCHES "^(	*)enum ([^ ]*)")
+    endif()
 
     # Maybe the end of the class, if so we can start with the Squirrel export pretty soon
-    if ("${LINE}" MATCHES "};")
+    if("${LINE}" MATCHES "};")
         math(EXPR CLS_LEVEL "${CLS_LEVEL} - 1")
-        if (CLS_LEVEL)
+        if(CLS_LEVEL)
             unset(IN_ENUM)
             continue()
-        endif (CLS_LEVEL)
+        endif()
 
-        if (CLS)
+        if(CLS)
             set(START_SQUIRREL_DEFINE_ON_NEXT_LINE TRUE)
-        endif (CLS)
+        endif()
         continue()
-    endif ("${LINE}" MATCHES "};")
+    endif()
 
     # Empty/white lines. When we may do the Squirrel export, do that export.
-    if ("${LINE}" MATCHES "^([ 	]*)$")
-        if (NOT START_SQUIRREL_DEFINE_ON_NEXT_LINE)
+    if("${LINE}" MATCHES "^([ 	]*)$")
+        if(NOT START_SQUIRREL_DEFINE_ON_NEXT_LINE)
             continue()
-        endif (NOT START_SQUIRREL_DEFINE_ON_NEXT_LINE)
+        endif()
 
-        if (NOT CLS_IN_API)
+        if(NOT CLS_IN_API)
             reset_reader()
             continue()
-        endif (NOT CLS_IN_API)
+        endif()
 
-        if (NOT HAS_FILEHEADER)
+        if(NOT HAS_FILEHEADER)
             dump_fileheader()
             set(HAS_FILEHEADER TRUE)
-        endif (NOT HAS_FILEHEADER)
+        endif()
 
         unset(IS_PUBLIC)
         unset(NAMESPACE_OPENED)
@@ -288,38 +288,38 @@ foreach(LINE IN LISTS SOURCE_LINES)
 
         string(APPEND SQUIRREL_EXPORT "\n")
 
-        if ("${APIUC}" STREQUAL "Template")
+        if("${APIUC}" STREQUAL "Template")
             # First check whether we have enums to print
-            if (DEFINED ENUMS)
-                if (NOT NAMESPACE_OPENED)
+            if(DEFINED ENUMS)
+                if(NOT NAMESPACE_OPENED)
                     string(APPEND SQUIRREL_EXPORT "\nnamespace SQConvert {")
                     set(NAMESPACE_OPENED TRUE)
-                endif (NOT NAMESPACE_OPENED)
+                endif()
                 string(APPEND SQUIRREL_EXPORT "\n	/* Allow enums to be used as Squirrel parameters */")
                 foreach(ENUM IN LISTS ENUMS)
                     string(APPEND SQUIRREL_EXPORT "\n	template <> inline ${ENUM} GetParam(ForceType<${ENUM}>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (${ENUM})tmp; }")
                     string(APPEND SQUIRREL_EXPORT "\n	template <> inline int Return<${ENUM}>(HSQUIRRELVM vm, ${ENUM} res) { sq_pushinteger(vm, (int32)res); return 1; }")
-                endforeach(ENUM)
-            endif (DEFINED ENUMS)
+                endforeach()
+            endif()
 
             # Then check whether we have structs/classes to print
-            if (DEFINED STRUCTS)
-                if (NOT NAMESPACE_OPENED)
+            if(DEFINED STRUCTS)
+                if(NOT NAMESPACE_OPENED)
                     string(APPEND SQUIRREL_EXPORT "\nnamespace SQConvert {")
                     set(NAMESPACE_OPENED TRUE)
-                endif (NOT NAMESPACE_OPENED)
+                endif()
                 string(APPEND SQUIRREL_EXPORT "\n	/* Allow inner classes/structs to be used as Squirrel parameters */")
                 foreach(STRUCT IN LISTS STRUCTS)
                     dump_class_templates(${STRUCT})
-                endforeach(STRUCT)
-            endif (DEFINED STRUCTS)
+                endforeach()
+            endif()
 
-            if (NOT NAMESPACE_OPENED)
+            if(NOT NAMESPACE_OPENED)
                 string(APPEND SQUIRREL_EXPORT "\nnamespace SQConvert {")
                 set(NAMESPACE_OPENED TRUE)
-            else (NOT NAMESPACE_OPENED)
+            else()
                 string(APPEND SQUIRREL_EXPORT "\n")
-            endif (NOT NAMESPACE_OPENED)
+            endif()
             string(APPEND SQUIRREL_EXPORT "\n	/* Allow ${CLS} to be used as Squirrel parameter */")
             dump_class_templates(${CLS})
 
@@ -327,7 +327,7 @@ foreach(LINE IN LISTS SOURCE_LINES)
 
             reset_reader()
             continue()
-        endif ("${APIUC}" STREQUAL "Template")
+        endif()
 
         string(APPEND SQUIRREL_EXPORT "\n")
         string(APPEND SQUIRREL_EXPORT "\ntemplate <> const char *GetClassName<${CLS}, ST_${APIUC}>() { return \"${API_CLS}\"; }")
@@ -337,61 +337,61 @@ foreach(LINE IN LISTS SOURCE_LINES)
         string(APPEND SQUIRREL_EXPORT "\nvoid SQ${API_CLS}_Register(Squirrel *engine)")
         string(APPEND SQUIRREL_EXPORT "\n{")
         string(APPEND SQUIRREL_EXPORT "\n	DefSQClass<${CLS}, ST_${APIUC}> SQ${API_CLS}(\"${API_CLS}\");")
-        if ("${SUPER_CLS}" STREQUAL "Text" OR "${SUPER_CLS}" STREQUAL "ScriptObject" OR "${SUPER_CLS}" STREQUAL "AIAbstractiveList::Valuator")
+        if("${SUPER_CLS}" STREQUAL "Text" OR "${SUPER_CLS}" STREQUAL "ScriptObject" OR "${SUPER_CLS}" STREQUAL "AIAbstractiveList::Valuator")
             string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.PreRegister(engine);")
-        else ("${SUPER_CLS}" STREQUAL "Text" OR "${SUPER_CLS}" STREQUAL "ScriptObject" OR "${SUPER_CLS}" STREQUAL "AIAbstractiveList::Valuator")
+        else()
             string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.PreRegister(engine, \"${API_SUPER_CLS}\");")
-        endif ("${SUPER_CLS}" STREQUAL "Text" OR "${SUPER_CLS}" STREQUAL "ScriptObject" OR "${SUPER_CLS}" STREQUAL "AIAbstractiveList::Valuator")
-        if (NOT "${SUPER_CLS}" STREQUAL "ScriptEvent")
-            if ("${CLS_PARAM_2}" STREQUAL "v")
+        endif()
+        if(NOT "${SUPER_CLS}" STREQUAL "ScriptEvent")
+            if("${CLS_PARAM_2}" STREQUAL "v")
                 string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.AddSQAdvancedConstructor(engine);")
-            else ("${CLS_PARAM_2}" STREQUAL "v")
+            else()
                 string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.AddConstructor<void (${CLS}::*)(${CLS_PARAM_0}), ${CLS_PARAM_1}>(engine, \"${CLS_PARAM_2}\");")
-            endif ("${CLS_PARAM_2}" STREQUAL "v")
-        endif (NOT "${SUPER_CLS}" STREQUAL "ScriptEvent")
+            endif()
+        endif()
         string(APPEND SQUIRREL_EXPORT "\n")
 
         # Enum values
         set(MLEN 0)
         foreach(ENUM_VALUE IN LISTS ENUM_VALUES)
             string(LENGTH "${ENUM_VALUE}" LEN)
-            if (MLEN LESS LEN)
+            if(MLEN LESS LEN)
                 set(MLEN ${LEN})
-            endif (MLEN LESS LEN)
-        endforeach(ENUM_VALUE)
+            endif()
+        endforeach()
         foreach(ENUM_VALUE IN LISTS ENUM_VALUES)
             string(LENGTH "${ENUM_VALUE}" LEN)
             math(EXPR LEN "${MLEN} - ${LEN}")
             unset(SPACES)
             foreach(i RANGE ${LEN})
                 string(APPEND SPACES " ")
-            endforeach(i)
+            endforeach()
             string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.DefSQConst(engine, ${CLS}::${ENUM_VALUE},${SPACES}\"${ENUM_VALUE}\");")
-        endforeach(ENUM_VALUE)
-        if (MLEN)
+        endforeach()
+        if(MLEN)
             string(APPEND SQUIRREL_EXPORT "\n")
-        endif (MLEN)
+        endif()
 
         # Const values
         set(MLEN 0)
         foreach(CONST_VALUE IN LISTS CONST_VALUES)
             string(LENGTH "${CONST_VALUE}" LEN)
-            if (MLEN LESS LEN)
+            if(MLEN LESS LEN)
                 set(MLEN ${LEN})
-            endif (MLEN LESS LEN)
-        endforeach(CONST_VALUE)
+            endif()
+        endforeach()
         foreach(CONST_VALUE IN LISTS CONST_VALUES)
             string(LENGTH "${CONST_VALUE}" LEN)
             math(EXPR LEN "${MLEN} - ${LEN}")
             unset(SPACES)
             foreach(i RANGE ${LEN})
                 string(APPEND SPACES " ")
-            endforeach(i)
+            endforeach()
             string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.DefSQConst(engine, ${CLS}::${CONST_VALUE},${SPACES}\"${CONST_VALUE}\");")
-        endforeach(CONST_VALUE)
-        if (MLEN)
+        endforeach()
+        if(MLEN)
             string(APPEND SQUIRREL_EXPORT "\n")
-        endif (MLEN)
+        endif()
 
         # Mapping of OTTD strings to errors
         set(MLEN 0)
@@ -399,10 +399,10 @@ foreach(LINE IN LISTS SOURCE_LINES)
             string(REPLACE ":" ";" ENUM_STRING_TO_ERROR "${ENUM_STRING_TO_ERROR}")
             list(GET ENUM_STRING_TO_ERROR 0 ENUM_STRING)
             string(LENGTH "${ENUM_STRING}" LEN)
-            if (MLEN LESS LEN)
+            if(MLEN LESS LEN)
                 set(MLEN ${LEN})
-            endif (MLEN LESS LEN)
-        endforeach(ENUM_STRING_TO_ERROR)
+            endif()
+        endforeach()
         foreach(ENUM_STRING_TO_ERROR IN LISTS ENUM_STRING_TO_ERRORS)
             string(REPLACE ":" ";" ENUM_STRING_TO_ERROR "${ENUM_STRING_TO_ERROR}")
             list(GET ENUM_STRING_TO_ERROR 0 ENUM_STRING)
@@ -412,33 +412,33 @@ foreach(LINE IN LISTS SOURCE_LINES)
             unset(SPACES)
             foreach(i RANGE ${LEN})
                 string(APPEND SPACES " ")
-            endforeach(i)
+            endforeach()
             string(APPEND SQUIRREL_EXPORT "\n	ScriptError::RegisterErrorMap(${ENUM_STRING},${SPACES}${CLS}::${ENUM_ERROR});")
-        endforeach(ENUM_STRING_TO_ERROR)
-        if (MLEN)
+        endforeach()
+        if(MLEN)
             string(APPEND SQUIRREL_EXPORT "\n")
-        endif (MLEN)
+        endif()
 
         # Mapping of errors to human 'readable' strings.
         set(MLEN 0)
         foreach(ENUM_ERROR_TO_STRING IN LISTS ENUM_ERROR_TO_STRINGS)
             string(LENGTH "${ENUM_ERROR_TO_STRING}" LEN)
-            if (MLEN LESS LEN)
+            if(MLEN LESS LEN)
                 set(MLEN ${LEN})
-            endif (MLEN LESS LEN)
-        endforeach(ENUM_ERROR_TO_STRING)
+            endif()
+        endforeach()
         foreach(ENUM_ERROR_TO_STRING IN LISTS ENUM_ERROR_TO_STRINGS)
             string(LENGTH "${ENUM_ERROR_TO_STRING}" LEN)
             math(EXPR LEN "${MLEN} - ${LEN}")
             unset(SPACES)
             foreach(i RANGE ${LEN})
                 string(APPEND SPACES " ")
-            endforeach(i)
+            endforeach()
             string(APPEND SQUIRREL_EXPORT "\n	ScriptError::RegisterErrorMapString(${CLS}::${ENUM_ERROR_TO_STRING},${SPACES}\"${ENUM_ERROR_TO_STRING}\");")
-        endforeach(ENUM_ERROR_TO_STRING)
-        if (MLEN)
+        endforeach()
+        if(MLEN)
             string(APPEND SQUIRREL_EXPORT "\n")
-        endif (MLEN)
+        endif()
 
         # Static methods
         set(MLEN 0)
@@ -446,10 +446,10 @@ foreach(LINE IN LISTS SOURCE_LINES)
             string(REPLACE ":" ";" STATIC_METHOD "${STATIC_METHOD}")
             list(GET STATIC_METHOD 0 FUNCNAME)
             string(LENGTH "${FUNCNAME}" LEN)
-            if (MLEN LESS LEN)
+            if(MLEN LESS LEN)
                 set(MLEN ${LEN})
-            endif (MLEN LESS LEN)
-        endforeach(STATIC_METHOD)
+            endif()
+        endforeach()
         foreach(STATIC_METHOD IN LISTS STATIC_METHODS)
             string(REPLACE ":" ";" STATIC_METHOD "${STATIC_METHOD}")
             list(GET STATIC_METHOD 0 FUNCNAME)
@@ -457,26 +457,26 @@ foreach(LINE IN LISTS SOURCE_LINES)
             list(GET STATIC_METHOD 2 TYPES)
             string(LENGTH "${FUNCNAME}" LEN)
             math(EXPR LEN "${MLEN} - ${LEN}")
-            if ("${TYPES}" STREQUAL "v")
-                if (LEN GREATER 8)
+            if("${TYPES}" STREQUAL "v")
+                if(LEN GREATER 8)
                     math(EXPR LEN "${LEN} - 8")
-                else (LEN GREATER 8)
+                else()
                     set(LEN 0)
-                endif (LEN GREATER 8)
-            endif ("${TYPES}" STREQUAL "v")
+                endif()
+            endif()
             unset(SPACES)
             foreach(i RANGE ${LEN})
                 string(APPEND SPACES " ")
-            endforeach(i)
-            if ("${TYPES}" STREQUAL "v")
+            endforeach()
+            if("${TYPES}" STREQUAL "v")
                 string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.DefSQAdvancedStaticMethod(engine, &${CLS}::${FUNCNAME},${SPACES}\"${FUNCNAME}\");")
-            else ("${TYPES}" STREQUAL "v")
+            else()
                 string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.DefSQStaticMethod(engine, &${CLS}::${FUNCNAME},${SPACES}\"${FUNCNAME}\",${SPACES}${ARGC}, \"${TYPES}\");")
-            endif ("${TYPES}" STREQUAL "v")
-        endforeach(STATIC_METHOD)
-        if (MLEN)
+            endif()
+        endforeach()
+        if(MLEN)
             string(APPEND SQUIRREL_EXPORT "\n")
-        endif (MLEN)
+        endif()
 
         # Non-static methods
         set(MLEN 0)
@@ -484,10 +484,10 @@ foreach(LINE IN LISTS SOURCE_LINES)
             string(REPLACE ":" ";" METHOD "${METHOD}")
             list(GET METHOD 0 FUNCNAME)
             string(LENGTH "${FUNCNAME}" LEN)
-            if (MLEN LESS LEN)
+            if(MLEN LESS LEN)
                 set(MLEN ${LEN})
-            endif (MLEN LESS LEN)
-        endforeach(METHOD)
+            endif()
+        endforeach()
         foreach(METHOD IN LISTS METHODS)
             string(REPLACE ":" ";" METHOD "${METHOD}")
             list(GET METHOD 0 FUNCNAME)
@@ -495,26 +495,26 @@ foreach(LINE IN LISTS SOURCE_LINES)
             list(GET METHOD 2 TYPES)
             string(LENGTH "${FUNCNAME}" LEN)
             math(EXPR LEN "${MLEN} - ${LEN}")
-            if ("${TYPES}" STREQUAL "v")
-                if (LEN GREATER 8)
+            if("${TYPES}" STREQUAL "v")
+                if(LEN GREATER 8)
                     math(EXPR LEN "${LEN} - 8")
-                else (LEN GREATER 8)
+                else()
                     set(LEN 0)
-                endif (LEN GREATER 8)
-            endif ("${TYPES}" STREQUAL "v")
+                endif()
+            endif()
             unset(SPACES)
             foreach(i RANGE ${LEN})
                 string(APPEND SPACES " ")
-            endforeach(i)
-            if ("${TYPES}" STREQUAL "v")
+            endforeach()
+            if("${TYPES}" STREQUAL "v")
                 string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.DefSQAdvancedMethod(engine, &${CLS}::${FUNCNAME},${SPACES}\"${FUNCNAME}\");")
-            else ("${TYPES}" STREQUAL "v")
+            else()
                 string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.DefSQMethod(engine, &${CLS}::${FUNCNAME},${SPACES}\"${FUNCNAME}\",${SPACES}${ARGC}, \"${TYPES}\");")
-            endif ("${TYPES}" STREQUAL "v")
-        endforeach(METHOD)
-        if (MLEN)
+            endif()
+        endforeach()
+        if(MLEN)
             string(APPEND SQUIRREL_EXPORT "\n")
-        endif (MLEN)
+        endif()
 
         string(APPEND SQUIRREL_EXPORT "\n	SQ${API_CLS}.PostRegister(engine);")
         string(APPEND SQUIRREL_EXPORT "\n}")
@@ -522,64 +522,64 @@ foreach(LINE IN LISTS SOURCE_LINES)
         reset_reader()
 
         continue()
-    endif ("${LINE}" MATCHES "^([ 	]*)$")
+    endif()
 
     # Skip non-public functions
-    if (NOT IS_PUBLIC)
+    if(NOT IS_PUBLIC)
         continue()
-    endif (NOT IS_PUBLIC)
+    endif()
 
     # Add enums
-    if (IN_ENUM)
+    if(IN_ENUM)
         string(REGEX MATCH "([^,	 ]+)" ENUM_VALUE "${LINE}")
         list(APPEND ENUM_VALUES "${ENUM_VALUE}")
 
         # Check if this a special error enum
         list(GET ENUMS -1 ENUM)
-        if ("${ENUM}" MATCHES ".*::ErrorMessages")
+        if("${ENUM}" MATCHES ".*::ErrorMessages")
             # syntax:
             # enum ErrorMessages {
             #	ERR_SOME_ERROR,	// [STR_ITEM1, STR_ITEM2, ...]
             # }
 
             # Set the mappings
-            if ("${LINE}" MATCHES "\\[(.*)\\]")
+            if("${LINE}" MATCHES "\\[(.*)\\]")
                 string(REGEX REPLACE "[ 	]" "" MAPPINGS "${CMAKE_MATCH_1}")
                 string(REPLACE "," ";" MAPPINGS "${MAPPINGS}")
 
                 foreach(MAPPING IN LISTS MAPPINGS)
                     list(APPEND ENUM_STRING_TO_ERRORS "${MAPPING}:${ENUM_VALUE}")
-                endforeach(MAPPING)
+                endforeach()
 
                 list(APPEND ENUM_ERROR_TO_STRINGS "${ENUM_VALUE}")
-            endif ("${LINE}" MATCHES "\\[(.*)\\]")
-        endif ("${ENUM}" MATCHES ".*::ErrorMessages")
+            endif()
+        endif()
         continue()
-    endif (IN_ENUM)
+    endif()
 
     # Add a const (non-enum) value
-    if ("${LINE}" MATCHES "^[ 	]*static const [^ ]+ ([^ ]+) = -?\\(?[^ ]*\\)?[^ ]+;")
+    if("${LINE}" MATCHES "^[ 	]*static const [^ ]+ ([^ ]+) = -?\\(?[^ ]*\\)?[^ ]+;")
         list(APPEND CONST_VALUES "${CMAKE_MATCH_1}")
         continue()
-    endif ("${LINE}" MATCHES "^[ 	]*static const [^ ]+ ([^ ]+) = -?\\(?[^ ]*\\)?[^ ]+;")
+    endif()
 
     # Add a method to the list
-    if ("${LINE}" MATCHES "^.*\\(.*\\).*$")
-        if (NOT CLS_LEVEL EQUAL 1)
+    if("${LINE}" MATCHES "^.*\\(.*\\).*$")
+        if(NOT CLS_LEVEL EQUAL 1)
             continue()
-        endif (NOT CLS_LEVEL EQUAL 1)
-        if ("${LINE}" MATCHES "~")
-            if (DEFINED API_SELECTED)
+        endif()
+        if("${LINE}" MATCHES "~")
+            if(DEFINED API_SELECTED)
                 message(WARNING "Destructor for '${CLS}' has @api. Tag ignored.")
                 unset(API_SELECTED)
-            endif (DEFINED API_SELECTED)
+            endif()
             continue()
-        endif ("${LINE}" MATCHES "~")
+        endif()
 
         unset(IS_STATIC)
-        if ("${LINE}" MATCHES "static")
+        if("${LINE}" MATCHES "static")
             set(IS_STATIC TRUE)
-        endif ("${LINE}" MATCHES "static")
+        endif()
 
         string(REGEX REPLACE "(virtual|static|const)[ 	]+" "" LINE "${LINE}")
         string(REGEX REPLACE "{.*" "" LINE "${LINE}")
@@ -593,75 +593,75 @@ foreach(LINE IN LISTS SOURCE_LINES)
         string(REGEX MATCH "([^ 	]+)( ([^ ]+))?" RESULT "${LINE}")
         set(FUNCTYPE "${CMAKE_MATCH_1}")
         set(FUNCNAME "${CMAKE_MATCH_3}")
-        if ("${FUNCTYPE}" STREQUAL "${CLS}" AND NOT FUNCNAME)
-            if (DEFINED API_SELECTED)
+        if("${FUNCTYPE}" STREQUAL "${CLS}" AND NOT FUNCNAME)
+            if(DEFINED API_SELECTED)
                 message(WARNING "Constructor for '${CLS}' has @api. Tag ignored.")
                 unset(API_SELECTED)
-            endif (DEFINED API_SELECTED)
+            endif()
             set(CLS_PARAM_0 "${PARAM_S}")
-            if (NOT PARAM_S)
+            if(NOT PARAM_S)
                 continue()
-            endif (NOT PARAM_S)
-        elseif (NOT FUNCNAME)
+            endif()
+        elseif(NOT FUNCNAME)
             continue()
-		endif ()
+		endif()
 
         string(REPLACE "," ";" PARAMS "${PARAM_S}")
-        if (IS_STATIC)
+        if(IS_STATIC)
             set(TYPES ".")
-        else (IS_STATIC)
+        else()
             set(TYPES "x")
-        endif (IS_STATIC)
+        endif()
 
         set(LEN 1)
         foreach(PARAM IN LISTS PARAMS)
             math(EXPR LEN "${LEN} + 1")
             string(STRIP "${PARAM}" PARAM)
-            if ("${PARAM}" MATCHES "\\*|&")
-                if ("${PARAM}" MATCHES "^char")
+            if("${PARAM}" MATCHES "\\*|&")
+                if("${PARAM}" MATCHES "^char")
                     # Many types can be converted to string, so use '.', not 's'. (handled by our glue code)
                     string(APPEND TYPES ".")
-                elseif ("${PARAM}" MATCHES "^void")
+                elseif("${PARAM}" MATCHES "^void")
                     string(APPEND TYPES "p")
-                elseif ("${PARAM}" MATCHES "^Array")
+                elseif("${PARAM}" MATCHES "^Array")
                     string(APPEND TYPES "a")
-                elseif ("${PARAM}" MATCHES "^struct Array")
+                elseif("${PARAM}" MATCHES "^struct Array")
                     string(APPEND TYPES "a")
-                elseif ("${PARAM}" MATCHES "^Text")
+                elseif("${PARAM}" MATCHES "^Text")
                     string(APPEND TYPES ".")
-                else ()
+                else()
                     string(APPEND TYPES "x")
-                endif ()
-            elseif ("${PARAM}" MATCHES "^bool")
+                endif()
+            elseif("${PARAM}" MATCHES "^bool")
                 string(APPEND TYPES "b")
-            elseif ("${PARAM}" MATCHES "^HSQUIRRELVM")
+            elseif("${PARAM}" MATCHES "^HSQUIRRELVM")
                 set(TYPES "v")
-            else ()
+            else()
                 string(APPEND TYPES "i")
-            endif ()
-        endforeach(PARAM)
+            endif()
+        endforeach()
 
         # Check if we want to publish this function
-        if (NOT DEFINED API_SELECTED)
+        if(NOT DEFINED API_SELECTED)
             set(API_SELECTED ${CLS_IN_API})
-        endif (NOT DEFINED API_SELECTED)
-        if (NOT API_SELECTED)
+        endif()
+        if(NOT API_SELECTED)
             unset(API_SELECTED)
             continue()
-        endif (NOT API_SELECTED)
+        endif()
         unset(API_SELECTED)
 
-        if ("${FUNCTYPE}" STREQUAL "${CLS}" AND NOT FUNCNAME)
+        if("${FUNCTYPE}" STREQUAL "${CLS}" AND NOT FUNCNAME)
             set(CLS_PARAM_1 ${LEN})
             set(CLS_PARAM_2 "${TYPES}")
-        elseif ("${FUNCNAME}" MATCHES "^_" AND NOT "${TYPES}" STREQUAL "v")
-        elseif (IS_STATIC)
+        elseif("${FUNCNAME}" MATCHES "^_" AND NOT "${TYPES}" STREQUAL "v")
+        elseif(IS_STATIC)
             list(APPEND STATIC_METHODS "${FUNCNAME}:${LEN}:${TYPES}")
-        else ()
+        else()
             list(APPEND METHODS "${FUNCNAME}:${LEN}:${TYPES}")
-        endif ()
+        endif()
         continue()
-    endif ("${LINE}" MATCHES "^.*\\(.*\\).*$")
-endforeach(LINE)
+    endif()
+endforeach()
 
 configure_file(${SCRIPT_API_SOURCE_FILE} ${SCRIPT_API_BINARY_FILE})
diff --git a/cmake/scripts/SquirrelIncludes.cmake b/cmake/scripts/SquirrelIncludes.cmake
index d6d8b8ec3..e64e2d25a 100644
--- a/cmake/scripts/SquirrelIncludes.cmake
+++ b/cmake/scripts/SquirrelIncludes.cmake
@@ -1,17 +1,17 @@
 cmake_minimum_required(VERSION 3.5)
 
-if (NOT INCLUDES_SOURCE_FILE)
+if(NOT INCLUDES_SOURCE_FILE)
     message(FATAL_ERROR "Script needs INCLUDES_SOURCE_FILE defined")
-endif (NOT INCLUDES_SOURCE_FILE)
-if (NOT INCLUDES_BINARY_FILE)
+endif()
+if(NOT INCLUDES_BINARY_FILE)
     message(FATAL_ERROR "Script needs INCLUDES_BINARY_FILE defined")
-endif (NOT INCLUDES_BINARY_FILE)
-if (NOT APILC)
+endif()
+if(NOT APILC)
     message(FATAL_ERROR "Script needs APILC defined")
-endif (NOT APILC)
-if (NOT APIUC)
+endif()
+if(NOT APIUC)
     message(FATAL_ERROR "Script needs APIUC defined")
-endif (NOT APIUC)
+endif()
 
 set(ARGC 1)
 set(ARG_READ NO)
@@ -21,32 +21,32 @@ set(ARG_READ NO)
 while(ARGC LESS CMAKE_ARGC)
     set(ARG ${CMAKE_ARGV${ARGC}})
 
-    if (ARG_READ)
+    if(ARG_READ)
         list(APPEND SCRIPT_API_BINARY_FILES "${ARG}")
-    endif (ARG_READ)
+    endif()
 
-    if (ARG STREQUAL "--")
+    if(ARG STREQUAL "--")
         set(ARG_READ YES)
-    endif (ARG STREQUAL "--")
+    endif()
 
     math(EXPR ARGC "${ARGC} + 1")
 endwhile()
 
 foreach(FILE IN LISTS SCRIPT_API_BINARY_FILES)
     file(STRINGS "${FILE}" LINES REGEX "^void SQ${APIUC}.*_Register\\(Squirrel \\*engine\\)$")
-    if (LINES)
+    if(LINES)
         string(REGEX REPLACE ".*api/${APILC}/(.*)" "#include \"\\1\"" FILE "${FILE}")
         list(APPEND SQUIRREL_INCLUDES "${FILE}")
         foreach(LINE IN LISTS LINES)
-            if ("${LINE}" MATCHES "SQ${APIUC}(List|Controller)_Register")
+            if("${LINE}" MATCHES "SQ${APIUC}(List|Controller)_Register")
                 continue()
-            endif ("${LINE}" MATCHES "SQ${APIUC}(List|Controller)_Register")
+            endif()
             string(REGEX REPLACE "^.*void " "	" LINE "${LINE}")
             string(REGEX REPLACE "Squirrel \\*" "" LINE "${LINE}")
             list(APPEND SQUIRREL_REGISTER "${LINE}")
-        endforeach(LINE)
-    endif (LINES)
-endforeach(FILE)
+        endforeach()
+    endif()
+endforeach()
 
 list(SORT SQUIRREL_INCLUDES)
 string(REPLACE ";" "\n" SQUIRREL_INCLUDES "${SQUIRREL_INCLUDES}")