Replace some SM cmake macros with builtin functions

Build/README.md

@@ -12,7 +12,7 @@ At first, you have to install CMake.
 All OSes
 ===
 
-The common way of installing CMake is to go to [CMake's download page](http://www.cmake.org/download/). At this time of writing, the latest versions are 3.3.0-rc3 and 3.2.3. Either version will work: the minimum version supported at this time is 2.8.12.
+The common way of installing CMake is to go to [CMake's download page](http://www.cmake.org/download/). At this time of writing, the latest version is 3.22.3. The minimum version supported at this time is 3.12.
 
 If this approach is used, consider using the binary distributions. Most should also provide a friendly GUI interface.
 

CMake/CMakeMacros.cmake

@@ -1,10 +1,3 @@
-# Borrowed from http://stackoverflow.com/a/3323227/445373
-function(sm_list_replace container index newvalue)
-  list(INSERT ${container} ${index} ${newvalue})
-  math(EXPR __INDEX "${index} + 1")
-  list(REMOVE_AT ${container} ${__INDEX})
-endfunction()
-
 function(sm_append_simple_target_property target property str)
   get_target_property(current_property ${target} ${property})
   if(current_property)
@@ -16,31 +9,6 @@ function(sm_append_simple_target_property target property str)
   endif()
 endfunction()
 
-# Borrowed from http://stackoverflow.com/a/7172941/445373 TODO: Upgrade to cmake
-# 3.x so that this function is not needed.
-function(sm_join values glue output)
-  string(REPLACE ";"
-                 "${glue}"
-                 _TMP_STR
-                 "${values}")
-  set(${output} "${_TMP_STR}" PARENT_SCOPE)
-endfunction()
-
-function(sm_add_compile_definition target def)
-  sm_append_simple_target_property(${target} COMPILE_DEFINITIONS ${def})
-endfunction()
-
-function(sm_add_compile_flag target flag)
-  get_target_property(current_property ${target} COMPILE_FLAGS)
-  if(current_property)
-    set(current_property "${current_property} ${flag}")
-    set_target_properties(${target}
-                          PROPERTIES COMPILE_FLAGS "${current_property}")
-  else()
-    set_target_properties(${target} PROPERTIES COMPILE_FLAGS ${flag})
-  endif()
-endfunction()
-
 function(sm_add_link_flag target flag)
   if(MSVC)
     # Use a modified form of sm_append_simple_target_property.
@@ -59,13 +27,11 @@ endfunction()
 function(disable_project_warnings projectName)
   if(NOT WITH_EXTERNAL_WARNINGS)
     if(MSVC)
-      sm_add_compile_flag(${projectName} "/W0")
+      target_compile_options(${projectName} PRIVATE "/W0")
     elseif(APPLE)
-      set_target_properties(
+      set_property(TARGET ${projectName} PROPERTY XCODE_ATTRIBUTE_GCC_WARN_INHIBIT_ALL_WARNINGS "YES")
-        ${projectName}
-        PROPERTIES XCODE_ATTRIBUTE_GCC_WARN_INHIBIT_ALL_WARNINGS "YES")
     else()
-      set_target_properties(${projectName} PROPERTIES COMPILE_FLAGS "-w")
+      target_compile_options(${projectName} PRIVATE "-w")
     endif()
   endif()
 endfunction()

CMake/SetupFfmpeg.cmake

@@ -10,7 +10,7 @@ set(SM_FFMPEG_SRC_LIST
     "${SM_EXTERN_DIR}"
     "/ffmpeg-linux-"
     "${SM_FFMPEG_VERSION}")
-sm_join("${SM_FFMPEG_SRC_LIST}" "" SM_FFMPEG_SRC_DIR)
+list(JOIN SM_FFMPEG_SRC_LIST "" SM_FFMPEG_SRC_DIR)
 set(SM_FFMPEG_CONFIGURE_EXE "${SM_FFMPEG_SRC_DIR}/configure")
 if(MINGW)
   # Borrow from http://stackoverflow.com/q/11845823 string(SUBSTRING

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.12)
 
 project(StepMania)
 

extern/CMakeProject-cppformat.cmake

@@ -21,15 +21,14 @@ disable_project_warnings("cppformat")
 target_include_directories("cppformat" PUBLIC "cppformat")
 
 if(MSVC)
-  sm_add_compile_definition("cppformat" _CRT_SECURE_NO_WARNINGS)
+  target_compile_definitions("cppformat" PRIVATE _CRT_SECURE_NO_WARNINGS)
 elseif(APPLE)
   set_target_properties("cppformat"
                         PROPERTIES XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD
                                    "${SM_CPP_STANDARD}"
                                    XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY
                                    "libc++")
-  sm_add_compile_flag("cppformat" "-std=${SM_CPP_STANDARD}")
+  target_compile_options("cppformat" PRIVATE "-std=${SM_CPP_STANDARD}" "-stdlib=libc++")
-  sm_add_compile_flag("cppformat" "-stdlib=libc++")
 else() # Unix
-  sm_add_compile_flag("cppformat" "-std=${SM_CPP_STANDARD}")
+  target_compile_options("cppformat" PRIVATE "-std=${SM_CPP_STANDARD}")
 endif()

extern/CMakeProject-glew.cmake

@@ -15,10 +15,10 @@ else()
 
   target_include_directories("glew" PUBLIC "glew-1.5.8/include")
 
-  sm_add_compile_definition("glew" GLEW_STATIC)
+  target_compile_definitions("glew" PRIVATE GLEW_STATIC)
 
   if(MSVC)
-    sm_add_compile_definition("glew" _MBCS)
+    target_compile_definitions("glew" PRIVATE _MBCS)
   endif(MSVC)
 
 endif()

extern/CMakeProject-ixwebsocket.cmake

@@ -109,32 +109,32 @@ set_property(TARGET "ixwebsocket" PROPERTY CXX_EXTENSIONS OFF)
 
 disable_project_warnings("ixwebsocket")
 
-sm_add_compile_definition("ixwebsocket" IXWEBSOCKET_USE_TLS)
+target_compile_definitions("ixwebsocket" PRIVATE IXWEBSOCKET_USE_TLS)
 
 if(APPLE)
-  sm_add_compile_definition("ixwebsocket" IXWEBSOCKET_USE_SECURE_TRANSPORT)
+  target_compile_definitions("ixwebsocket" PRIVATE IXWEBSOCKET_USE_SECURE_TRANSPORT)
   target_link_libraries(ixwebsocket "-framework foundation" "-framework security")
 elseif(WIN32)
-  sm_add_compile_definition("ixwebsocket" IXWEBSOCKET_USE_MBED_TLS)
+  target_compile_definitions("ixwebsocket" PRIVATE IXWEBSOCKET_USE_MBED_TLS)
-  sm_add_compile_definition("ixwebsocket" IXWEBSOCKET_USE_MBED_TLS_MIN_VERSION_3)
+  target_compile_definitions("ixwebsocket" PRIVATE IXWEBSOCKET_USE_MBED_TLS_MIN_VERSION_3)
   add_subdirectory("${MBEDTLS_DIR}" EXCLUDE_FROM_ALL)
   set_property(TARGET "mbedtls" PROPERTY FOLDER "External Libraries")
   set_property(TARGET "mbedcrypto" PROPERTY FOLDER "External Libraries")
   set_property(TARGET "mbedx509" PROPERTY FOLDER "External Libraries")
   target_link_libraries("ixwebsocket" mbedtls mbedcrypto mbedx509)
 else()
-  sm_add_compile_definition("ixwebsocket" IXWEBSOCKET_USE_OPEN_SSL)
+  target_compile_definitions("ixwebsocket" PRIVATE IXWEBSOCKET_USE_OPEN_SSL)
   find_package(OpenSSL REQUIRED)
   add_definitions(${OPENSSL_DEFINITIONS})
   target_include_directories(ixwebsocket PUBLIC ${OPENSSL_INCLUDE_DIR})
   target_link_libraries(ixwebsocket ${OPENSSL_LIBRARIES})
 endif()
 
-sm_add_compile_definition("ixwebsocket" IXWEBSOCKET_USE_ZLIB)
+target_compile_definitions("ixwebsocket" PRIVATE IXWEBSOCKET_USE_ZLIB)
 
 if(WIN32)
   target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi Crypt32)
