CMakeLists.txt

# vi:set sw=2 et:
cmake_minimum_required(VERSION 3.15)
cmake_policy(SET CMP0091 NEW)
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
set(CMAKE_OSX_DEPLOYMENT_TARGET 10.13 CACHE STRING "Minimum macOS version")
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
endif()

if(NOT ENABLE_LTO)
  option(ENABLE_LTO "Turns on link-time optimization for release builds" ON)
endif()

if(NOT BUILD_TESTING)
  option(BUILD_TESTING "" OFF)
endif()

project(Surge VERSION 1.4.0 LANGUAGES C CXX)

# Banner {{{
message(STATUS "It's Surge XT, folks! Version is ${PROJECT_VERSION}.")
message(STATUS "CMAKE_BUILD_TYPE is ${CMAKE_BUILD_TYPE}.")
message(STATUS "CMake version is ${CMAKE_VERSION}.")
message(STATUS "Compiler version is ${CMAKE_CXX_COMPILER_VERSION}.")
math(EXPR SURGE_BITNESS "${CMAKE_SIZEOF_VOID_P} * 8" OUTPUT_FORMAT DECIMAL)
message(STATUS "Targeting ${SURGE_BITNESS}-bit configuration.")

# }}}
if(APPLE)
  enable_language(OBJC)
  enable_language(OBJCXX)
endif()

# Make Sure the REpo is properly cloned {{{
set(SURGE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})

if(NOT EXISTS "${SURGE_SOURCE_DIR}/libs/tuning-library/README.md")
  message(FATAL_ERROR "Cannot find the contents of the tuning-library submodule. This usually means"
    " that you haven't done a submodule update, so the repository will not build properly. "
    "To resolve this, please run git submodule update --init --recursive and re-run CMake!")
endif()

# }}}

# Fail on 32 bit except on windows {{{
option(SURGE_BUILD_32BIT_LINUX "Allow non-working Surge XT builds to run on 32-bit Linux" OFF)

if(${CMAKE_SIZEOF_VOID_P} EQUAL 4)
  if(WIN32)
    message(STATUS "Windows 32-bit build is lightly tested")
  else()
    # If you hit this error and want to try and do a 32-bit build on your Linux variant,
    # most likely you will need to conditionally #ifdef out the Spring Reverb and a few other
    # things. We would happily merge that conditional compilation. The strategy is basically:
    # add an 'is 32-bit Linux' compile flag to Surge common, use that to make the SpringReverb
    # a nullptr in Effects.cpp and skipped code in the C++, test. etc... The branch where you
    # can add this flag is where we add the -msse4.1 flag in the GNU/CLang branch below, to get
    # started
    message(WARNING "32-bit builds are only available on Windows.")
    message(WARNING "If you are building on an Raspberry Pi, install a 64-bit operating system!")
    message(WARNING "If you want to help fix this, see the comment in CMakeLists.txt.")

    if(NOT ${SURGE_BUILD_32BIT_LINUX})
      message(FATAL_ERROR "Stopping compilation!")
    else()
      message(WARNING "Compilation continuing anyway. Good luck!")
    endif()
  endif()
endif()

# }}}

# Global compiler/linker settings {{{
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD 20)

# Enable LTO if unspecified, for release builds.
if(CMAKE_BUILD_TYPE MATCHES "Release" AND ENABLE_LTO)
  message(STATUS "Enabling link-time optimization for release builds.")
  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
else()
  message(STATUS "Link-time optimization is disabled.")
endif()

if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND UNIX AND NOT APPLE AND NOT SURGE_SKIP_PIE_CHANGE)
  message(STATUS "Setting -no-pie on EXE flags; use SURGE_SKIP_PIE_CHANGE=TRUE to avoid.")
  set(CMAKE_EXE_LINKER_FLAGS "-no-pie")
endif()

