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