-  sm_add_compile_definition(ixwebsocket _CRT_SECURE_NO_WARNINGS)
+  target_compile_definitions(ixwebsocket PRIVATE _CRT_SECURE_NO_WARNINGS)
 endif()
 
 if(UNIX)

extern/CMakeProject-jpeg.cmake

@@ -78,7 +78,7 @@ else()
   set_property(TARGET "jpeg" PROPERTY FOLDER "External Libraries")
 
   if(MSVC)
-    sm_add_compile_definition("jpeg" _CRT_SECURE_NO_WARNINGS)
+    target_compile_definitions("jpeg" PRIVATE _CRT_SECURE_NO_WARNINGS)
   endif(MSVC)
 
   target_include_directories("jpeg" PUBLIC "${JPEG_DIR}")

extern/CMakeProject-json.cmake

@@ -22,9 +22,9 @@ else()
   target_include_directories("jsoncpp" PUBLIC "jsoncpp")
 
   if(MSVC)
-    sm_add_compile_definition("jsoncpp" _CRT_SECURE_NO_WARNINGS)
+    target_compile_definitions("jsoncpp" PRIVATE _CRT_SECURE_NO_WARNINGS)
   elseif(APPLE)
     set_target_properties("jsoncpp" PROPERTIES XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
-    sm_add_compile_flag("jsoncpp" "-stdlib=libc++")
+    target_compile_options("jsoncpp" PRIVATE "-stdlib=libc++")
   endif()
 endif()

extern/CMakeProject-lua.cmake

@@ -63,7 +63,7 @@ set_property(TARGET "lua-5.1" PROPERTY FOLDER "External Libraries")
 # include_directories(src)
 
 if(MSVC)
-  sm_add_compile_definition("lua-5.1" _CRT_SECURE_NO_WARNINGS)
+  target_compile_definitions("lua-5.1" PRIVATE _CRT_SECURE_NO_WARNINGS)
   set_source_files_properties(${LUA_SRC} PROPERTIES LANGUAGE CXX)
 endif(MSVC)
 

extern/CMakeProject-mad.cmake

@@ -53,28 +53,28 @@ else()
     set(WORDS_BIGENDIAN 1)
   endif()
 
-  sm_add_compile_definition("mad" $<$<CONFIG:Debug>:DEBUG>)
+  target_compile_definitions("mad" PRIVATE $<$<CONFIG:Debug>:DEBUG>)
-  sm_add_compile_definition("mad" HAVE_CONFIG_H)
+  target_compile_definitions("mad" PRIVATE HAVE_CONFIG_H)
 
   if(MSVC)
-    sm_add_compile_definition("mad" _CRT_SECURE_NO_WARNINGS)
+    target_compile_definitions("mad" PRIVATE _CRT_SECURE_NO_WARNINGS)
     # TODO: Remove the need for this check since it's tied to 32-bit builds from
     # first glance.
-    sm_add_compile_definition("mad" ASO_ZEROCHECK)
+    target_compile_definitions("mad" PRIVATE ASO_ZEROCHECK)
-    sm_add_compile_definition("mad" $<$<CONFIG:Debug>:FPM_DEFAULT>)
+    target_compile_definitions("mad" PRIVATE $<$<CONFIG:Debug>:FPM_DEFAULT>)
     if(SM_WIN32_ARCH MATCHES "x64")
-      sm_add_compile_definition("mad" $<$<CONFIG:Release>:FPM_64BIT>)
+      target_compile_definitions("mad" PRIVATE $<$<CONFIG:Release>:FPM_64BIT>)
-      sm_add_compile_definition("mad" $<$<CONFIG:MinSizeRel>:FPM_64BIT>)
+      target_compile_definitions("mad" PRIVATE $<$<CONFIG:MinSizeRel>:FPM_64BIT>)
-      sm_add_compile_definition("mad" $<$<CONFIG:RelWithDebInfo>:FPM_64BIT>)
+      target_compile_definitions("mad" PRIVATE $<$<CONFIG:RelWithDebInfo>:FPM_64BIT>)
     else()
-      sm_add_compile_definition("mad" $<$<CONFIG:Release>:FPM_INTEL>)
+      target_compile_definitions("mad" PRIVATE $<$<CONFIG:Release>:FPM_INTEL>)
-      sm_add_compile_definition("mad" $<$<CONFIG:MinSizeRel>:FPM_INTEL>)
+      target_compile_definitions("mad" PRIVATE $<$<CONFIG:MinSizeRel>:FPM_INTEL>)
-      sm_add_compile_definition("mad" $<$<CONFIG:RelWithDebInfo>:FPM_INTEL>)
+      target_compile_definitions("mad" PRIVATE $<$<CONFIG:RelWithDebInfo>:FPM_INTEL>)
     endif()
     # TODO: Provide a proper define for inline.
-    sm_add_compile_definition("mad" inline=__inline)
+    target_compile_definitions("mad" PRIVATE inline=__inline)
   elseif(APPLE OR UNIX)
-    sm_add_compile_definition("mad" FPM_64BIT=1)
+    target_compile_definitions("mad" PRIVATE FPM_64BIT=1)
   endif(MSVC)
 
   target_include_directories("mad" PUBLIC "${MAD_DIR}")

extern/CMakeProject-miniz.cmake

@@ -10,5 +10,5 @@ set_property(TARGET "miniz" PROPERTY FOLDER "External Libraries")
 disable_project_warnings("miniz")
 
 if(MSVC)
-  sm_add_compile_definition("miniz" _MBCS)
+  target_compile_definitions("miniz" PRIVATE _MBCS)
 endif(MSVC)

extern/CMakeProject-png.cmake

@@ -43,7 +43,7 @@ else()
   disable_project_warnings("png")
 
   if(MSVC)
-    sm_add_compile_definition("png" _CRT_SECURE_NO_WARNINGS)
+    target_compile_definitions("png" PRIVATE _CRT_SECURE_NO_WARNINGS)
   endif()
 
   target_include_directories("png" PUBLIC

extern/CMakeProject-tomcrypt.cmake

@@ -814,54 +814,53 @@ else()
   set_property(TARGET "tomcrypt" PROPERTY FOLDER "External Libraries")
 
   # Required since building from the source.
-  sm_add_compile_definition("tomcrypt" LTC_SOURCE)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_SOURCE)
 
   # Required since tommath is a dependency.
-  sm_add_compile_definition("tomcrypt" LTM_DESC)
+  target_compile_definitions("tomcrypt" PRIVATE LTM_DESC)
 
   # This was defined behind an always active block.
-  sm_add_compile_definition("tomcrypt" LTC_DEVRANDOM)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_DEVRANDOM)
 
   # Common formulas used by our app.
