CMakeLists.txt

   1 # CMake build script for the libgit2 project
   2 #
   3 # Building (out of source build):
   4 # > mkdir build && cd build
   5 # > cmake .. [-DSETTINGS=VALUE]
   6 # > cmake --build .
   7 #
   8 # Testing:
   9 # > ctest -V
  10 #
  11 # Install:
  12 # > cmake --build . --target install
  13
  14 PROJECT(libgit2 C)
  15 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
  16 CMAKE_POLICY(SET CMP0015 NEW)
  17
  18 # Add find modules to the path
  19 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
  20
  21 INCLUDE(CheckLibraryExists)
  22 INCLUDE(CheckFunctionExists)
  23 INCLUDE(AddCFlagIfSupported)
  24 INCLUDE(FindPkgConfig)
  25
  26 # Build options
  27 #
  28 OPTION( SONAME                          "Set the (SO)VERSION of the target"             ON  )
  29 OPTION( BUILD_SHARED_LIBS       "Build Shared Library (OFF for Static)" ON  )
  30 OPTION( THREADSAFE                      "Build libgit2 as threadsafe"                   ON )
  31 OPTION( BUILD_CLAR                      "Build Tests using the Clar suite"              ON  )
  32 OPTION( BUILD_EXAMPLES          "Build library usage example apps"              OFF )
  33 OPTION( TAGS                            "Generate tags"                                                 OFF )
  34 OPTION( PROFILE                         "Generate profiling information"                OFF )
  35 OPTION( ENABLE_TRACE            "Enables tracing support"                               OFF )
  36 OPTION( LIBGIT2_FILENAME        "Name of the produced binary"                   OFF )
  37
  38 OPTION( USE_ICONV                       "Link with and use iconv library"               OFF )
  39 OPTION( USE_SSH                         "Link with libssh to enable SSH support" ON )
  40 OPTION( USE_GSSAPI                      "Link with libgssapi for SPNEGO auth"   OFF )
  41 OPTION( VALGRIND                        "Configure build for valgrind"                  OFF )
  42 OPTION( CURL                    "User curl for HTTP if available" ON)
  43
  44 IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
  45         SET( USE_ICONV ON )
  46         FIND_PACKAGE(Security)
  47         FIND_PACKAGE(CoreFoundation REQUIRED)
  48 ENDIF()
  49
  50 IF(MSVC)
  51         # This option is only available when building with MSVC. By default, libgit2
  52         # is build using the cdecl calling convention, which is useful if you're
  53         # writing C. However, the CLR and Win32 API both expect stdcall.
  54         #
  55         # If you are writing a CLR program and want to link to libgit2, you'll want
  56         # to turn this on by invoking CMake with the "-DSTDCALL=ON" argument.
  57         OPTION( STDCALL                 "Build libgit2 with the __stdcall convention"   OFF  )
  58
  59         # This option must match the settings used in your program, in particular if you
  60         # are linking statically
  61         OPTION( STATIC_CRT              "Link the static CRT libraries" ON  )
  62
  63         ADD_DEFINITIONS(-D_SCL_SECURE_NO_WARNINGS)
  64         ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
  65         ADD_DEFINITIONS(-D_CRT_NONSTDC_NO_DEPRECATE)
  66 ENDIF()
  67
  68
  69 IF(WIN32)
  70         # By default, libgit2 is built with WinHTTP.  To use the built-in
  71         # HTTP transport, invoke CMake with the "-DWINHTTP=OFF" argument.
  72         OPTION( WINHTTP                 "Use Win32 WinHTTP routines"    ON      )
  73 ENDIF()
  74
  75 IF(MSVC)
  76         # Enable MSVC CRTDBG memory leak reporting when in debug mode.
  77         OPTION(MSVC_CRTDBG "Enable CRTDBG memory leak reporting" OFF)
  78 ENDIF()
  79
  80 IF (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
  81         OPTION( USE_OPENSSL                     "Link with and use openssl library"             ON )
  82 ENDIF()
  83
  84 # This variable will contain the libraries we need to put into
  85 # libgit2.pc's Requires.private. That is, what we're linking to or
  86 # what someone who's statically linking us needs to link to.
  87 SET(LIBGIT2_PC_REQUIRES "")
  88 # This will be set later if we use the system's http-parser library or
  89 # use iconv (OSX) and will be written to the Libs.private field in the
  90 # pc file.
  91 SET(LIBGIT2_PC_LIBS "")
  92
  93 # Installation paths
  94 #
  95 SET(BIN_INSTALL_DIR bin CACHE PATH "Where to install binaries to.")
  96 SET(LIB_INSTALL_DIR lib CACHE PATH "Where to install libraries to.")
  97 SET(INCLUDE_INSTALL_DIR include CACHE PATH "Where to install headers to.")
  98
  99 FUNCTION(TARGET_OS_LIBRARIES target)
 100         IF(WIN32)
 101                 TARGET_LINK_LIBRARIES(${target} ws2_32)
 102         ELSEIF(CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)")
 103                 TARGET_LINK_LIBRARIES(${target} socket nsl)
 104                 LIST(APPEND LIBGIT2_PC_LIBS "-lsocket" "-lnsl")
 105                 SET(LIBGIT2_PC_LIBS ${LIBGIT2_PC_LIBS} PARENT_SCOPE)
 106         ENDIF()
 107         CHECK_LIBRARY_EXISTS(rt clock_gettime "time.h" NEED_LIBRT)
 108         IF(NEED_LIBRT)
 109                 TARGET_LINK_LIBRARIES(${target} rt)
 110                 LIST(APPEND LIBGIT2_PC_LIBS "-lrt")
 111                 SET(LIBGIT2_PC_LIBS ${LIBGIT2_PC_LIBS} PARENT_SCOPE)
 112         ENDIF()
 113
 114         IF(THREADSAFE)
 115                 TARGET_LINK_LIBRARIES(${target} ${CMAKE_THREAD_LIBS_INIT})
 116         ENDIF()
 117 ENDFUNCTION()
 118
 119 # For the MSVC IDE, this function splits up the source files like windows
 120 # explorer does. This is esp. useful with the libgit2_clar project, were
 121 # usually 2 or more files share the same name.  Sadly, this file grouping
 122 # is a per-directory option in cmake and not per-target, resulting in
 123 # empty virtual folders "tests" for the git2.dll
 124 FUNCTION(MSVC_SPLIT_SOURCES target)
 125         IF(MSVC_IDE)
 126                 GET_TARGET_PROPERTY(sources ${target} SOURCES)
 127                 FOREACH(source ${sources})
 128                         IF(source MATCHES ".*/")
 129                                 STRING(REPLACE ${CMAKE_CURRENT_SOURCE_DIR}/ "" rel ${source})
 130                                 IF(rel)
 131                                         STRING(REGEX REPLACE "/([^/]*)$" "" rel ${rel})
 132                                         IF(rel)
 133                                                 STRING(REPLACE "/" "\\\\" rel ${rel})
 134                                                 SOURCE_GROUP(${rel} FILES ${source})
 135                                         ENDIF()
 136                                 ENDIF()
 137                         ENDIF()
 138                 ENDFOREACH()
 139         ENDIF()
 140 ENDFUNCTION()
 141
 142 FILE(STRINGS "include/git2/version.h" GIT2_HEADER REGEX "^#define LIBGIT2_VERSION \"[^\"]*\"$")
 143
 144 STRING(REGEX REPLACE "^.*LIBGIT2_VERSION \"([0-9]+).*$" "\\1" LIBGIT2_VERSION_MAJOR "${GIT2_HEADER}")
 145 STRING(REGEX REPLACE "^.*LIBGIT2_VERSION \"[0-9]+\\.([0-9]+).*$" "\\1" LIBGIT2_VERSION_MINOR  "${GIT2_HEADER}")
 146 STRING(REGEX REPLACE "^.*LIBGIT2_VERSION \"[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" LIBGIT2_VERSION_REV "${GIT2_HEADER}")
 147 SET(LIBGIT2_VERSION_STRING "${LIBGIT2_VERSION_MAJOR}.${LIBGIT2_VERSION_MINOR}.${LIBGIT2_VERSION_REV}")
 148
 149 FILE(STRINGS "include/git2/version.h" GIT2_HEADER_SOVERSION REGEX "^#define LIBGIT2_SOVERSION [0-9]+$")
 150 STRING(REGEX REPLACE "^.*LIBGIT2_SOVERSION ([0-9]+)$" "\\1" LIBGIT2_SOVERSION "${GIT2_HEADER_SOVERSION}")
 151
 152 # Find required dependencies
 153 INCLUDE_DIRECTORIES(src include)
 154
 155 IF (SECURITY_FOUND)
 156   # OS X 10.7 and older do not have some functions we use, fall back to OpenSSL there
 157   CHECK_LIBRARY_EXISTS("${SECURITY_DIRS}" SSLCreateContext "Security/SecureTransport.h" HAVE_NEWER_SECURITY)
 158   IF (HAVE_NEWER_SECURITY)
 159     MESSAGE("-- Found Security ${SECURITY_DIRS}")
 160     LIST(APPEND LIBGIT2_PC_LIBS "-framework Security")
 161   ELSE()
 162     MESSAGE("-- Security framework is too old, falling back to OpenSSL")
 163     SET(SECURITY_FOUND "NO")
 164     SET(SECURITY_DIRS "")
 165     SET(SECURITY_DIR "")
 166     SET(USE_OPENSSL "ON")
 167   ENDIF()
 168 ENDIF()
 169
 170 IF (COREFOUNDATION_FOUND)
 171   MESSAGE("-- Found CoreFoundation ${COREFOUNDATION_DIRS}")
 172   LIST(APPEND LIBGIT2_PC_LIBS "-framework CoreFoundation")
 173 ENDIF()
 174
 175
 176 IF (WIN32 AND WINHTTP)
 177         ADD_DEFINITIONS(-DGIT_WINHTTP)
 178         INCLUDE_DIRECTORIES(deps/http-parser)
 179         FILE(GLOB SRC_HTTP deps/http-parser/*.c deps/http-parser/*.h)
 180
 181         # Since MinGW does not come with headers or an import library for winhttp,
 182         # we have to include a private header and generate our own import library
 183         IF (MINGW)
 184                 FIND_PROGRAM(DLLTOOL dlltool CMAKE_FIND_ROOT_PATH_BOTH)
 185                 IF (NOT DLLTOOL)
 186                         MESSAGE(FATAL_ERROR "Could not find dlltool command")
 187                 ENDIF ()
 188
 189                 SET(LIBWINHTTP_PATH "${CMAKE_CURRENT_BINARY_DIR}/deps/winhttp")
 190                 FILE(MAKE_DIRECTORY ${LIBWINHTTP_PATH})
 191
 192                 IF ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
 193                         set(WINHTTP_DEF "${CMAKE_CURRENT_SOURCE_DIR}/deps/winhttp/winhttp64.def")
 194                 ELSE()
 195                         set(WINHTTP_DEF "${CMAKE_CURRENT_SOURCE_DIR}/deps/winhttp/winhttp.def")
 196                 ENDIF()
 197
 198                 ADD_CUSTOM_COMMAND(
 199                         OUTPUT ${LIBWINHTTP_PATH}/libwinhttp.a
 200                         COMMAND ${DLLTOOL} -d ${WINHTTP_DEF} -k -D winhttp.dll -l libwinhttp.a
 201                         DEPENDS ${WINHTTP_DEF}
 202                         WORKING_DIRECTORY ${LIBWINHTTP_PATH}
 203                 )
 204
 205                 SET_SOURCE_FILES_PROPERTIES(
 206                         ${CMAKE_CURRENT_SOURCE_DIR}/src/transports/winhttp.c
 207                         PROPERTIES OBJECT_DEPENDS ${LIBWINHTTP_PATH}/libwinhttp.a
 208                 )
 209
 210                 INCLUDE_DIRECTORIES(deps/winhttp)
 211                 LINK_DIRECTORIES(${LIBWINHTTP_PATH})
 212         ENDIF ()
 213
 214         LINK_LIBRARIES(winhttp rpcrt4 crypt32)
 215 ELSE ()
 216         IF (CURL)
 217                 PKG_CHECK_MODULES(CURL libcurl)
 218         ENDIF ()
 219
 220         IF (NOT AMIGA AND USE_OPENSSL)
 221                 FIND_PACKAGE(OpenSSL)
 222         ENDIF ()
 223
 224         IF (CURL_FOUND)
 225                 ADD_DEFINITIONS(-DGIT_CURL)
 226                 INCLUDE_DIRECTORIES(${CURL_INCLUDE_DIRS})
 227                 LINK_LIBRARIES(${CURL_LIBRARIES})
 228                 LIST(APPEND LIBGIT2_PC_LIBS ${CURL_LDFLAGS})
 229         ENDIF()
 230
 231         FIND_PACKAGE(HTTP_Parser)
 232         IF (HTTP_PARSER_FOUND AND HTTP_PARSER_VERSION_MAJOR EQUAL 2)
 233                 INCLUDE_DIRECTORIES(${HTTP_PARSER_INCLUDE_DIRS})
 234                 LINK_LIBRARIES(${HTTP_PARSER_LIBRARIES})
 235                 LIST(APPEND LIBGIT2_PC_LIBS "-lhttp_parser")
 236         ELSE()
 237                 MESSAGE(STATUS "http-parser was not found or is too old; using bundled 3rd-party sources.")
 238                 INCLUDE_DIRECTORIES(deps/http-parser)
 239                 FILE(GLOB SRC_HTTP deps/http-parser/*.c deps/http-parser/*.h)
 240         ENDIF()
 241 ENDIF()
 242
 243 # Specify sha1 implementation
 244 IF (WIN32 AND NOT MINGW AND NOT SHA1_TYPE STREQUAL "builtin")
 245         ADD_DEFINITIONS(-DWIN32_SHA1)
 246         FILE(GLOB SRC_SHA1 src/hash/hash_win32.c)
 247 ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 248         ADD_DEFINITIONS(-DGIT_COMMON_CRYPTO)
 249 ELSEIF (OPENSSL_FOUND AND NOT SHA1_TYPE STREQUAL "builtin")
 250         ADD_DEFINITIONS(-DOPENSSL_SHA1)
 251         IF (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 252                 LIST(APPEND LIBGIT2_PC_LIBS "-lssl")
 253         ELSE()
 254                 SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} openssl")
 255         ENDIF ()
 256 ELSE()
 257         FILE(GLOB SRC_SHA1 src/hash/hash_generic.c)
 258 ENDIF()
 259
 260 # Enable tracing
 261 IF (ENABLE_TRACE STREQUAL "ON")
 262         ADD_DEFINITIONS(-DGIT_TRACE)
 263 ENDIF()
 264
 265 # Include POSIX regex when it is required
 266 IF(WIN32 OR AMIGA OR CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)")
 267         INCLUDE_DIRECTORIES(deps/regex)
 268         SET(SRC_REGEX deps/regex/regex.c)
 269 ENDIF()
 270
 271 # Optional external dependency: zlib
 272 FIND_PACKAGE(ZLIB)
 273 IF (ZLIB_FOUND)
 274         INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIRS})
 275         LINK_LIBRARIES(${ZLIB_LIBRARIES})
 276         IF(APPLE OR CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 277                 LIST(APPEND LIBGIT2_PC_LIBS "-lz")
 278         ELSE()
 279                 SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} zlib")
 280         ENDIF()
 281 ELSE()
 282         MESSAGE(STATUS "zlib was not found; using bundled 3rd-party sources." )
 283         INCLUDE_DIRECTORIES(deps/zlib)
 284         ADD_DEFINITIONS(-DNO_VIZ -DSTDC -DNO_GZIP)
 285         FILE(GLOB SRC_ZLIB deps/zlib/*.c deps/zlib/*.h)
 286 ENDIF()
 287
 288 # Optional external dependency: libssh2
 289 IF (USE_SSH)
 290         PKG_CHECK_MODULES(LIBSSH2 libssh2)
 291 ENDIF()
 292 IF (LIBSSH2_FOUND)
 293         ADD_DEFINITIONS(-DGIT_SSH)
 294         INCLUDE_DIRECTORIES(${LIBSSH2_INCLUDE_DIRS})
 295         LINK_DIRECTORIES(${LIBSSH2_LIBRARY_DIRS})
 296         LIST(APPEND LIBGIT2_PC_LIBS ${LIBSSH2_LDFLAGS})
 297         #SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} ${LIBSSH2_LDFLAGS}")
 298         SET(SSH_LIBRARIES ${LIBSSH2_LIBRARIES})
 299
 300         CHECK_LIBRARY_EXISTS("${LIBSSH2_LIBRARIES}" libssh2_userauth_publickey_frommemory "${LIBSSH2_LIBRARY_DIRS}" HAVE_LIBSSH2_MEMORY_CREDENTIALS)
 301         IF (HAVE_LIBSSH2_MEMORY_CREDENTIALS)
 302                 ADD_DEFINITIONS(-DGIT_SSH_MEMORY_CREDENTIALS)
 303         ENDIF()
 304 ELSE()
 305         MESSAGE(STATUS "LIBSSH2 not found. Set CMAKE_PREFIX_PATH if it is installed outside of the default search path.")
 306 ENDIF()
 307
 308 # Optional external dependency: libgssapi
 309 IF (USE_GSSAPI)
 310         FIND_PACKAGE(GSSAPI)
 311 ENDIF()
 312 IF (GSSAPI_FOUND)
 313         ADD_DEFINITIONS(-DGIT_GSSAPI)
 314 ENDIF()
 315
 316 # Optional external dependency: iconv
 317 IF (USE_ICONV)
 318         FIND_PACKAGE(Iconv)
 319 ENDIF()
 320 IF (ICONV_FOUND)
 321         ADD_DEFINITIONS(-DGIT_USE_ICONV)
 322         INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR})
 323         LIST(APPEND LIBGIT2_PC_LIBS ${ICONV_LIBRARIES})
 324 ENDIF()
 325
 326 # Platform specific compilation flags
 327 IF (MSVC)
 328
 329         STRING(REPLACE "/Zm1000" " " CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
 330
 331         # /GF - String pooling
 332         # /MP - Parallel build
 333         SET(CMAKE_C_FLAGS "/GF /MP /nologo ${CMAKE_C_FLAGS}")
 334
 335         IF (STDCALL)
 336                 # /Gz - stdcall calling convention
 337                 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Gz")
 338         ENDIF ()
 339
 340         IF (STATIC_CRT)
 341                 SET(CRT_FLAG_DEBUG "/MTd")
 342                 SET(CRT_FLAG_RELEASE "/MT")
 343         ELSE()
 344                 SET(CRT_FLAG_DEBUG "/MDd")
 345                 SET(CRT_FLAG_RELEASE "/MD")
 346         ENDIF()
 347
 348         IF (MSVC_CRTDBG)
 349                 SET(CRT_FLAG_DEBUG "${CRT_FLAG_DEBUG} /DGIT_MSVC_CRTDBG")
 350                 SET(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES}" "Dbghelp.lib")
 351         ENDIF()
 352
 353         # /Zi - Create debugging information
 354         # /Od - Disable optimization
 355         # /D_DEBUG - #define _DEBUG
 356         # /MTd - Statically link the multithreaded debug version of the CRT
 357         # /MDd - Dynamically link the multithreaded debug version of the CRT
 358         # /RTC1 - Run time checks
 359         SET(CMAKE_C_FLAGS_DEBUG "/Zi /Od /D_DEBUG /RTC1 ${CRT_FLAG_DEBUG}")
 360
 361         # /DNDEBUG - Disables asserts
 362         # /MT - Statically link the multithreaded release version of the CRT
 363         # /MD - Dynamically link the multithreaded release version of the CRT
 364         # /O2 - Optimize for speed
 365         # /Oy - Enable frame pointer omission (FPO) (otherwise CMake will automatically turn it off)
 366         # /GL - Link time code generation (whole program optimization)
 367         # /Gy - Function-level linking
 368         SET(CMAKE_C_FLAGS_RELEASE "/DNDEBUG /O2 /Oy /GL /Gy ${CRT_FLAG_RELEASE}")
 369
 370         # /Oy- - Disable frame pointer omission (FPO)
 371         SET(CMAKE_C_FLAGS_RELWITHDEBINFO "/DNDEBUG /Zi /O2 /Oy- /GL /Gy ${CRT_FLAG_RELEASE}")
 372
 373         # /O1 - Optimize for size
 374         SET(CMAKE_C_FLAGS_MINSIZEREL "/DNDEBUG /O1 /Oy /GL /Gy ${CRT_FLAG_RELEASE}")
 375
 376         # /DYNAMICBASE - Address space load randomization (ASLR)
 377         # /NXCOMPAT - Data execution prevention (DEP)
 378         # /LARGEADDRESSAWARE - >2GB user address space on x86
 379         # /VERSION - Embed version information in PE header
 380         SET(CMAKE_EXE_LINKER_FLAGS "/DYNAMICBASE /NXCOMPAT /LARGEADDRESSAWARE /VERSION:${LIBGIT2_VERSION_MAJOR}.${LIBGIT2_VERSION_MINOR}")
 381
 382         # /DEBUG - Create a PDB
 383         # /LTCG - Link time code generation (whole program optimization)
 384         # /OPT:REF /OPT:ICF - Fold out duplicate code at link step
 385         # /INCREMENTAL:NO - Required to use /LTCG
 386         # /DEBUGTYPE:cv,fixup - Additional data embedded in the PDB (requires /INCREMENTAL:NO, so not on for Debug)
 387         SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "/DEBUG")
 388         SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "/RELEASE /LTCG /OPT:REF /OPT:ICF /INCREMENTAL:NO")
 389         SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "/DEBUG /RELEASE /LTCG /OPT:REF /OPT:ICF /INCREMENTAL:NO /DEBUGTYPE:cv,fixup")
 390         SET(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "/RELEASE /LTCG /OPT:REF /OPT:ICF /INCREMENTAL:NO")
 391
 392         # Same linker settings for DLL as EXE
 393         SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
 394         SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
 395         SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
 396         SET(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO}")
 397         SET(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL}")
 398
 399         SET(WIN_RC "src/win32/git2.rc")
 400
 401    # Precompiled headers
 402
 403 ELSE ()
 404         SET(CMAKE_C_FLAGS "-D_GNU_SOURCE -Wall -Wextra ${CMAKE_C_FLAGS}")
 405
 406         IF (CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)")
 407                 SET(CMAKE_C_FLAGS "-std=c99 -D_POSIX_C_SOURCE=200112L -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS ${CMAKE_C_FLAGS}")
 408         ENDIF()
 409
 410         IF (WIN32 AND NOT CYGWIN)
 411                 SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG")
 412         ENDIF ()
 413
 414         IF (MINGW) # MinGW always does PIC and complains if we tell it to
 415                 STRING(REGEX REPLACE "-fPIC" "" CMAKE_SHARED_LIBRARY_C_FLAGS "${CMAKE_SHARED_LIBRARY_C_FLAGS}")
 416                 # MinGW >= 3.14 uses the C99-style stdio functions
 417                 # automatically, but forks like mingw-w64 still want
 418                 # us to define this in order to use them
 419                 ADD_DEFINITIONS(-D__USE_MINGW_ANSI_STDIO=1)
 420
 421         ELSEIF (BUILD_SHARED_LIBS)
 422                 ADD_C_FLAG_IF_SUPPORTED(-fvisibility=hidden)
 423
 424                 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
 425         ENDIF ()
 426
 427         ADD_C_FLAG_IF_SUPPORTED(-Wdocumentation)
 428         ADD_C_FLAG_IF_SUPPORTED(-Wno-missing-field-initializers)
 429         ADD_C_FLAG_IF_SUPPORTED(-Wstrict-aliasing=2)
 430         ADD_C_FLAG_IF_SUPPORTED(-Wstrict-prototypes)
 431         ADD_C_FLAG_IF_SUPPORTED(-Wdeclaration-after-statement)
 432         ADD_C_FLAG_IF_SUPPORTED(-Wno-unused-const-variable)
 433         ADD_C_FLAG_IF_SUPPORTED(-Wno-unused-function)
 434
 435         IF (APPLE) # Apple deprecated OpenSSL
 436                 ADD_C_FLAG_IF_SUPPORTED(-Wno-deprecated-declarations)
 437         ENDIF()
 438
 439         IF (PROFILE)
 440                 SET(CMAKE_C_FLAGS "-pg ${CMAKE_C_FLAGS}")
 441                 SET(CMAKE_EXE_LINKER_FLAGS "-pg ${CMAKE_EXE_LINKER_FLAGS}")
 442         ENDIF ()
 443 ENDIF()
 444
 445 CHECK_FUNCTION_EXISTS(futimens HAVE_FUTIMENS)
 446 IF (HAVE_FUTIMENS)
 447         ADD_DEFINITIONS(-DHAVE_FUTIMENS)
 448 ENDIF ()
 449
 450 CHECK_FUNCTION_EXISTS(qsort_r HAVE_QSORT_R)
 451 IF (HAVE_QSORT_R)
 452         ADD_DEFINITIONS(-DHAVE_QSORT_R)
 453 ENDIF ()
 454
 455 CHECK_FUNCTION_EXISTS(qsort_s HAVE_QSORT_S)
 456 IF (HAVE_QSORT_S)
 457         ADD_DEFINITIONS(-DHAVE_QSORT_S)
 458 ENDIF ()
 459
 460 IF( NOT CMAKE_CONFIGURATION_TYPES )
 461         # Build Debug by default
 462         IF (NOT CMAKE_BUILD_TYPE)
 463                 SET(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
 464         ENDIF ()
 465 ELSE()
 466         # Using a multi-configuration generator eg MSVC or Xcode
 467         # that uses CMAKE_CONFIGURATION_TYPES and not CMAKE_BUILD_TYPE
 468 ENDIF()
 469
 470 IF (SECURITY_FOUND)
 471   ADD_DEFINITIONS(-DGIT_SECURE_TRANSPORT)
 472   INCLUDE_DIRECTORIES(${SECURITY_INCLUDE_DIR})
 473 ENDIF ()
 474
 475 IF (OPENSSL_FOUND)
 476   ADD_DEFINITIONS(-DGIT_OPENSSL)
 477   INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
 478   SET(SSL_LIBRARIES ${OPENSSL_LIBRARIES})
 479 ENDIF()
 480
 481
 482
 483 IF (THREADSAFE)
 484         IF (NOT WIN32)
 485                 FIND_PACKAGE(Threads REQUIRED)
 486         ENDIF()
 487
 488         ADD_DEFINITIONS(-DGIT_THREADS)
 489 ENDIF()
 490
 491 ADD_DEFINITIONS(-D_FILE_OFFSET_BITS=64)
 492
 493 # Collect sourcefiles
 494 FILE(GLOB SRC_H include/git2.h include/git2/*.h include/git2/sys/*.h)
 495
 496 # On Windows use specific platform sources
 497 IF (WIN32 AND NOT CYGWIN)
 498         ADD_DEFINITIONS(-DWIN32 -D_WIN32_WINNT=0x0501)
 499         FILE(GLOB SRC_OS src/win32/*.c src/win32/*.h)
 500 ELSEIF (AMIGA)
 501         ADD_DEFINITIONS(-DNO_ADDRINFO -DNO_READDIR_R -DNO_MMAP)
 502 ELSE()
 503         IF (VALGRIND)
 504                 ADD_DEFINITIONS(-DNO_MMAP)
 505         ENDIF()
 506         FILE(GLOB SRC_OS src/unix/*.c src/unix/*.h)
 507 ENDIF()
 508 FILE(GLOB SRC_GIT2 src/*.c src/*.h src/transports/*.c src/transports/*.h src/xdiff/*.c src/xdiff/*.h)
 509
 510 # Determine architecture of the machine
 511 IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
 512         ADD_DEFINITIONS(-DGIT_ARCH_64)
 513 ELSEIF (CMAKE_SIZEOF_VOID_P EQUAL 4)
 514         ADD_DEFINITIONS(-DGIT_ARCH_32)
 515 ELSE()
 516         MESSAGE(FATAL_ERROR "Unsupported architecture")
 517 ENDIF()
 518
 519 # Compile and link libgit2
 520 ADD_LIBRARY(git2 ${SRC_H} ${SRC_GIT2} ${SRC_OS} ${SRC_ZLIB} ${SRC_HTTP} ${SRC_REGEX} ${SRC_SHA1} ${WIN_RC})
 521 TARGET_LINK_LIBRARIES(git2 ${SECURITY_DIRS})
 522 TARGET_LINK_LIBRARIES(git2 ${COREFOUNDATION_DIRS})
 523 TARGET_LINK_LIBRARIES(git2 ${SSL_LIBRARIES})
 524 TARGET_LINK_LIBRARIES(git2 ${SSH_LIBRARIES})
 525 TARGET_LINK_LIBRARIES(git2 ${GSSAPI_LIBRARIES})
 526 TARGET_LINK_LIBRARIES(git2 ${ICONV_LIBRARIES})
 527 TARGET_OS_LIBRARIES(git2)
 528
 529 # Workaround for Cmake bug #0011240 (see http://public.kitware.com/Bug/view.php?id=11240)
 530 # Win64+MSVC+static libs = linker error
 531 IF(MSVC AND GIT_ARCH_64 AND NOT BUILD_SHARED_LIBS)
 532   SET_TARGET_PROPERTIES(git2 PROPERTIES STATIC_LIBRARY_FLAGS "/MACHINE:x64")
 533 ENDIF()
 534
 535 MSVC_SPLIT_SOURCES(git2)
 536
 537 IF (SONAME)
 538         SET_TARGET_PROPERTIES(git2 PROPERTIES VERSION ${LIBGIT2_VERSION_STRING})
 539         SET_TARGET_PROPERTIES(git2 PROPERTIES SOVERSION ${LIBGIT2_SOVERSION})
 540         IF (LIBGIT2_FILENAME)
 541                 ADD_DEFINITIONS(-DLIBGIT2_FILENAME=\"${LIBGIT2_FILENAME}\")
 542                 SET_TARGET_PROPERTIES(git2 PROPERTIES OUTPUT_NAME ${LIBGIT2_FILENAME})
 543         ENDIF()
 544 ENDIF()
 545 STRING(REPLACE ";" " " LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS}")
 546 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libgit2.pc.in ${CMAKE_CURRENT_BINARY_DIR}/libgit2.pc @ONLY)
 547
 548 IF (MSVC_IDE)
 549    # Precompiled headers
 550    SET_TARGET_PROPERTIES(git2 PROPERTIES COMPILE_FLAGS "/Yuprecompiled.h /FIprecompiled.h")
 551    SET_SOURCE_FILES_PROPERTIES(src/win32/precompiled.c COMPILE_FLAGS "/Ycprecompiled.h")
 552 ENDIF ()
 553
 554 # Install
 555 INSTALL(TARGETS git2
 556         RUNTIME DESTINATION ${BIN_INSTALL_DIR}
 557         LIBRARY DESTINATION ${LIB_INSTALL_DIR}
 558         ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
 559 )
 560 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/libgit2.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig )
 561 INSTALL(DIRECTORY include/git2 DESTINATION ${INCLUDE_INSTALL_DIR} )
 562 INSTALL(FILES include/git2.h DESTINATION ${INCLUDE_INSTALL_DIR} )
 563
 564 # Tests
 565 IF (BUILD_CLAR)
 566         FIND_PACKAGE(PythonInterp REQUIRED)
 567
 568         SET(CLAR_FIXTURES "${CMAKE_CURRENT_SOURCE_DIR}/tests/resources/")
 569         SET(CLAR_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tests")
 570         SET(CLAR_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/tests/resources" CACHE PATH "Path to test resources.")
 571         ADD_DEFINITIONS(-DCLAR_FIXTURE_PATH=\"${CLAR_FIXTURES}\")
 572         ADD_DEFINITIONS(-DCLAR_RESOURCES=\"${TEST_RESOURCES}\")
 573         ADD_DEFINITIONS(-DCLAR_TMPDIR=\"libgit2_tests\")
 574
 575         INCLUDE_DIRECTORIES(${CLAR_PATH})
 576         FILE(GLOB_RECURSE SRC_TEST ${CLAR_PATH}/*/*.c ${CLAR_PATH}/*/*.h)
 577         SET(SRC_CLAR "${CLAR_PATH}/main.c" "${CLAR_PATH}/clar_libgit2.c" "${CLAR_PATH}/clar_libgit2_trace.c" "${CLAR_PATH}/clar_libgit2_timer.c" "${CLAR_PATH}/clar.c")
 578
 579         ADD_CUSTOM_COMMAND(
 580                 OUTPUT ${CLAR_PATH}/clar.suite
 581                 COMMAND ${PYTHON_EXECUTABLE} generate.py -f -xonline -xstress .
 582                 DEPENDS ${SRC_TEST}
 583                 WORKING_DIRECTORY ${CLAR_PATH}
 584         )
 585
 586         SET_SOURCE_FILES_PROPERTIES(
 587                 ${CLAR_PATH}/clar.c
 588                 PROPERTIES OBJECT_DEPENDS ${CLAR_PATH}/clar.suite)
 589
 590         ADD_EXECUTABLE(libgit2_clar ${SRC_H} ${SRC_GIT2} ${SRC_OS} ${SRC_CLAR} ${SRC_TEST} ${SRC_ZLIB} ${SRC_HTTP} ${SRC_REGEX} ${SRC_SHA1})
 591
 592         TARGET_LINK_LIBRARIES(libgit2_clar ${COREFOUNDATION_DIRS})
 593         TARGET_LINK_LIBRARIES(libgit2_clar ${SECURITY_DIRS})
 594         TARGET_LINK_LIBRARIES(libgit2_clar ${SSL_LIBRARIES})
 595         TARGET_LINK_LIBRARIES(libgit2_clar ${SSH_LIBRARIES})
 596         TARGET_LINK_LIBRARIES(libgit2_clar ${GSSAPI_LIBRARIES})
 597         TARGET_LINK_LIBRARIES(libgit2_clar ${ICONV_LIBRARIES})
 598         TARGET_OS_LIBRARIES(libgit2_clar)
 599         MSVC_SPLIT_SOURCES(libgit2_clar)
 600
 601         IF (MSVC_IDE)
 602                 # Precompiled headers
 603                 SET_TARGET_PROPERTIES(libgit2_clar PROPERTIES COMPILE_FLAGS "/Yuprecompiled.h /FIprecompiled.h")
 604         ENDIF ()
 605
 606         ENABLE_TESTING()
 607         IF (WINHTTP OR OPENSSL_FOUND OR SECURITY_FOUND)
 608                 ADD_TEST(libgit2_clar libgit2_clar -ionline)
 609         ELSE ()
 610                 ADD_TEST(libgit2_clar libgit2_clar -v)
 611         ENDIF ()
 612 ENDIF ()
 613
 614 IF (TAGS)
 615         FIND_PROGRAM(CTAGS ctags)
 616         IF (NOT CTAGS)
 617                 MESSAGE(FATAL_ERROR "Could not find ctags command")
 618         ENDIF ()
 619
 620         FILE(GLOB_RECURSE SRC_ALL *.[ch])
 621
 622         ADD_CUSTOM_COMMAND(
 623                 OUTPUT tags
 624                 COMMAND ${CTAGS} -a ${SRC_ALL}
 625                 DEPENDS ${SRC_ALL}
 626         )
 627         ADD_CUSTOM_TARGET(
 628                 do_tags ALL
 629                 DEPENDS tags
 630         )
 631 ENDIF ()
 632
 633 IF (BUILD_EXAMPLES)
 634         ADD_SUBDIRECTORY(examples)
 635 ENDIF ()