CMakeLists.txt

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#
# CMakeLists.txt -- configuration file for CMake build system
#

# CMAKE_MINIMUM_REQUIRED should be the first directive in the file:
# https://cmake.org/cmake/help/latest/command/cmake_minimum_required.html

# Information about bundled CMake versions in different distributions and
# toolsets:
# - Visual Studio 2017     (supported until Apr 2027): CMake 3.6
# - Visual Studio 2019     (supported until Apr 2029): CMake 3.20
# - Visual Studio 2022     (supported until Jan 2032): CMake 3.31
# - Visual Studio 2026     (supported until Nov 2028): CMake 4.3
# - Debian 11 "bullseye"   (supported until Aug 2026): CMake 3.18
# - Debian 12 "bookworm"   (supported until Jun 2028): CMake 3.25
# - Debian 13 "trixie"     (supported until Aug 2030): CMake 3.31
# - Ubuntu 22.04 LTS       (supported until May 2027): CMake 3.22
# - Ubuntu 24.04 LTS       (supported until May 2029): CMake 3.28
# - Ubuntu 26.04 LTS       (supported until May 2031): CMake 4.2
# - RHEL 8                 (supported until May 2029): CMake 3.26
# - RHEL 9                 (supported until May 2032): CMake 3.31
# - RHEL 10                (supported until May 2035): CMake 3.31
cmake_minimum_required(VERSION 3.20)

function(read_version path var major minor patch)
  get_filename_component(path ${path} ABSOLUTE)

  if (EXISTS ${path})
    file(
      STRINGS ${path} VERSION_STRINGS
      REGEX "#define (${major}|${minor}|${patch})"
    )

    string(REGEX REPLACE ".*${major} +([0-9]+).*" "\\1" VER_MAJOR ${VERSION_STRINGS})
    string(REGEX REPLACE ".*${minor} +([0-9]+).*" "\\1" VER_MINOR ${VERSION_STRINGS})
    string(REGEX REPLACE ".*${patch} +([0-9]+).*" "\\1" VER_PATCH ${VERSION_STRINGS})

    set(${major} "${VER_MAJOR}" PARENT_SCOPE)
    set(${minor} "${VER_MINOR}" PARENT_SCOPE)
    set(${patch} "${VER_PATCH}" PARENT_SCOPE)
    set(${var} "${VER_MAJOR}.${VER_MINOR}.${VER_PATCH}" PARENT_SCOPE)
  endif()
endfunction()

read_version(
  "subversion/include/svn_version.h" SVN_VERSION
  SVN_VER_MAJOR SVN_VER_MINOR SVN_VER_PATCH
)

project("Subversion"
  VERSION "${SVN_VERSION}"
  LANGUAGES C
)

### Options

include(CMakeDependentOption)

# Build components
option(SVN_ENABLE_SVNXX "Enable compilation of the C++ bindings (requires C++)" OFF)
option(SVN_ENABLE_PROGRAMS "Build Subversion programs (such as svn.exe)" ON)
cmake_dependent_option(SVN_ENABLE_TOOLS "Build Subversion tools" ON "SVN_ENABLE_TESTS" OFF)
option(SVN_ENABLE_TESTS "Build Subversion test-suite" OFF)
option(SVN_TEST_EXPAND "Expand tests; This will slow-down configuration, but you will have an ability to run any subtest" OFF)
option(SVN_TEST_CONFIGURE_FOR_PARALLEL "Configures tests for parallel run execution" OFF)
set(SVN_TEST_COMMAND_ARGUMENTS "" CACHE STRING "Additional command line options to be passed to run_tests.py")
option(SVN_TEST_CHECK_XML_SCHEMA "Enable extended XML schema validation" OFF)
option(SVN_TEST_CLEANUP "Clean up directories for successful tests" ON)
option(SVN_ENABLE_APACHE_MODULES "Build modules for Apache HTTPD" OFF)

include(GNUInstallDirs)
option(SVN_ENABLE_SWIG_PERL "Enable Subversion Perl bindings Perl" OFF)
option(SVN_ENABLE_SWIG_PERL_TESTS "Enable tests for Subversion Perl bindings" OFF)
option(SVN_ENABLE_SWIG_PERL_MAN_PAGES "Enable man pages for Subversion Perl bindings" OFF)
option(SVN_ENABLE_SWIG_PYTHON "Enable Subversion Python bindings" OFF)
option(SVN_ENABLE_SWIG_PYTHON_TESTS "Enable tests for Subversion Python bindings" OFF)
option(SVN_ENABLE_SWIG_RUBY "Enable Subversion Ruby bindings" OFF)
option(SVN_ENABLE_SWIG_RUBY_TESTS "Enable tests for Subversion Ruby bindings" OFF)
option(SVN_ENABLE_JAVAHL "Enable Subversion JavaHL bindings" OFF)
option(SVN_ENABLE_JAVAHL_TESTS "Enable tests for Subversion JavaHL bindings" OFF)
set(SVN_SWIG_PERL_SITEARCH "${CMAKE_INSTALL_LIBDIR}/svn-perl"
  CACHE PATH "Path to install Subversion Perl bindings for sitearch")
set(SVN_SWIG_PERL_MAN3DIR "${CMAKE_INSTALL_MANDIR}/man3"
  CACHE PATH "Path to install Subversion Perl bindings for man3dir")
set(SVN_SWIG_PYTHON_SITELIB "${CMAKE_INSTALL_LIBDIR}/svn-python"
  CACHE PATH "Path to install Subversion Python bindings for sitelib")
set(SVN_SWIG_PYTHON_SITEARCH "${CMAKE_INSTALL_LIBDIR}/svn-python"
  CACHE PATH "Path to install Subversion Python bindings for sitearch")
set(SVN_SWIG_RUBY_SITELIB "${CMAKE_INSTALL_LIBDIR}/svn-ruby"
  CACHE PATH "Path to install Subversion Ruby bindings for sitelib")
set(SVN_SWIG_RUBY_SITEARCH "${CMAKE_INSTALL_LIBDIR}/svn-ruby"
  CACHE PATH "Path to install Subversion Ruby bindings for sitearch")
set(SVN_JAVAHL_DIR "${CMAKE_INSTALL_DATAROOTDIR}/java"
  CACHE PATH "Path to install Subversion JavaHL bindings")

# Enable modules and features
option(SVN_ENABLE_RA_LOCAL "Enable Subversion Local Repository Access Library" ON)
option(SVN_ENABLE_RA_SERF "Enable Subversion HTTP/WebDAV Protocol Repository Access Library" ON)
option(SVN_ENABLE_RA_SVN "Enable Subversion SVN Protocol Repository Access Library" ON)
option(SVN_ENABLE_FS_FS "Enable Subversion FSFS Repository Filesystem Library" ON)
option(SVN_ENABLE_FS_X "Enable Subversion FSX Repository Filesystem Library" ON)
option(SVN_ENABLE_FS_BASE "Enable Subversion Filesystem Base Library (NOT IMPLEMENTED and DEPRECATED)" OFF)
option(SVN_ENABLE_NLS "Enable gettext functionality" OFF)
option(SVN_ENABLE_TUI "Enable TUI applications (requires ncurses)" OFF)
option(SVN_ENABLE_AUTH_KWALLET "Enable KWallet auth library" OFF)
option(SVN_ENABLE_AUTH_GNOME_KEYRING "Enable GNOME Keyring for auth credentials" OFF)
option(SVN_ENABLE_SASL "Enable Cyrus SASL v2" OFF)
option(SVN_ENABLE_LIBMAGIC "Enable libmagic filetype detection library")
cmake_dependent_option(SVN_ENABLE_AUTH_GPG_AGENT "Enable GPG Agent support" OFF "WIN32" ON)

option(SVN_INSTALL_PRIVATE_H "Install private header files." OFF)