-  sm_add_compile_definition("tomcrypt" LTC_SHA256)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_SHA256)
-  sm_add_compile_definition("tomcrypt" LTC_SHA1)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_SHA1)
-  sm_add_compile_definition("tomcrypt" LTC_MD5)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_MD5)
 
   # Use the full AES encryption items.
-  sm_add_compile_definition("tomcrypt" LTC_YARROW)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_YARROW)
-  sm_add_compile_definition("tomcrypt" LTC_YARROW_AES=3)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_YARROW_AES=3)
 
   # Other definitions we used in the past, but whose meanings are not clear.
-  sm_add_compile_definition("tomcrypt" LTC_NO_PKCS)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_NO_PKCS)
-  sm_add_compile_definition("tomcrypt" LTC_PKCS_1)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_PKCS_1)
-  sm_add_compile_definition("tomcrypt" LTC_DER)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_DER)
-  sm_add_compile_definition("tomcrypt" LTC_NO_MODES)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_NO_MODES)
-  sm_add_compile_definition("tomcrypt" LTC_ECB_MODE)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_ECB_MODE)
-  sm_add_compile_definition("tomcrypt" LTC_CBC_MODE)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_CBC_MODE)
-  sm_add_compile_definition("tomcrypt" LTC_CTR_MODE)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_CTR_MODE)
-  sm_add_compile_definition("tomcrypt" LTC_NO_HASHES)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_NO_HASHES)
-  sm_add_compile_definition("tomcrypt" LTC_NO_MACS) # no MAC (message authentication code) support
+  target_compile_definitions("tomcrypt" PRIVATE LTC_NO_MACS) # no MAC (message authentication code) support
-  sm_add_compile_definition("tomcrypt" LTC_NO_PRNGS)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_NO_PRNGS)
-  sm_add_compile_definition("tomcrypt" LTC_RNG_GET_BYTES)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_RNG_GET_BYTES)
-  sm_add_compile_definition("tomcrypt" LTC_RNG_MAKE_PRNG)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_RNG_MAKE_PRNG)
-  sm_add_compile_definition("tomcrypt" LTC_TRY_URANDOM_FIRST)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_TRY_URANDOM_FIRST)
-  sm_add_compile_definition("tomcrypt" LTC_NO_PK)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_NO_PK)
-  sm_add_compile_definition("tomcrypt" LTC_MRSA)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_MRSA)
-  sm_add_compile_definition("tomcrypt" LTC_NO_PROTOTYPES)
+  target_compile_definitions("tomcrypt" PRIVATE LTC_NO_PROTOTYPES)
 
   if(WITH_PORTABLE_TOMCRYPT)