if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
  if(${SURGE_SANITIZE})
    message(STATUS "Sanitizer is on.")
  endif()

  # Any Clang or any GCC
  add_compile_options(
    -Wno-multichar
    -fno-math-errno
    -fno-trapping-math

    # Targeting Windows with GCC/Clang is experimental
    $<$<NOT:$<OR:$<BOOL:${WIN32}>,$<BOOL:${SURGE_SKIP_WERROR}>>>:-Werror>

    # PE/COFF doesn't support visibility
    $<$<NOT:$<BOOL:${WIN32}>>:-fvisibility=hidden>

    # Inlines visibility is only relevant with C++
    $<$<AND:$<NOT:$<BOOL:${WIN32}>>,$<COMPILE_LANGUAGE:CXX>>:-fvisibility-inlines-hidden>

    # BP note: If you want to turn on llvm/gcc sanitize undo this and the link options below
    $<$<BOOL:${SURGE_SANITIZE}>:-fsanitize=address>
    $<$<BOOL:${SURGE_SANITIZE}>:-fsanitize=undefined>

    # Do *not* use the new, breaking char8_t UTF-8 bits in C++20.
    $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<VERSION_GREATER_EQUAL:${CMAKE_CXX_STANDARD},20>>:-fno-char8_t>
  )

  add_link_options(
    $<$<BOOL:${SURGE_SANITIZE}>:-fsanitize=address>
    $<$<BOOL:${SURGE_SANITIZE}>:-fsanitize=undefined>
  )

  # Enable SSE4.1 on x86 platforms.
  include(CheckCXXSourceCompiles)
  check_cxx_source_compiles("
#if defined(__i386__) || defined(__x86_64) || defined(_M_AMD64) || defined(_M_X64)
#else
#error
#endif
int main() {}" IS_X86)
  if (IS_X86)
    add_compile_options(-msse4.1 -mfpmath=sse)
  endif()

  # Add AVX support
  include(CheckCXXSourceCompiles)
  check_cxx_source_compiles("
#if defined(__x86_64__) || defined(__SSE2__) || defined(_M_AMD64) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
  #ifndef __AVX__
  #error
  #endif
#endif
    int main() {}" COMPILER_HAS_AVX_OR_IS_ARM)

  if(NOT COMPILER_HAS_AVX_OR_IS_ARM)
    message(STATUS "Holding off on AVX support. See GitHub issue #4479 for the strategy.")

    # add_compile_options("-mavx")
  endif()

  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    # Any Clang
    add_compile_options(
      -Wno-unused-command-line-argument
      -Wno-deprecated-declarations
      -Werror=inconsistent-missing-override
      -Werror=logical-op-parentheses
      -Werror=dynamic-class-memaccess
      -Werror=undefined-bool-conversion
      -Werror=bitwise-op-parentheses
      -Werror=pointer-bool-conversion
    )

    if(CMAKE_CXX_COMPILER_ID MATCHES "^AppleClang$")
      # Apple Clang only
      add_compile_options(
        -faligned-allocation
        -fasm-blocks
      )
    endif()
  elseif(CMAKE_CXX_COMPILER_ID MATCHES "^GNU$")
    # GCC only
    add_compile_options(
      -Wformat-truncation=0 # squelch warning about snprintf truncating strings (see PR #3977)
      -Wno-free-nonheap-object # https://github.com/surge-synthesizer/surge/issues/4251
      -Wno-return-local-addr # squelch sqlite3 error: function may return address of local variable
      -Wno-error=restrict # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105651
      -Wno-date-time
    )
  endif()
endif()

if(MSVC)
  message(STATUS "MSVC build with ${CMAKE_GENERATOR_PLATFORM} generator")

  if(("${CMAKE_GENERATOR_PLATFORM}" STREQUAL "arm64ec") OR("${CMAKE_GENERATOR_PLATFORM}" STREQUAL "arm64"))
    message(STATUS "Skipping warnings as errors (-WX) on arm64ec for now.")
  else()
    add_compile_options(-WX)
  endif()

  add_compile_options(

    # MSVC-only warnings, Clang-cl silently ignores these
    /wd4244 # float to double
    /wd4305 # truncation of variable
    /wd4267 # int and size_t
    /wd4018 # signed unsigned mismatch
    /wd4388 # signed unsigned mismatch in comparison
    /wd4065 # standalone default in a switch with no case
    /wd4702 # unreachable code. I generally do if( a ) return foo else return bar; return nullptr so don't warn on that
    /wd4005 # macro redefinition. Thanks NOMINMAX
    /wd5105 # defined operator in macro expansion; used in some JUCE dependencies and works okay on all of our compilers

    # Clang-cl-only warnings
    $<$<CXX_COMPILER_ID:Clang>:-Wno-microsoft-exception-spec>
    $<$<CXX_COMPILER_ID:Clang>:-Wno-pragma-pack>

    /Zc:alignedNew
    /bigobj

    # /arch:AVX

    # Build with multiple processes (clang-cl builds use Ninja instead)
    $<$<CXX_COMPILER_ID:MSVC>:/MP>

    # Set source and executable charsets to UTF-8
    $<$<CXX_COMPILER_ID:MSVC>:/utf-8>

    # Do *not* use the new, breaking char8_t UTF-8 bits in C++20.
    $<$<COMPILE_LANGUAGE:CXX>:/Zc:char8_t->

    # make MSVC define __cplusplus properly
    $<$<COMPILE_LANGUAGE:CXX>:/Zc:__cplusplus>

    # standards-conforming lambda grammar and processing
    $<$<COMPILE_LANGUAGE:CXX>:/Zc:lambda>
  )
  add_compile_definitions(_SILENCE_STDEXT_ARR_ITERS_DEPRECATION_WARNING)
endif()

# }}}
# Source Groups {{{
source_group("Libraries" REGULAR_EXPRESSION "libs/")
source_group("AirWindows" REGULAR_EXPRESSION "libs/airwindows/")
source_group("Surge Core" REGULAR_EXPRESSION "src/common/.*\.cpp")
source_group("Surge DSP" REGULAR_EXPRESSION "src/common/dsp/")
source_group("Surge FX" REGULAR_EXPRESSION "src/common/dsp/effects/")
source_group("Surge GUI" REGULAR_EXPRESSION "src/surge-xt/gui/")
source_group("Generated Code" REGULAR_EXPRESSION "version.cpp")
source_group("Headless" REGULAR_EXPRESSION "src/surge-testrunner/")
source_group("Surge XT Juce" REGULAR_EXPRESSION "src/surge-xt/")
source_group("Surge FX Juce" REGULAR_EXPRESSION "src/surge-fx/")

# }}}
option(SURGE_BUILD_TESTRUNNER "Build Surge unit test runner" ON)

if(${SURGE_BUILD_TESTRUNNER})
  message(STATUS "Enabling tests; compile with SURGE_BUILD_TESTRUNNER=OFF to skip")
  enable_testing()
endif()

add_subdirectory(libs/sst/sst-cmake)
add_subdirectory(resources)
add_subdirectory(src)

# CI Pipeline {{{
include(cmake/stage-extra-content.cmake)

# We have a special target here which the PR pipeline uses to make sure things
# are of the appropriate code quality. This allows us to write CMAKE rules which
# become linters and stuff. The code will run on macos in the pipeline. I suppose
# you could run it locally to, but really, you should know what you are doing if you
# do that. And I'll document it so you can know that when I use it earnest in 1.9
add_custom_target(code-quality-pipeline-checks)

# Check 1: The extra content is properly specified.
# add_dependencies(code-quality-pipeline-checks download-extra-content)

# Clang Format checks
set(CLANG_FORMAT_DIRS src)
set(CLANG_FORMAT_EXTS cpp h)

foreach(dir ${CLANG_FORMAT_DIRS})
  foreach(ext ${CLANG_FORMAT_EXTS})
    list(APPEND CLANG_FORMAT_GLOBS "':(glob)${dir}/**/*.${ext}'")
  endforeach()
endforeach()

add_custom_command(TARGET code-quality-pipeline-checks
  POST_BUILD
  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
  COMMAND ${CMAKE_COMMAND} -E echo About to check clang-format using clang-format-12
  COMMAND git ls-files -- ${CLANG_FORMAT_GLOBS} | xargs clang-format-12 --dry-run --Werror
)

# }}}