# Configuration
option(BUILD_SHARED_LIBS "Build using shared libraries" ON)
cmake_dependent_option(SVN_BUILD_SHARED_FS "Build shared FS modules" ON "BUILD_SHARED_LIBS" OFF)
cmake_dependent_option(SVN_BUILD_SHARED_RA "Build shared RA modules" ON "BUILD_SHARED_LIBS" OFF)
option(SVN_DEBUG "Enables specific features for developer builds" OFF)
cmake_dependent_option(SVN_USE_WIN32_CRASHHANDLER "Enables WIN32 crash handler." ON "WIN32" OFF)
option(SVN_USE_DSO "Defined if svn should try to load DSOs" OFF)
set(SVN_CHECKSUM_BACKEND "apr" CACHE STRING "Checksum backend to use (possible values are 'apr', 'openssl', 'bcrypt', 'xdigest')" )
set_property(CACHE SVN_CHECKSUM_BACKEND PROPERTY STRINGS "apr" "openssl" "bcrypt" "xdigest")
set(SVN_SOVERSION "0" CACHE STRING "Subversion library ABI version")
mark_as_advanced(SVN_SOVERSION)

# Check whether we have pkg-config executable or not; Silence any messages.
find_package(PkgConfig QUIET)
cmake_dependent_option(SVN_USE_PKG_CONFIG "Use pkg-config for the dependencies" ON "PKG_CONFIG_FOUND" OFF)

# Dependencies
option(SVN_USE_INTERNAL_LZ4 "Use internal version of lz4" ON)
option(SVN_USE_INTERNAL_UTF8PROC "Use internal version of utf8proc" ON)
option(SVN_SQLITE_USE_AMALGAMATION "Use sqlite amalgamation" OFF)
set(SQLiteAmalgamation_ROOT "${CMAKE_SOURCE_DIR}/sqlite-amalgamation" CACHE STRING "Directory with sqlite amalgamation")

# Require C++ compiler
if (SVN_ENABLE_SVNXX OR SVN_ENABLE_AUTH_KWALLET OR SVN_ENABLE_JAVAHL)
  enable_language(CXX)
endif()

set(PRIVATE_CONFIG_DEFINITIONS "")

macro(add_private_config_definition comment name value)
  string(APPEND PRIVATE_CONFIG_DEFINITIONS
    "\n"
    "/* ${comment} */\n"
  )

  if("${value}" STREQUAL "")
    string(APPEND PRIVATE_CONFIG_DEFINITIONS
      "#define ${name}\n"
    )
  else()
    string(APPEND PRIVATE_CONFIG_DEFINITIONS
      "#define ${name} ${value}\n"
    )
  endif()
endmacro()

if (SVN_ENABLE_RA_LOCAL)
  add_private_config_definition(
    "Defined if libsvn_ra should link against libsvn_ra_local"
    "SVN_LIBSVN_RA_LINKS_RA_LOCAL" "1"
  )
endif()

if (SVN_ENABLE_RA_SERF)
  add_private_config_definition(
    "Defined if libsvn_ra should link against libsvn_ra_serf"
    "SVN_LIBSVN_RA_LINKS_RA_SERF" "1"
  )
endif()

if (SVN_ENABLE_RA_SVN)
  add_private_config_definition(
    "Defined if libsvn_ra should link against libsvn_ra_svn"
    "SVN_LIBSVN_RA_LINKS_RA_SVN" "1"
  )
endif()

if (SVN_ENABLE_FS_FS)
  add_private_config_definition(
    "Defined if libsvn_fs should link against libsvn_fs_fs"
    "SVN_LIBSVN_FS_LINKS_FS_FS" "1"
  )
endif()

if (SVN_ENABLE_FS_X)
  add_private_config_definition(
    "Defined if libsvn_fs should link against libsvn_fs_x"
    "SVN_LIBSVN_FS_LINKS_FS_X" "1"
  )
endif()

if(SVN_ENABLE_AUTH_GPG_AGENT)
  add_private_config_definition(
    "Is GPG Agent support enabled?"
    "SVN_HAVE_GPG_AGENT" "1"
  )
endif()

if (SVN_DEBUG)
  add_compile_definitions("SVN_DEBUG")
endif()

if(SVN_USE_DSO)
  add_private_config_definition(
    "Defined if svn should try to load DSOs"
    "SVN_USE_DSO" "1"
  )
endif()

add_private_config_definition(
  "Shared library file name suffix format"
  "SVN_DSO_SUFFIX_FMT" "\"%d${CMAKE_SHARED_LIBRARY_SUFFIX}\""
)
add_private_config_definition(
  "Subversion library major version"
  "SVN_SOVERSION" "${SVN_SOVERSION}"
)

if (SVN_ENABLE_TESTS OR 
    SVN_ENABLE_SWIG_PERL_TESTS OR 
    SVN_ENABLE_SWIG_PYTHON_TESTS OR
    SVN_ENABLE_SWIG_RUBY_TESTS OR
    SVN_ENABLE_JAVAHL_TESTS)
  enable_testing()
endif()

if(SVN_BUILD_SHARED_FS)
  set(SVN_FS_BUILD_TYPE SHARED)
else()
  set(SVN_FS_BUILD_TYPE STATIC)
endif()

if(SVN_BUILD_SHARED_RA)
  set(SVN_RA_BUILD_TYPE SHARED)
else()
  set(SVN_RA_BUILD_TYPE STATIC)
endif()

if(SVN_ENABLE_FS_BASE)
  message(SEND_ERROR "SVN_ENABLE_FS_BASE is NOT implemented and deprecated.")
endif()

if(BUILD_SHARED_LIBS OR SVN_BUILD_SHARED_FS OR SVN_BUILD_SHARED_RA)
  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
endif()

if (SVN_ENABLE_SWIG_PERL OR SVN_ENABLE_SWIG_PYTHON OR SVN_ENABLE_SWIG_RUBY)
  find_package(SWIG REQUIRED)
  include(UseSWIG)

  set(SWIG_INCLUDE_DIRECTORIES
    ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/include
    ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig
    ${CMAKE_CURRENT_SOURCE_DIR}/subversion/include

    ${CMAKE_CURRENT_BINARY_DIR}/subversion/bindings/swig/proxy
    ${CMAKE_CURRENT_BINARY_DIR}
  )

  if(SVN_ENABLE_SWIG_PYTHON)
    if(SWIG_VERSION VERSION_LESS "3.0.10")
      message(SEND_ERROR
        "Subversion Python bindings require SWIG 3.0.10 or newer")
    elseif(SWIG_VERSION VERSION_LESS "4.0.0")
      set(SVN_SWIG_PY_OPTS "-py3;-nofastunpack;-modern")
    elseif(SWIG_VERSION VERSION_LESS "4.1.0")
      set(SVN_SWIG_PY_OPTS "-py3;-nofastunpack")
    else()
      set(SVN_SWIG_PY_OPTS "-nofastunpack")
    endif()
  endif()

  if(SVN_ENABLE_SWIG_PERL)
    set(SVN_SWIG_PL_OPTS "-nopm;-noproxy")
  endif()

  if(SVN_ENABLE_SWIG_RUBY)
    if(SWIG_VERSION VERSION_EQUAL "4.2.0")
      message(WARNING
        "Ruby bindings cannot be built with swig 4.2.0, see "
        "https://github.com/swig/swig/issues/2751")
    elseif(SWIG_VERSION VERSION_EQUAL "3.0.8")
      message(WARNING
        "Ruby bindings are known not to support swig 3.0.8, see https://"
        "subversion.apache.org/docs/release-notes/1.11#ruby-swig-issue-602")
    endif()
    set(SVN_SWIG_RB_OPTS)
  endif()
endif()