-    sm_add_compile_definition("tomcrypt" LTC_NO_ASM)
+    target_compile_definitions("tomcrypt" PRIVATE LTC_NO_ASM)
   endif()
   if(WITH_NO_ROLC_TOMCRYPT)
-    sm_add_compile_definition("tomcrypt" LTC_NO_ROLC)
+    target_compile_definitions("tomcrypt" PRIVATE LTC_NO_ROLC)
   endif()
 
   if(APPLE)
-    sm_append_simple_target_property("tomcrypt"
+    set_property(TARGET "tomcrypt" PROPERTY XCODE_ATTRIBUTE_GCC_NO_COMMON_BLOCKS "YES")
-                 XCODE_ATTRIBUTE_GCC_NO_COMMON_BLOCKS "YES")
   endif()
   if(MSVC)
-    sm_add_compile_definition("tomcrypt" _CRT_SECURE_NO_WARNINGS)
+    target_compile_definitions("tomcrypt" PRIVATE _CRT_SECURE_NO_WARNINGS)
   endif()
 
   disable_project_warnings("tomcrypt")

extern/CMakeProject-zlib.cmake

@@ -41,6 +41,6 @@ else()
   disable_project_warnings("zlib")
 
   if(MSVC)
-    sm_add_compile_definition("zlib" _MBCS)
+    target_compile_definitions("zlib" PRIVATE _MBCS)
   endif(MSVC)
 endif()