if(SVN_ENABLE_JAVAHL)
  find_package(Java REQUIRED)
  if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24")
    find_package(JNI REQUIRED COMPONENTS JVM)
  else()
    find_package(JNI REQUIRED)
  endif()
  include(UseJava)

  if(NOT TARGET JNI::JNI)
    add_library(JNI::JNI IMPORTED INTERFACE)
  endif()
  set_property(TARGET JNI::JNI PROPERTY INTERFACE_INCLUDE_DIRECTORIES
    ${JAVA_INCLUDE_PATH})

  set(CMAKE_JAVA_COMPILE_FLAGS)
  if(Java_VERSION VERSION_LESS "9")
    list(APPEND CMAKE_JAVA_COMPILE_FLAGS
      -target 1.8
      -source 1.8
    )
  else()
    list(APPEND CMAKE_JAVA_COMPILE_FLAGS
      --release 8
    )
  endif()

  set(SVN_JAVAHL_SOURCES)
  set(SVN_JAVAHL_TESTS_SOURCES)
  find_jar(JUNIT_JAR NAMES junit4 junit)
  if(NOT JUNIT_JAR OR NOT EXISTS "${JUNIT_JAR}")
    message(SEND_ERROR "The junit jar file does not exist; JUNIT_JAR=${JUNIT_JAR}")
  endif()
endif()

if (MSVC)
  add_compile_options(
    # Setup warning level
    /W4
    # Disable warnings
    /wd4100
    /wd4127
    /wd4206
    /wd4512
    /wd4701
    /wd4706
    /wd4800
    # Treat some criticial warnings as error
    /we4002
    /we4003
    /we4013
    /we4020
    /we4022
    /we4024
    /we4028
    /we4029
    /we4030
    /we4031
    /we4033
    /we4047
    /we4089
    /we4113
    /we4133
    /we4204
    /we4700
    /we4715
    /we4789
    /source-charset:utf-8
  )

  add_compile_definitions(
    "_CRT_SECURE_NO_DEPRECATE"
    "_CRT_NONSTDC_NO_DEPRECATE"
    "_CRT_SECURE_NO_WARNINGS"
  )
else()
  # Assume that all compilers except MSVC are GCC-compatible and support
  # the -W syntax

  include(CheckCompilerFlag)

  # Adds flags if each one is supported by the compiler for the lang
  function(svn_add_compiler_options_ifelse lang)
    if(CMAKE_${lang}_COMPILER)
      foreach(flag ${ARGN})
        if(flag)
          set(variable "HAVE_FLAG_${lang}_${flag}")
          check_compiler_flag(${lang} ${flag} ${variable})
          if(${${variable}})
            add_compile_options($<$<COMPILE_LANGUAGE:${lang}>:${flag}>)
          endif()
        endif()
      endforeach()
    endif()
  endfunction()

  function(SVN_CFLAGS_ADD_IFELSE)
    svn_add_compiler_options_ifelse(C ${ARGN})
  endfunction()

  function(SVN_CXXFLAGS_ADD_IFELSE)
    svn_add_compiler_options_ifelse(CXX ${ARGN})
  endfunction()

  # Add flags that all versions of GCC/G++ (should) support
  add_compile_options(
    -Wpointer-arith
    -Wwrite-strings
    -Wshadow
    -Wformat=2
    -Wunused
    -Wmissing-declarations
    -Wno-multichar
    -Wredundant-decls
    -Winline
    -Wno-long-long
    $<$<COMPILE_LANGUAGE:C>:-Wstrict-prototypes>
    $<$<COMPILE_LANGUAGE:C>:-Wmissing-prototypes>
    $<$<COMPILE_LANGUAGE:C>:-Wnested-externs>
    $<$<COMPILE_LANGUAGE:C>:-Wbad-function-cast>
    $<$<COMPILE_LANGUAGE:CXX>:-Wall>
    $<$<COMPILE_LANGUAGE:CXX>:-Wpointer-arith>
    $<$<COMPILE_LANGUAGE:CXX>:-Wwrite-strings>
    $<$<COMPILE_LANGUAGE:CXX>:-Wshadow>
    $<$<COMPILE_LANGUAGE:CXX>:-Wunused>
    $<$<COMPILE_LANGUAGE:CXX>:-Wunreachable-code>
  )

  # Add each of the following flags only if the C/C++ compiler accepts it.
  SVN_CFLAGS_ADD_IFELSE(
    -Wextra-tokens
    -Wnewline-eof
    -Wshorten-64-to-32
    -Wno-system-headers
    -Wno-format-nonliteral
    -Wmissing-variable-declarations
    -Wno-unused-const-variable
    -Werror=implicit-function-declaration
    -Werror=declaration-after-statement
    -Wold-style-definition
  )
  SVN_CXXFLAGS_ADD_IFELSE(
    -Wextra-tokens
    -Wnewline-eof
    -Wshorten-64-to-32
    -Wno-system-headers
  )
endif()

# Setup modules path

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/cmake")

function(target_exports target_name)
  if (WIN32)
    set(filter_names
      # svn_config_enumerator_t looks like (to our regex) a
      # function declaration for svn_boolean_t
      "svn_boolean_t"
      # Not available on Windows
      "svn_auth_get_keychain_simple_provider"
      "svn_auth_get_keychain_ssl_client_cert_pw_provider"
      "svn_auth_get_gnome_keyring_simple_provider"
      "svn_auth_get_gnome_keyring_ssl_client_cert_pw_provider"
      "svn_auth_get_kwallet_simple_provider"
      "svn_auth_get_kwallet_ssl_client_cert_pw_provider"
      "svn_auth_gnome_keyring_version"
      "svn_auth_kwallet_version"
      "svn_auth_get_gpg_agent_simple_provider"
      "svn_auth_gpg_agent_version"
      # Unavailable in release mode
      "svn_fs_base__trail_debug"
    )

    set(def_file_path ${CMAKE_BINARY_DIR}/${target_name}.def)
    set(headers)

    foreach(file ${ARGN})
      list(APPEND headers "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
    endforeach()

    add_custom_command(
      OUTPUT "${def_file_path}"
      DEPENDS ${headers}
      COMMAND ${CMAKE_COMMAND}
              "-DEXPORT_HEADER_FILE_PATHS=${headers}"
              "-DEXPORT_DEF_FILE_PATH=${def_file_path}"
              "-DEXPORT_BLACKLIST=${filter_names}"
              -P "${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/extractor.cmake"
      WORKING_DIRECTORY "${SERF_SOURCE_DIR}"
    )

    target_sources("${target_name}" PRIVATE "${def_file_path}")
  endif()
endfunction()

if (NOT EXISTS "${CMAKE_SOURCE_DIR}/build/cmake/targets.cmake")
  message(SEND_ERROR
    "The 'build/cmake/targets.cmake' file does NOT exist. "
    "Use the following command to generate it:\n"
    "  python gen-make.py -t cmake"
  )
endif()

### Intl

if(SVN_ENABLE_NLS)
  # Note: when installing these dependencies with vcpkg, you will need to
  # install 'gettext' package with 'tools' feature. Use the following command
  # for this: `./vcpkg install gettext[tools]`. This package contains both,
  # Gettext and Intl dependencies.
  find_package(Gettext REQUIRED)
  find_package(Intl REQUIRED)

  add_library(external-intl ALIAS Intl::Intl)

  add_private_config_definition(
    "Define to 1 if translation of program messages to the user's native language is requested."
    "ENABLE_NLS" "1"
  )

  if (NOT WIN32)
    add_private_config_definition(
      "Defined to be the path to the installed locale dirs"
      "SVN_LOCALE_DIR" "\"${CMAKE_INSTALL_PREFIX}/share/locale\""
    )
  endif()

  file(GLOB SVN_PO_FILES "subversion/po/*.po")
  set(SVN_MO_FILES)

  foreach(po_file ${SVN_PO_FILES})
    get_filename_component(lang ${po_file} NAME_WLE)
    set(mo_file "${CMAKE_BINARY_DIR}/${lang}.mo")

    add_custom_command(
      DEPENDS
        "${po_file}"
      OUTPUT
        "${mo_file}"
      COMMAND
        "${GETTEXT_MSGFMT_EXECUTABLE}" -c -o ${mo_file} ${po_file}
    )
    list(APPEND SVN_MO_FILES ${mo_file})
    install(
      FILES "${mo_file}"
      DESTINATION "share/locale/${lang}/LC_MESSAGES"
      RENAME "subversion.mo"
    )
  endforeach()

  add_custom_target(locale ALL SOURCES ${SVN_MO_FILES})
else()
  # Declare empty target for Intl if we don't use it.
  add_library(external-intl INTERFACE)
endif()

# Link all targets with Intl library. The 'external-intl' target is always,
# even if we don't use NLS functionality.
#
# Following the CMake documentation [1], the link_libraries affects only on
# the targets declared later, so it should be here.
#
# [1] https://cmake.org/cmake/help/latest/command/link_libraries.html
#     -- "Link libraries to all targets added later."
link_libraries(external-intl)

### Httpd

if(SVN_ENABLE_APACHE_MODULES)
  find_package(Httpd REQUIRED)
  add_library(external-libhttpd ALIAS httpd::httpd)
  add_library(external-mod_dav ALIAS httpd::mod_dav)
endif()

add_library(ra-libs INTERFACE)
add_library(fs-libs INTERFACE)

include("build/cmake/targets.cmake")

# Require pkg-config if we are going to use it, to show the `Found PkgConfig`
# meassge and insure it has actually been found. (yea, this invokes the module
# for second time, but we are guaranteed to from it to not perform actual look
# for the path due to the cache. It's fine to include the same modules for
# multiple times).
if(SVN_USE_PKG_CONFIG)
  find_package(PkgConfig REQUIRED)
endif()

### APR and APR-Util

if(SVN_USE_PKG_CONFIG)
  pkg_search_module(apr REQUIRED IMPORTED_TARGET apr-2 apr-1)
  add_library(external-apr ALIAS PkgConfig::apr)

  if(APR_VERSION VERSION_LESS 2.0.0)
    # apr-1
    pkg_check_modules(aprutil-1 REQUIRED IMPORTED_TARGET apr-util-1)
    add_library(external-aprutil ALIAS PkgConfig::aprutil-1)
    set(SVN_APR_MAJOR_VERSION 1)
  else()
    # apr-2
    add_library(external-aprutil ALIAS PkgConfig::apr)
    set(SVN_APR_MAJOR_VERSION 2)
  endif()
else()
  find_package(APR REQUIRED)
  add_library(external-apr ALIAS apr::apr)

  if(APR_VERSION VERSION_LESS 2.0.0)
    find_package(APRUtil REQUIRED)
    add_library(external-aprutil ALIAS apr::aprutil)
  else()
    add_library(external-aprutil ALIAS apr::apr)
  endif()
endif()

### ZLIB

if(SVN_USE_PKG_CONFIG)
  pkg_check_modules(zlib REQUIRED IMPORTED_TARGET zlib)
  add_library(external-zlib ALIAS PkgConfig::zlib)
  set(SVN_ZLIB_LIBS ${zlib_LDFLAGS})
else()
  find_package(ZLIB REQUIRED)
  add_library(external-zlib ALIAS ZLIB::ZLIB)
endif()

### EXPAT

if(SVN_USE_PKG_CONFIG)
  pkg_check_modules(expat REQUIRED IMPORTED_TARGET expat)
  add_library(external-xml ALIAS PkgConfig::expat)
  set(SVN_XML_LIBS ${expat_LDFLAGS})
else()
  find_package(EXPAT REQUIRED)
  add_library(external-xml ALIAS EXPAT::EXPAT)
endif()

### LZ4

if(SVN_USE_INTERNAL_LZ4)
  add_library(external-lz4 INTERFACE)
  target_compile_definitions(external-lz4 INTERFACE "SVN_INTERNAL_LZ4")

  read_version(
    "subversion/libsvn_subr/lz4/lz4internal.h" lz4_VERSION
    LZ4_VERSION_MAJOR LZ4_VERSION_MINOR LZ4_VERSION_RELEASE
  )
elseif(SVN_USE_PKG_CONFIG)
  pkg_check_modules(lz4 REQUIRED IMPORTED_TARGET liblz4)
  add_library(external-lz4 ALIAS PkgConfig::lz4)
  set(SVN_LZ4_LIBS ${lz4_LDFLAGS})
else()
  find_package(lz4 CONFIG REQUIRED)
  add_library(external-lz4 ALIAS lz4::lz4)
endif()

### UTF8PROC

if(SVN_USE_INTERNAL_UTF8PROC)
  add_library(external-utf8proc INTERFACE)
  target_compile_definitions(external-utf8proc INTERFACE "SVN_INTERNAL_UTF8PROC")

  read_version(
    "subversion/libsvn_subr/utf8proc/utf8proc_internal.h" UTF8PROC_VERSION
    UTF8PROC_VERSION_MAJOR UTF8PROC_VERSION_MINOR UTF8PROC_VERSION_PATCH
  )
elseif(SVN_USE_PKG_CONFIG)
  pkg_check_modules(utf8proc REQUIRED IMPORTED_TARGET libutf8proc)
  add_library(external-utf8proc ALIAS PkgConfig::utf8proc)
  set(SVN_UTF8PROC_LIBS ${utf8proc_LDFLAGS})
else()
  find_package(UTF8PROC REQUIRED)
  add_library(external-utf8proc ALIAS UTF8PROC::UTF8PROC)
endif()

### SQLite3

if(SVN_SQLITE_USE_AMALGAMATION)
  find_package(SQLiteAmalgamation REQUIRED)
  add_library(external-sqlite ALIAS SQLite::SQLite3Amalgamation)
elseif(SVN_USE_PKG_CONFIG)
  pkg_check_modules(sqlite3 REQUIRED IMPORTED_TARGET sqlite3)
  add_library(external-sqlite ALIAS PkgConfig::sqlite3)
else()
  # It should be not required.
  find_package(SQLite3)

  if(SQLite3_FOUND)
    # Support for CMake < 4.3
    # In prior versions of cmake, the sqlite targets were exported in the
    # SQLite namespace.
    if(TARGET SQLite3::SQLite3)
      add_library(external-sqlite ALIAS SQLite3::SQLite3)
    else()
      add_library(external-sqlite ALIAS SQLite::SQLite3)
    endif()
  else()
    find_package(SQLiteAmalgamation REQUIRED)
    add_library(external-sqlite ALIAS SQLite::SQLite3Amalgamation)

    # Is implicitness an actual problem? This warning could be removed
    # if it isn't.
    message(WARNING
      "Implicitly using SQLite amalgamation; enable"
      "SVN_SQLITE_USE_AMALGAMATION option to force it."
    )
  endif()
endif()

### Serf
if (SVN_ENABLE_RA_SERF)
  if(SVN_USE_PKG_CONFIG)
    pkg_search_module(serf IMPORTED_TARGET REQUIRED serf-2 serf-1>=1.3.4)
    add_library(external-serf ALIAS PkgConfig::serf)
  else()
    find_package(Serf 1.3.4 REQUIRED)
    add_library(external-serf ALIAS Serf::Serf)
  endif()
endif()

if (SVN_CHECKSUM_BACKEND STREQUAL "apr")
  add_library(external-checksum-libs INTERFACE)
  add_private_config_definition(
    "Defined if svn should use APR to compute checksums."
    "SVN_CHECKSUM_BACKEND_APR" "1"
  )
elseif (SVN_CHECKSUM_BACKEND STREQUAL "openssl")
  find_package(OpenSSL REQUIRED)
  add_library(external-checksum-libs ALIAS OpenSSL::Crypto)
  add_private_config_definition(
    "Defined if svn should use OpenSSL to compute checksums."
    "SVN_CHECKSUM_BACKEND_OPENSSL" "1"
  )
elseif (SVN_CHECKSUM_BACKEND STREQUAL "bcrypt")
  if (NOT WIN32)
    message(SEND_ERROR "BCrypt checksum backend is only available on Win32 platform.")
  endif()

  add_library(external-checksum-libs INTERFACE)
  target_link_libraries(external-checksum-libs INTERFACE Bcrypt.lib)

  add_private_config_definition(
    "Defined if svn should use BCrypt to compute checksums."
    "SVN_CHECKSUM_BACKEND_BCRYPT" "1"
  )
elseif (SVN_CHECKSUM_BACKEND STREQUAL "xdigest")
  if (SVN_USE_PKG_CONFIG)
    pkg_check_modules(xdigest REQUIRED IMPORTED_TARGET xdigest)
    add_library(external-checksum-libs ALIAS PkgConfig::xdigest)
  else()
    find_package(XDIGEST REQUIRED)
    add_library(external-checksum-libs ALIAS XDIGEST::XDIGEST)
  endif()

  add_private_config_definition(
    "Defined if svn should use xdigest to compute checksums."
    "SVN_CHECKSUM_BACKEND_XDIGEST" "1"
  )
else()
  message(SEND_ERROR
    "Invalid value of SVN_CHECKSUM_BACKEND: '${SVN_CHECKSUM_BACKEND}'. "
    "Possible options are 'apr', 'openssl', 'bcrypt', 'xdigest'."
  )
endif()

### Python

if(SVN_ENABLE_SWIG_PYTHON)
  find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
elseif(SVN_ENABLE_TESTS)
  find_package(Python3 REQUIRED COMPONENTS
      Interpreter
  )
endif()

### KWallet

if(SVN_ENABLE_AUTH_KWALLET)
  if(NOT BUILD_SHARED_LIBS)
    message(SEND_ERROR "SVN_ENABLE_AUTH_KWALLET is not supported in static build.")
  endif()

  find_package(KF5Wallet REQUIRED)
  find_package(KF5CoreAddons REQUIRED)
  find_package(KF5I18n REQUIRED)
  find_package(DBus1 REQUIRED)
  find_package(Qt5 COMPONENTS Core REQUIRED)

  add_library(external-kwallet INTERFACE)
  target_link_libraries(external-kwallet INTERFACE
    KF5::Wallet
    KF5::CoreAddons
    KF5::I18n
    Qt5::Core
    dbus-1
  )
  target_compile_definitions(external-kwallet INTERFACE SVN_HAVE_KF5)

  add_private_config_definition(
    "Defined if KWallet support is enabled"
    "SVN_HAVE_KWALLET" "1"
  )

endif()

### GNOME Keyring

if(SVN_ENABLE_AUTH_GNOME_KEYRING)
  add_library(external-gnome-keyring INTERFACE)

  if(SVN_USE_PKG_CONFIG OR PKG_CONFIG_FOUND)
    pkg_check_modules(libsecret-1 REQUIRED IMPORTED_TARGET libsecret-1)
    target_link_libraries(external-gnome-keyring INTERFACE PkgConfig::libsecret-1)
  else()
    message(SEND_ERROR "GNOME Keyring requires pkg-config")
  endif()

  add_private_config_definition(
    "Is libsecret support enabled?"
    "SVN_HAVE_LIBSECRET" "1"
  )
endif()

if (SVN_ENABLE_TUI)
  add_library(external-ncurses INTERFACE)

  if(SVN_USE_PKG_CONFIG)
    pkg_check_modules(ncurses REQUIRED IMPORTED_TARGET ncurses)
    target_link_libraries(external-ncurses INTERFACE PkgConfig::ncurses)
    set(SVN_NCURSES_LIBS ${ncurses_LDFLAGS})
  else()
    find_package(CURSES REQUIRED)
    target_link_libraries(external-ncurses INTERFACE CURSES::CURSES)
  endif()
endif()

add_library(external-sasl INTERFACE)
if (SVN_ENABLE_SASL)
  if(SVN_USE_PKG_CONFIG)
    pkg_check_modules(libsasl2 REQUIRED IMPORTED_TARGET libsasl2>=2.0.0)
    target_link_libraries(external-sasl INTERFACE PkgConfig::libsasl2)
    set(SVN_SASL_LIBS ${libsasl2_LDFLAGS})
  else()
    find_package(SASL 2.0.0 REQUIRED)
    target_link_libraries(external-sasl INTERFACE SASL::SASL)
  endif()

  add_private_config_definition(
    "Defined if Cyrus SASL v2 is present on the system"
    "SVN_HAVE_SASL" "1"
  )
endif()

add_library(external-magic INTERFACE)
if (SVN_ENABLE_LIBMAGIC)
  if(SVN_USE_PKG_CONFIG)
    pkg_check_modules(libmagic REQUIRED IMPORTED_TARGET libmagic)
    target_link_libraries(external-magic INTERFACE PkgConfig::libmagic)
    set(SVN_MAGIC_LIBS ${libmagic_LDFLAGS})
  else()
    find_package(MAGIC REQUIRED)
    target_link_libraries(external-magic INTERFACE MAGIC::MAGIC)
  endif()

  add_private_config_definition(
    "Defined if libmagic support is enabled"
    "SVN_HAVE_LIBMAGIC" "1"
  )
endif()

if(SVN_ENABLE_SWIG_PERL OR SVN_ENABLE_SWIG_PYTHON OR SVN_ENABLE_SWIG_RUBY)
  file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/subversion/bindings/swig/proxy")

  add_library(external-swig INTERFACE)

  file(GLOB swig_headers_input "${CMAKE_CURRENT_SOURCE_DIR}/subversion/include/*.h")
  set(swig_headers_output)
  foreach(swig_header ${swig_headers_input})
    get_filename_component(filename ${swig_header} NAME_WLE)
    set(output "${CMAKE_CURRENT_BINARY_DIR}/subversion/bindings/swig/proxy/${filename}_h.swg")
    list(APPEND swig_headers_output ${output})

    add_custom_command(
      DEPENDS
        "${swig_header}"
      OUTPUT
        "${output}"
      WORKING_DIRECTORY
        "${CMAKE_CURRENT_BINARY_DIR}"
      COMMAND
        "${Python3_EXECUTABLE}"
        "${CMAKE_CURRENT_SOURCE_DIR}/build/generator/swig/header_wrappers.py"
        "${CMAKE_CURRENT_SOURCE_DIR}/build.conf"
        "${SWIG_EXECUTABLE}"
        "${swig_header}"
      COMMAND_EXPAND_LISTS
    )
  endforeach()

  add_custom_target(swig_headers DEPENDS ${swig_headers_output})
  add_dependencies(external-swig swig_headers)
endif()

function(swig_target_external_runtime target lang)
  set(swig_runtime_path "${CMAKE_CURRENT_BINARY_DIR}/subversion/bindings/swig/proxy/swig_${lang}_external_runtime.swg")
  add_custom_command(
    OUTPUT ${swig_runtime_path}
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMAND
      "${Python3_EXECUTABLE}"
      "${CMAKE_CURRENT_SOURCE_DIR}/build/generator/swig/external_runtime.py"
      "${CMAKE_CURRENT_SOURCE_DIR}/build.conf"
      "${SWIG_EXECUTABLE}"
      "${lang}"
    COMMAND_EXPAND_LISTS
  )
  target_sources(${target} INTERFACE ${swig_runtime_path})
endfunction()

function(test_prepend_builddir_to_path name)
  set(dir "$<SHELL_PATH:$<TARGET_FILE_DIR:svn>>")
  if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.22")
    set_property(TEST ${name} APPEND PROPERTY ENVIRONMENT_MODIFICATION
      "PATH=path_list_prepend:${dir}"
    )
  else()
    if(WIN32)
      # Replace <;> with <\;> to prevent conversion to a list
      string(REPLACE ";" "\\;" value "PATH=${dir};$ENV{PATH}")
    else()
      set(value "PATH=${dir}:$ENV{PATH}")
    endif()
    set_property(TEST ${name} APPEND PROPERTY ENVIRONMENT "${value}")
  endif()
endfunction()

if(SVN_ENABLE_SWIG_PYTHON)
  find_package(PY3C REQUIRED)

  add_library(external-python INTERFACE)
  target_link_libraries(external-python INTERFACE
    Python3::Module
    Python::py3c
  )
  target_include_directories(external-python INTERFACE
    ${SWIG_INCLUDE_DIRECTORIES}
    ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/python/libsvn_swig_py
  )
  swig_target_external_runtime(external-python python)

  add_custom_command(TARGET libsvn_swig_py POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_directory
      "${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/python/svn"
      "${CMAKE_CURRENT_BINARY_DIR}/swig-python/svn"
    COMMAND ${CMAKE_COMMAND} -E make_directory
      "${CMAKE_CURRENT_BINARY_DIR}/swig-python/libsvn"
    COMMAND ${CMAKE_COMMAND} -E copy
      "${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/python/__init__.py"
      "${CMAKE_CURRENT_BINARY_DIR}/swig-python/libsvn/__init__.py"
  )
  install(
    DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/python/svn/"
    DESTINATION "${SVN_SWIG_PYTHON_SITELIB}/svn"
    FILES_MATCHING
      PATTERN "__pycache__" EXCLUDE
      PATTERN "*.py"
  )
  install(
    DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/swig-python/libsvn/"
    DESTINATION "${SVN_SWIG_PYTHON_SITEARCH}/libsvn"
    FILES_MATCHING
      PATTERN "__pycache__" EXCLUDE
      PATTERN "*.py"
  )
  install(CODE [==[
    execute_process(
      COMMAND
        "${Python3_EXECUTABLE}" -m compileall -q
        "${SVN_SWIG_PYTHON_SITELIB}/svn"
        "${SVN_SWIG_PYTHON_SITEARCH}/libsvn"
    )
  ]==])

  if (SVN_ENABLE_SWIG_PYTHON_TESTS)
    add_test(
      NAME swig-python
      COMMAND
        "${Python3_EXECUTABLE}"
        ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/python/tests/run_all.py
        --verbose
      WORKING_DIRECTORY
        "${CMAKE_CURRENT_BINARY_DIR}/swig-python"
    )
    if(WIN32 OR CYGWIN)
      test_prepend_builddir_to_path(swig-python)
    endif()
  endif()
endif()

if(SVN_ENABLE_SWIG_PERL)
  find_package(Perl REQUIRED)
  find_package(PerlLibs REQUIRED)
  if(SVN_ENABLE_SWIG_PERL_MAN_PAGES)
    find_program(POD2MAN_EXECUTABLE NAMES pod2man REQUIRED)
  endif()

  separate_arguments(PERL_EXTRA_C_FLAGS)

  add_library(external-perl IMPORTED INTERFACE)
  target_include_directories(external-perl INTERFACE
    ${PERL_INCLUDE_PATH}
    ${SWIG_INCLUDE_DIRECTORIES}
    ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/perl/libsvn_swig_perl
  )
  target_compile_options(external-perl INTERFACE
    $<$<C_COMPILER_ID:MSVC>:/FIswigutil_pl__pre_perl.h>
    ${PERL_EXTRA_C_FLAGS}
  )
  target_link_libraries(external-perl INTERFACE ${PERL_LIBRARY})
  swig_target_external_runtime(external-perl perl)

  set(SVN_SWIG_PERL_PM_FILES)
  file(GLOB SVN_SWIG_PERL_PM_FILES
    "${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/perl/native/*.pm")
  add_custom_command(TARGET libsvn_swig_perl POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E make_directory
      "${CMAKE_CURRENT_BINARY_DIR}/swig-perl/lib/SVN"
      "${CMAKE_CURRENT_BINARY_DIR}/swig-perl/man"
    COMMAND ${CMAKE_COMMAND} -E copy
    ${SVN_SWIG_PERL_PM_FILES}
      "${CMAKE_CURRENT_BINARY_DIR}/swig-perl/lib/SVN"
  )
  if(SVN_ENABLE_SWIG_PERL_MAN_PAGES)
    foreach(name ${SVN_SWIG_PERL_PM_FILES})
      get_filename_component(name ${name} NAME_WLE)
      add_custom_command(TARGET libsvn_swig_perl POST_BUILD
        COMMAND ${POD2MAN_EXECUTABLE} --section=3pm
          "${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/perl/native/${name}.pm"
          "${CMAKE_CURRENT_BINARY_DIR}/swig-perl/man/SVN::${name}.3pm"
      )
    endforeach()
  endif()

  install(
    DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/swig-perl/lib/SVN/"
    DESTINATION "${SVN_SWIG_PERL_SITEARCH}/SVN"
    FILES_MATCHING PATTERN "*.pm"
  )
  if(SVN_ENABLE_SWIG_PERL_MAN_PAGES)
    install(
      DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/swig-perl/man/"
      DESTINATION "${SVN_SWIG_PERL_MAN3DIR}"
      FILES_MATCHING PATTERN "*.3pm"
    )
  endif()

  if (SVN_ENABLE_SWIG_PERL_TESTS)
    add_test(
      NAME swig-perl
      COMMAND
        ${PERL_EXECUTABLE}
        "-I${CMAKE_CURRENT_BINARY_DIR}/swig-perl/lib"
        -MTest::Harness
        -e
        "$Test::Harness::verbose = 1; runtests(glob('t/*.t'))"
      WORKING_DIRECTORY
        ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/perl/native
    )
    if(WIN32 OR CYGWIN)
      test_prepend_builddir_to_path(swig-perl)
    endif()
  endif()
endif()

if(SVN_ENABLE_SWIG_RUBY)
  find_package(Ruby REQUIRED)

  add_library(external-ruby IMPORTED INTERFACE)
  target_include_directories(external-ruby INTERFACE
    ${Ruby_INCLUDE_DIRS}
    ${SWIG_INCLUDE_DIRECTORIES}
    ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/ruby/libsvn_swig_ruby
  )
  target_compile_options(external-ruby INTERFACE
    $<$<C_COMPILER_ID:MSVC>:/FIswigutil_rb__pre_ruby.h>
  )
  target_compile_definitions(external-ruby INTERFACE
    HAVE_RB_ERRINFO
    $<$<BOOL:${WIN32}>:SVN_SWIG_RUBY__CUSTOM_RUBY_CONFIG>
  )
  target_link_libraries(external-ruby INTERFACE ${Ruby_LIBRARY})
  swig_target_external_runtime(external-ruby ruby)

  install(
    DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/ruby/svn/"
    DESTINATION "${SVN_SWIG_RUBY_SITELIB}/svn"
    FILES_MATCHING PATTERN "*.rb"
  )

  if (SVN_ENABLE_SWIG_RUBY_TESTS)
    add_test(
      NAME swig-ruby
      COMMAND
        "${Ruby_EXECUTABLE}"
        "-I${CMAKE_CURRENT_BINARY_DIR}/swig-ruby"
        "-I${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/ruby"
        test/run-test.rb
        --collector=dir
        --verbose=v
      WORKING_DIRECTORY
        ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/swig/ruby
    )
    set_property(TEST swig-ruby APPEND PROPERTY ENVIRONMENT
      "SVN_TEST_SWIG_RUBY=ctest"
    )
    # svnserve in the build directory is launched by the tests
    test_prepend_builddir_to_path(swig-ruby)
  endif()
endif()

if(SVN_ENABLE_JAVAHL)
  file(READ
    "${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/javahl/Manifest.in"
    SVN_JAVAHL_MANIFEST
  )
  string(REPLACE "%bundleVersion" "${SVN_VERSION}"
    SVN_JAVAHL_MANIFEST "${SVN_JAVAHL_MANIFEST}"
  )
  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/javahl/Manifest"
    "${SVN_JAVAHL_MANIFEST}"
  )
  add_jar(svn-javahl
    SOURCES ${SVN_JAVAHL_SOURCES} ${SVN_JAVAHL_TESTS_SOURCES}
    INCLUDE_JARS "${JUNIT_JAR}"
    MANIFEST "${CMAKE_CURRENT_BINARY_DIR}/javahl/Manifest"
    GENERATE_NATIVE_HEADERS svn-javahl.headers
      DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/javahl/include"
    OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/javahl/lib"
  )
  add_custom_command(TARGET libsvnjavahl PRE_BUILD
    COMMAND ${CMAKE_COMMAND} -E make_directory
      "${CMAKE_CURRENT_BINARY_DIR}/javahl/native"
  )
  target_link_libraries(libsvnjavahl PRIVATE svn-javahl.headers)
  add_library(external-java-sdk INTERFACE)
  target_link_libraries(external-java-sdk INTERFACE
    JNI::JNI
  )
  target_include_directories(external-java-sdk INTERFACE
    ${JNI_INCLUDE_DIRS}
    ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/javahl/native
    ${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/javahl/native/jniwrapper
    ${CMAKE_CURRENT_BINARY_DIR}/javahl/native
  )
  target_link_libraries(external-java-sdk INTERFACE
    ${JNI_LIBRARIES}
  )

  if(SVN_ENABLE_JAVAHL_TESTS)
    function(add_javahl_tests target)
      if(WIN32)
        set(sep "\\;")
      else()
        set(sep ":")
      endif()
      string(JOIN ${sep} classpath
        "${CMAKE_CURRENT_BINARY_DIR}/javahl/lib/svn-javahl.jar"
        "${JUNIT_JAR}"
      )
      set(rootdir "${CMAKE_CURRENT_BINARY_DIR}/Testing/${target}")
      file(MAKE_DIRECTORY "${rootdir}")

      set(test_args)
      if(Java_VERSION VERSION_GREATER_EQUAL "24")
        list(APPEND test_args
          --enable-native-access=ALL-UNNAMED
        )
      endif()
      add_test(NAME ${target}
        COMMAND
          ${Java_JAVA_EXECUTABLE}
          -Xcheck:jni
          -Djava.library.path=$<TARGET_FILE_DIR:libsvnjavahl>
          -Dtest.rootdir=${rootdir}
          -Dtest.srcdir=${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/javahl
          -classpath
          "${classpath}"
          ${test_args}
          ${ARGN}
        WORKING_DIRECTORY
          "${rootdir}"
      )
      if(WIN32 OR CYGWIN)
        test_prepend_builddir_to_path(${target})
      endif()
    endfunction()

    add_javahl_tests(javahl-tests-apache org.apache.subversion.javahl.RunTests)
    add_javahl_tests(javahl-tests-tigris org.tigris.subversion.javahl.RunTests)
    add_javahl_tests(javahl-tests-deprecated-authn
      "-Dtest.authn.deprecated=true" org.apache.subversion.javahl.RunTests
    )
  endif()

  install_jar(svn-javahl DESTINATION "${SVN_JAVAHL_DIR}")
endif()

### Checks

include(CheckIncludeFiles)
include(CheckSymbolExists)

macro(autocheck_include_files INCLUDE VARIABLE)
  check_include_files(${INCLUDE} ${VARIABLE})

  if(${VARIABLE})
    add_private_config_definition(
      "Define to 1 if you have the <${INCLUDE}> header file."
      "${VARIABLE}" "1"
    )
  endif()
endmacro()

macro(autocheck_symbol_exists SYMBOL FILE VARIABLE)
  check_symbol_exists(${SYMBOL} ${FILE} ${VARIABLE})

  if(${VARIABLE})
    add_private_config_definition(
      "Define to 1 if you have the `${SYMBOL}' function."
      "${VARIABLE}" "1"
    )
  endif()
endmacro()

autocheck_symbol_exists("snprintf" "stdio.h" HAVE_SNPRINTF)

autocheck_include_files("elf.h" HAVE_ELF_H)
autocheck_include_files("inttypes.h" HAVE_INTTYPES_H)
autocheck_include_files("stdbool.h" HAVE_STDBOOL_H)
autocheck_include_files("stdint.h" HAVE_STDINT_H)

autocheck_include_files("sys/utsname.h" HAVE_SYS_UTSNAME_H)
if (HAVE_SYS_UTSNAME_H)
  autocheck_symbol_exists("uname" "sys/utsname.h" HAVE_UNAME)
endif()

autocheck_include_files("sys/types.h" HAVE_SYS_TYPES_H)

autocheck_include_files("termios.h" HAVE_TERMIOS_H)
if(HAVE_TERMIOS_H)
  autocheck_symbol_exists("tcgetattr" "termios.h" HAVE_TCGETATTR)
  autocheck_symbol_exists("tcsetattr" "termios.h" HAVE_TCSETATTR)
endif()

autocheck_include_files("unistd.h" HAVE_UNISTD_H)
if (HAVE_UNISTD_H)
  autocheck_symbol_exists("symlink" "unistd.h" HAVE_SYMLINK)
  autocheck_symbol_exists("readlink" "unistd.h" HAVE_READLINK)
  autocheck_symbol_exists("getpid" "unistd.h" HAVE_GETPID)
endif()

set(CMAKE_REQUIRED_LIBRARIES external-zlib)
autocheck_symbol_exists("adler32_z" "zlib.h" SVN_ZLIB_HAS_ADLER32_Z)
unset(CMAKE_REQUIRED_LIBRARIES)

include_directories("${CMAKE_CURRENT_BINARY_DIR}")

file(GLOB public_headers "subversion/include/*.h")
install(FILES ${public_headers} DESTINATION "include/subversion-1")

if(SVN_INSTALL_PRIVATE_H)
  file(GLOB private_headers "subversion/include/private/*.h")
  install(FILES ${private_headers} DESTINATION "include/subversion-1/private")
endif()

if(SVN_ENABLE_SVNXX)
  install(
    DIRECTORY "subversion/bindings/cxx/include/"
    DESTINATION "include/subversion-1"
  )
endif()

if (WIN32)
  add_compile_definitions(
    "alloca=_alloca"
    "WIN32"
  )
endif()

if(APPLE)
  add_compile_definitions("DARWIN")
endif()

# Build shared libraries and theirs implibs with 'lib' prefix, for example
# libsvn_subr-1.[lib|a] and libsvn_subr-1.[dll|so]
set(CMAKE_SHARED_LIBRARY_PREFIX "lib")
set(CMAKE_IMPORT_LIBRARY_PREFIX "lib")

# This tells CMake to build static libraries without any prefix
# (just svn_subr-1.[lib|a])
set(CMAKE_STATIC_LIBRARY_PREFIX "")

if(SVN_ENABLE_TESTS)
  find_package(Python3 COMPONENTS Interpreter REQUIRED)
  set(run_tests_script "${CMAKE_CURRENT_SOURCE_DIR}/build/run_tests.py")
  set(list_tests_script "${CMAKE_CURRENT_SOURCE_DIR}/build/list_tests.py")
  set(test_base_dir "${CMAKE_CURRENT_BINARY_DIR}/Testing")

  function(add_py_test name prog)
    if(SVN_TEST_CONFIGURE_FOR_PARALLEL)
      set(test_root "${test_base_dir}/${name}")
    else()
      set(test_root "${test_base_dir}")
    endif()

    file(MAKE_DIRECTORY "${test_root}/subversion/tests/cmdline")

    set(test_args
      --bin ${binary_dir}
      --tools-bin ${binary_dir}
      --verbose
      --log-to-stdout
      --set-log-level=WARNING
    )
    if(SVN_TEST_CLEANUP)
      list(APPEND test_args --cleanup)
    endif()
    if(SVN_TEST_CHECK_XML_SCHEMA)
      list(APPEND test_args --check-xml-schema)
    endif()
    list(APPEND test_args
      ${SVN_TEST_COMMAND_ARGUMENTS}
      ${CMAKE_CURRENT_SOURCE_DIR}
      ${test_root}
      "${prog}"
    )

    add_test(
      NAME
        "${name}"
      COMMAND
        "${Python3_EXECUTABLE}" "${run_tests_script}" ${test_args}
      WORKING_DIRECTORY
        ${test_root}
    )
  endfunction()

  file(GLOB PYTHON_TESTS
     "subversion/tests/cmdline/*_tests.py"
  )

  set(binary_dir $<TARGET_FILE_DIR:svn>)

  if(SVN_TEST_EXPAND)
    execute_process(
      COMMAND
        "${Python3_EXECUTABLE}" "${list_tests_script}"
        ${PYTHON_TESTS}
        OUTPUT_VARIABLE tests_list_output
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        RESULT_VARIABLE command_result
    )

    if (command_result)
      message(SEND_ERROR "list_tests.py failed.")
    endif()

    string(REGEX MATCHALL "[^\n\r]+" tests_list "${tests_list_output}")

    foreach(test_case ${tests_list})
      if(test_case MATCHES "(.+)#(.+)")
        set(py_test_abspath "${CMAKE_MATCH_1}")
        set(py_test_num "${CMAKE_MATCH_2}")

        get_filename_component(py_test_name ${py_test_abspath} NAME_WLE)
        file(RELATIVE_PATH py_test_relpath ${CMAKE_CURRENT_SOURCE_DIR} ${py_test_abspath})

        add_py_test(
          "cmdline.${py_test_name}.${py_test_num}"
          "${py_test_relpath}#${py_test_num}"
        )
      endif()
    endforeach()
  else()
    foreach(py_test_abspath ${PYTHON_TESTS})
      # Keep `.py'.
      get_filename_component(py_test_name ${py_test_abspath} NAME_WLE)
      file(RELATIVE_PATH py_test_relpath ${CMAKE_CURRENT_SOURCE_DIR} ${py_test_abspath})

      add_py_test(
        "cmdline.${py_test_name}"
        "${py_test_relpath}"
      )
    endforeach()
  endif()
endif()

if (SVN_USE_PKG_CONFIG)
  file(GLOB pc_files "${CMAKE_CURRENT_SOURCE_DIR}/subversion/libsvn_*/*.pc.in")

  # setup template variables
  set(PACKAGE_VERSION ${SVN_VERSION})
  set(prefix "${CMAKE_INSTALL_PREFIX}")
  set(exec_prefix "\${prefix}")
  set(libdir "\${exec_prefix}/lib")
  set(includedir "\${prefix}/include")

  foreach (input_file ${pc_files})
    get_filename_component(name ${input_file} NAME_WLE)
    set(output_file "${CMAKE_CURRENT_BINARY_DIR}/${name}")

    # @ONLY to remove ${variable} syntax that overlaps with pkg-config
    # variables
    configure_file(${input_file} ${output_file} @ONLY)

    install(
      FILES ${output_file}
      DESTINATION "lib/pkgconfig"
    )

    unset(output_file)
    unset(name)
  endforeach()

  unset(PACKAGE_VERSION)
  unset(prefix)
  unset(exec_prefix)
  unset(libdir)
  unset(includedir)
endif()

if (SVN_ENABLE_SVNXX)
  target_include_directories(libsvnxx PUBLIC
    "${CMAKE_CURRENT_SOURCE_DIR}/subversion/bindings/cxx/include"
  )
endif()

if(SVN_USE_WIN32_CRASHHANDLER)
  target_compile_definitions(libsvn_subr PRIVATE
    "SVN_USE_WIN32_CRASHHANDLER"
    "SVN_WIN32_CRASHREPORT_EMAIL=\"users@subversion.apache.org\""
  )
endif()

string(TOLOWER "${CMAKE_HOST_SYSTEM_PROCESSOR}-${CMAKE_HOST_SYSTEM_NAME}" SVN_BUILD_HOST)
string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_SYSTEM_NAME}" SVN_BUILD_TARGET)

configure_file(
  "${CMAKE_CURRENT_SOURCE_DIR}/subversion/svn_private_config.hc"
  "${CMAKE_CURRENT_BINARY_DIR}/svn_private_config.h"
)

message(STATUS "Configuration summary:")
message(STATUS "  Version ......................... : ${SVN_VERSION}")
message(STATUS "  C compiler ...................... : ${CMAKE_C_COMPILER_ID} ${CMAKE_C_COMPILER_VERSION}")
message(STATUS "  Build type ...................... : ${CMAKE_BUILD_TYPE}")
message(STATUS "    Build shared libraries ........ : ${BUILD_SHARED_LIBS}")
message(STATUS "    Build shared FS Modues ........ : ${SVN_BUILD_SHARED_FS}")
message(STATUS "    Build shared RA Modues ........ : ${SVN_BUILD_SHARED_RA}")
message(STATUS "    Build TUI applications ........ : ${SVN_ENABLE_TUI}")
message(STATUS "    Use pkg-config dependencies ... : ${SVN_USE_PKG_CONFIG}")
message(STATUS "    Checksum Backend .............. : ${SVN_CHECKSUM_BACKEND}")
message(STATUS "  FS modules:")
message(STATUS "    Enable FSFS ................... : ${SVN_ENABLE_FS_FS}")
message(STATUS "    Enable FSX .................... : ${SVN_ENABLE_FS_X}")
message(STATUS "  RA modules:")
message(STATUS "    Enable file:// ................ : ${SVN_ENABLE_RA_LOCAL}")
message(STATUS "    Enable svn:// ................. : ${SVN_ENABLE_RA_SVN}")
message(STATUS "    Enable http:// and https://.... : ${SVN_ENABLE_RA_SERF}")
message(STATUS "  Auth providers:")
message(STATUS "    Enable KWallet integration .... : ${SVN_ENABLE_AUTH_KWALLET}")
message(STATUS "    Enable Gnome Keyring .......... : ${SVN_ENABLE_AUTH_GNOME_KEYRING}")
message(STATUS "    Enable GPG Agent support ...... : ${SVN_ENABLE_AUTH_GPG_AGENT}")
message(STATUS "    Enable Cyrus SASL v2 .......... : ${SVN_ENABLE_SASL}")
message(STATUS "  Optionsal features:")
message(STATUS "    Enable libmagic ............... : ${SVN_ENABLE_LIBMAGIC}")
message(STATUS "  Optional modules and targets:")
message(STATUS "    Build Apache Modules .......... : ${SVN_ENABLE_APACHE_MODULES}")
message(STATUS "    Build programs ................ : ${SVN_ENABLE_PROGRAMS}")
message(STATUS "    Build tools ................... : ${SVN_ENABLE_TOOLS}")
message(STATUS "    Build test suite .............. : ${SVN_ENABLE_TESTS}")
message(STATUS "  Install:")
message(STATUS "    Install prefix: ............... : ${CMAKE_INSTALL_PREFIX}")
message(STATUS "    Install private headers: ...... : ${SVN_INSTALL_PRIVATE_H}")
message(STATUS "  Bindings:")
message(STATUS "    Build SVNXX ................... : ${SVN_ENABLE_SVNXX}")
message(STATUS "    Build SWIG_PERL ............... : ${SVN_ENABLE_SWIG_PERL}")
message(STATUS "    Build SWIG_PYTHON ............. : ${SVN_ENABLE_SWIG_PYTHON}")
message(STATUS "    Build SWIG_RUBY ............... : ${SVN_ENABLE_SWIG_RUBY}")
message(STATUS "    Build JavaHL .................. : ${SVN_ENABLE_JAVAHL}")