src/CMakeLists.txt

@@ -112,25 +112,25 @@ set_target_properties("${SM_EXE_NAME}"
                                  "${SM_NAME_RELWITHDEBINFO}")
 
 # Required for usage of tomcrypt and tommath.
-sm_add_compile_definition("${SM_EXE_NAME}" LTM_DESC)
+target_compile_definitions("${SM_EXE_NAME}" PRIVATE LTM_DESC)
 
 if(WITH_PORTABLE_TOMCRYPT)
-  sm_add_compile_definition("${SM_EXE_NAME}" LTC_NO_ASM)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE LTC_NO_ASM)
 endif()
 if(WITH_NO_ROLC_TOMCRYPT)
-  sm_add_compile_definition("${SM_EXE_NAME}" LTC_NO_ROLC)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE LTC_NO_ROLC)
 endif()
 
 if(NOT WITH_NETWORKING)
-  sm_add_compile_definition("${SM_EXE_NAME}" WITHOUT_NETWORKING)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE WITHOUT_NETWORKING)
 endif()
 
 # Compilation flags per project here.
-sm_add_compile_definition("${SM_EXE_NAME}" $<$<CONFIG:Debug>:DEBUG>)
+target_compile_definitions("${SM_EXE_NAME}" PRIVATE $<$<CONFIG:Debug>:DEBUG>)
-sm_add_compile_definition("${SM_EXE_NAME}" $<$<CONFIG:Release>:RELEASE>)
+target_compile_definitions("${SM_EXE_NAME}" PRIVATE $<$<CONFIG:Release>:RELEASE>)
-sm_add_compile_definition("${SM_EXE_NAME}" $<$<CONFIG:MinSizeRel>:MINSIZEREL>)
+target_compile_definitions("${SM_EXE_NAME}" PRIVATE $<$<CONFIG:MinSizeRel>:MINSIZEREL>)
-sm_add_compile_definition("${SM_EXE_NAME}"
+target_compile_definitions("${SM_EXE_NAME}" PRIVATE
-                          $<$<CONFIG:RelWithDebInfo>:RELWITHDEBINFO>)
+                           $<$<CONFIG:RelWithDebInfo>:RELWITHDEBINFO>)
 
 set(SM_COMPILE_FLAGS "")
 
@@ -180,12 +180,11 @@ list(APPEND SM_WINDOWS_PROGRAM_DLLS
             "${SM_PROGRAM_DIR}/swscale-2.dll")
 
 if(WIN32)
-  sm_add_compile_definition("${SM_EXE_NAME}" WINDOWS)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE WINDOWS)
-  sm_add_compile_definition("${SM_EXE_NAME}" _WINDOWS) # TODO: Remove this
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE _WINDOWS) # TODO: Remove this potential duplicate.
-                                                       # potential duplicate.
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE _CRT_SECURE_NO_WARNINGS)
-  sm_add_compile_definition("${SM_EXE_NAME}" _CRT_SECURE_NO_WARNINGS)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE _WINSOCK_DEPRECATED_NO_WARNINGS)
-  sm_add_compile_definition("${SM_EXE_NAME}" _WINSOCK_DEPRECATED_NO_WARNINGS)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE GLEW_STATIC)
-  sm_add_compile_definition("${SM_EXE_NAME}" GLEW_STATIC)
 
   set_target_properties("${SM_EXE_NAME}"
                         PROPERTIES RUNTIME_OUTPUT_DIRECTORY
@@ -210,8 +209,8 @@ if(WIN32)
       COMMENT "Generating file to allow for easier stack traces.")
   endif()
 elseif(APPLE)
-  sm_add_compile_definition("${SM_EXE_NAME}" BACKTRACE_METHOD_X86_DARWIN)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE BACKTRACE_METHOD_X86_DARWIN)
-  sm_add_compile_definition("${SM_EXE_NAME}" MACOSX)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE MACOSX)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++14 -stdlib=libc++")
   set_target_properties(
     "${SM_EXE_NAME}"
@@ -272,10 +271,10 @@ elseif(APPLE)
   target_sources("${SM_EXE_NAME}" PUBLIC ${APPLE_BUNDLE_RESOURCES})
   set_source_files_properties(${APPLE_BUNDLE_RESOURCES} PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
 
-  sm_add_compile_definition("${SM_EXE_NAME}" _XOPEN_SOURCE)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE _XOPEN_SOURCE)
 
   if(${HAS_FFMPEG})
-    sm_add_compile_definition("${SM_EXE_NAME}" HAVE_FFMPEG)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE HAVE_FFMPEG)
   endif()
 
   if(CMAKE_BUILD_TYPE EQUAL "Debug")
@@ -351,73 +350,73 @@ else() # Linux
                                    "${SM_ROOT_DIR}")
 
   if(${WITH_CRASH_HANDLER})
-    sm_add_compile_definition("${SM_EXE_NAME}" CRASH_HANDLER)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE CRASH_HANDLER)
     if(LINUX)
       # used only in the ArchHooks_Unix.cpp file
       if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86" OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
-        sm_add_compile_definition("${SM_EXE_NAME}" BACKTRACE_METHOD_X86_LINUX)
+        target_compile_definitions("${SM_EXE_NAME}" PRIVATE BACKTRACE_METHOD_X86_LINUX)
-        sm_add_compile_definition("${SM_EXE_NAME}"
+        target_compile_definitions("${SM_EXE_NAME}" PRIVATE
-                                BACKTRACE_METHOD_TEXT="x86 custom backtrace")
+                                   BACKTRACE_METHOD_TEXT="x86 custom backtrace")
       else()
-        sm_add_compile_definition("${SM_EXE_NAME}"
+        target_compile_definitions("${SM_EXE_NAME}" PRIVATE
-                                BACKTRACE_METHOD_TEXT="no backtrace")
+                                   BACKTRACE_METHOD_TEXT="no backtrace")
       endif()
-      sm_add_compile_definition(
+      target_compile_definitions("${SM_EXE_NAME}" PRIVATE
-        "${SM_EXE_NAME}" BACKTRACE_LOOKUP_METHOD_TEXT="backtrace_symbols")
+                                 BACKTRACE_LOOKUP_METHOD_TEXT="backtrace_symbols")
       if(${DL_FOUND})
-        sm_add_compile_definition("${SM_EXE_NAME}"
+        target_compile_definitions("${SM_EXE_NAME}" PRIVATE
-                                  BACKTRACE_LOOKUP_METHOD_DLADDR)
+                                   BACKTRACE_LOOKUP_METHOD_DLADDR)
       else()
-        sm_add_compile_definition("${SM_EXE_NAME}"
+        target_compile_definitions("${SM_EXE_NAME}" PRIVATE
-                                  BACKTRACE_LOOKUP_METHOD_BACKTRACE_SYMBOLS)
+                                   BACKTRACE_LOOKUP_METHOD_BACKTRACE_SYMBOLS)
       endif()
     endif()
   endif()
   if(${HAS_PTHREAD})
-    sm_add_compile_definition("${SM_EXE_NAME}" HAVE_LIBPTHREAD)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE HAVE_LIBPTHREAD)
 
     message("Host processor is ${CMAKE_SYSTEM_PROCESSOR}")
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
       message("Host processor is 64bit X86")
-      sm_add_compile_definition("${SM_EXE_NAME}" CPU_X86_64)
+      target_compile_definitions("${SM_EXE_NAME}" PRIVATE CPU_X86_64)
     elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86"
            OR CMAKE_SYSTEM_PROCESSOR MATCHES "i686")
       message("Host processor is 32bit X86")
-      sm_add_compile_definition("${SM_EXE_NAME}" CPU_X86)
+      target_compile_definitions("${SM_EXE_NAME}" PRIVATE CPU_X86)
     elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
       message("Host processor is 64bit ARM")
-      sm_add_compile_definition("${SM_EXE_NAME}" CPU_AARCH64)
+      target_compile_definitions("${SM_EXE_NAME}" PRIVATE CPU_AARCH64)
     else()
       message("Unrecognized host processor type")
     endif()
   endif()
   if(${HAS_FFMPEG})
-    sm_add_compile_definition("${SM_EXE_NAME}" HAVE_FFMPEG)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE HAVE_FFMPEG)
   endif()
   if(${HAS_XRANDR})
-    sm_add_compile_definition("${SM_EXE_NAME}" HAVE_XRANDR)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE HAVE_XRANDR)
   endif()
   if(${HAS_LIBXTST})
-    sm_add_compile_definition("${SM_EXE_NAME}" HAVE_LIBXTST)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE HAVE_LIBXTST)
   endif()
   if(${HAS_XINERAMA})
-    sm_add_compile_definition("${SM_EXE_NAME}" HAVE_XINERAMA)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE HAVE_XINERAMA)
   endif()
 
   if(BSD)
-    sm_add_compile_definition("${SM_EXE_NAME}" BSD)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE BSD)
   endif()
 
   if(GTK3_FOUND)
-    sm_add_compile_definition("${SM_EXE_NAME}" HAVE_GTK)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE HAVE_GTK)
   endif()
 
-  sm_add_compile_definition("${SM_EXE_NAME}" UNIX)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE UNIX)
   if("${CMAKE_SYSTEM}" MATCHES "Linux")
-    sm_add_compile_definition("${SM_EXE_NAME}" LINUX)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE LINUX)
   endif()
 
-  sm_add_compile_flag("${SM_EXE_NAME}" "-std=${SM_CPP_STANDARD}")
+  target_compile_options("${SM_EXE_NAME}" PRIVATE "-std=${SM_CPP_STANDARD}")
 endif()
 
 set_property(TARGET "${SM_EXE_NAME}" PROPERTY FOLDER "Internal Libraries")
@@ -459,7 +458,7 @@ else()
 endif()
 
 if(WITH_SYSTEM_JPEG)
-  sm_add_compile_definition("${SM_EXE_NAME}" SYSTEM_JPEGLIB)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE SYSTEM_JPEGLIB)
   list(APPEND SMDATA_LINK_LIB ${JPEG_LIBRARIES})
 else()
   list(APPEND SMDATA_LINK_LIB "jpeg")
@@ -472,7 +471,7 @@ else()
 endif()
 
 if(WITH_SYSTEM_PNG)
-  sm_add_compile_definition("${SM_EXE_NAME}" SYSTEM_PNG)
+  target_compile_definitions("${SM_EXE_NAME}" PRIVATE SYSTEM_PNG)
   list(APPEND SMDATA_LINK_LIB ${PNG_LIBRARIES})
 else()
   list(APPEND SMDATA_LINK_LIB "png")
@@ -607,17 +606,17 @@ else() # Unix / Linux TODO: Remember to find and locate the zip archive files.
 
   if(HAS_OSS)
     # No mention of OSS libraries.
-    sm_add_compile_definition("${SM_EXE_NAME}" "HAVE_OSS_VERSION=1")
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE "HAVE_OSS_VERSION=1")
   endif()
 
   if(HAS_PULSE)
     list(APPEND SMDATA_LINK_LIB ${PULSEAUDIO_LIBRARY})
     # PACKAGE_NAME and PACKAGE_VERSION are only used in this scenario. Why is
     # not clear. TODO: Remove this silliness.
-    sm_add_compile_definition("${SM_EXE_NAME}" PACKAGE_NAME="StepMania")
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE PACKAGE_NAME="StepMania")
     set(PACKAGE_VERSION "${SM_VERSION_MAJOR}.${SM_VERSION_MINOR}")
-    sm_add_compile_definition("${SM_EXE_NAME}"
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE
-                              PACKAGE_VERSION="${PACKAGE_VERSION}")
+                               PACKAGE_VERSION="${PACKAGE_VERSION}")
   endif()
 
   if(X11_FOUND)
@@ -626,7 +625,7 @@ else() # Unix / Linux TODO: Remember to find and locate the zip archive files.
 
   if(SDL2_FOUND)
     list(APPEND SMDATA_LINK_LIB ${SDL2_LIBRARY})
-    sm_add_compile_definition("${SM_EXE_NAME}" HAVE_SDL)
+    target_compile_definitions("${SM_EXE_NAME}" PRIVATE HAVE_SDL)
   endif()
 
   if(PCRE_FOUND)
@@ -737,7 +736,7 @@ endif()
 if(NOT APPLE)
   if(WIN32)
     set(SM_FULL_INSTALLATION_PATH_LIST "${SM_INSTALL_DESTINATION}" "Program")
-    sm_join("${SM_FULL_INSTALLATION_PATH_LIST}" "/" SM_FULL_INSTALLATION_PATH)
+    list(JOIN SM_FULL_INSTALLATION_PATH_LIST "/" SM_FULL_INSTALLATION_PATH)
     # Hardcoding the values for now since the foreach loop is not working as
     # intended.
     install(TARGETS "${SM_EXE_NAME}" DESTINATION "${SM_FULL_INSTALLATION_PATH}")

src/CMakeProject-texture.cmake

@@ -38,7 +38,7 @@ set_property(TARGET "TextureFontGenerator" PROPERTY FOLDER "Internal Libraries")
 disable_project_warnings("TextureFontGenerator")
 
 if(NOT WITH_STATIC_LINKING)
-  sm_add_compile_definition("TextureFontGenerator" _AFXDLL)
+  target_compile_definitions("TextureFontGenerator" PRIVATE _AFXDLL)
 endif()
 
 list(APPEND TEXTURE_LINK_LIB "zlib" "png")