1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
|
cmake_minimum_required(VERSION 3.5)
project(warzone2100)
OPTION(ENABLE_NLS "Native Language Support" ON)
OPTION(WZ_PORTABLE "Portable (Windows-only)" ON)
OPTION(WZ_ENABLE_WARNINGS "Enable (additional) warnings" OFF)
OPTION(WZ_ENABLE_WARNINGS_AS_ERRORS "Enable compiler flags that treat (most) warnings as errors" ON)
set(WZ_DISTRIBUTOR "UNKNOWN" CACHE STRING "Name of distributor compiling this package")
set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
# Handle options
if(WZ_PORTABLE AND NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
message( WARNING "Portable build is only supported on Windows; Ignoring WZ_PORTABLE option" )
unset(WZ_PORTABLE CACHE)
endif()
# Disallow in-source builds
include(DisallowInSourceBuilds)
if(WZ_ENABLE_WARNINGS)
set(WZ_Wno_ "-Wno-error=")
else()
set(WZ_Wno_ "-Wno-")
endif()
# CXX Standard
if(MSVC)
set(CMAKE_CXX_STANDARD 14)
else()
set(CMAKE_CXX_STANDARD 11)
endif()
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Support folders (for nicer IDE organization)
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set_property(GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "_CMakePredefinedTargets")
# Fix: Linking issues with static libraries when using certain generated project files (ex. Xcode in "Archive" build mode)
# See: https://stackoverflow.com/questions/30318941/, https://stackoverflow.com/questions/33020245/
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "./")
# Handle install paths
if(CMAKE_SYSTEM_NAME MATCHES "Windows")
# On Windows, set the default DATAROOTDIR to "."
# - No need to put everything in a nested "share" folder, as the expectation is that
# WZ will be installed in its own directory (ex. a subdirectory of Program Files)
if(NOT DEFINED CMAKE_INSTALL_DATAROOTDIR)
set(CMAKE_INSTALL_DATAROOTDIR "." CACHE PATH "Read-only architecture-independent data root" FORCE)
endif()
# Set the default DOCDIR to "DATAROOTDIR/doc"
if(NOT DEFINED CMAKE_INSTALL_DOCDIR)
set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc" CACHE PATH "Documentation root (DATAROOTDIR/doc)" FORCE)
endif()
endif()
include(GNUInstallDirs)
if(NOT DEFINED WZ_DATADIR)
# Set default WZ_DATADIR based on target platform
if(CMAKE_SYSTEM_NAME MATCHES "Windows")
set(WZ_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}/data")
elseif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
set(WZ_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}/warzone2100") # not used on macOS (macOS always creates an app bundle)
else()
set(WZ_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}/warzone2100")
endif()
endif()
if(CMAKE_SYSTEM_NAME MATCHES "Windows")
if(NOT CMAKE_INSTALL_BINDIR STREQUAL "bin")
# Windows builds expect a non-empty BINDIR
# Windows NSIS installer scripts expect a BINDIR that is "bin"
message( WARNING "Windows builds currently require CMAKE_INSTALL_BINDIR to be \"bin\" - resetting value" )
set(CMAKE_INSTALL_BINDIR "bin" CACHE PATH "User executables (bin)" FORCE)
endif()
endif()
if(IS_ABSOLUTE "${CMAKE_INSTALL_BINDIR}")
# Since the main executable install location is used to determine the install prefix,
# an absolute bindir requires an absolute CMAKE_INSTALL_LOCALEDIR + WZ_DATADIR (or locales + data won't be found)
set(_nonAbsolutePaths)
if(NOT IS_ABSOLUTE "${CMAKE_INSTALL_LOCALEDIR}")
list(APPEND _nonAbsolutePaths "CMAKE_INSTALL_LOCALEDIR")
endif()
if(NOT IS_ABSOLUTE "${WZ_DATADIR}")
list(APPEND _nonAbsolutePaths "WZ_DATADIR")
endif()
if(_nonAbsolutePaths)
message( FATAL_ERROR "An absolute CMAKE_INSTALL_BINDIR path cannot be used if the following are not also absolute paths: ${_nonAbsolutePaths}\nRECOMMENDED SOLUTION:\nMake all of these *relative* paths, and use CMAKE_INSTALL_DIR and/or CPACK_PACKAGING_INSTALL_PREFIX to affect the install prefix / location (which can be absolute)." )
endif()
endif()
if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
# Disable compiler-specific extensions for macOS builds
set(CMAKE_CXX_EXTENSIONS OFF)
# Enable macOS-specific find scripts
list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/macosx/cmake")
# Workaround for framework header conflicts with find_package
# - Common issue when Mono.framework is installed, since it contains headers for libpng (etc)
# and the default CMake setting finds the headers in Mono, but the library in the vcpkg
# install location (leading to a version mismatch)
# - See: https://github.com/torch/image/issues/16
set(CMAKE_FIND_FRAMEWORK LAST)
endif()
if(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
# Enable detection of Homebrew-installed Gettext
list(APPEND CMAKE_PREFIX_PATH "/usr/local/opt/gettext")
endif()
set(_wz_additional_qt_components)
if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
# Workaround: Qt5's Cocoa platform integration plugin requires Qt5::PrintSupport
set(_wz_additional_qt_components "PrintSupport")
endif()
find_package(Qt5 COMPONENTS Core Widgets Script Gui ${_wz_additional_qt_components} REQUIRED)
if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
find_package(PkgConfig)
if(${CMAKE_CROSSCOMPILING})
pkg_check_modules(QT5ALL REQUIRED Qt5Widgets Qt5Core Qt5Script)
link_directories(${QT5ALL_LIBRARY_DIRS})
endif()
endif()
# Use "-fPIC" / "-fPIE" for all targets by default, including static libs
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
# CMake doesn't add "-pie" by default for executables (CMake issue #14983)
INCLUDE(AddTargetLinkFlagsIfSupported)
CHECK_CXX_LINKER_FLAGS("${CMAKE_EXE_LINKER_FLAGS} -pie" LINK_FLAG_PIE_SUPPORTED)
if(LINK_FLAG_PIE_SUPPORTED AND NOT CMAKE_SYSTEM_NAME MATCHES "Windows" AND NOT CMAKE_SYSTEM_NAME MATCHES "Darwin")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie")
endif()
# Ensure all builds always have debug info built (MSVC)
if("${CMAKE_CXX_COMPILER_ID}" MATCHES "MSVC")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF" CACHE STRING "Flags used by the linker (Release builds)" FORCE)
endif()
# Treat source files as UTF-8 (unless they have a BOM) (MSVC)
# NOTE: For MSVC, this also sets the executable character set.
add_compile_options("$<$<C_COMPILER_ID:MSVC>:/utf-8>")
add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/utf-8>")
# Set Windows-specific defines (ex. _WIN32_WINNT)
if(CMAKE_SYSTEM_NAME MATCHES "Windows")
if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
message( WARNING "WindowsStore builds are not currently supported" )
add_definitions(-D_WIN32_WINNT=0x0A00) # Windows 10+
else()
add_definitions(-D_WIN32_WINNT=0x0501) # Windows XP+
endif()
endif()
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
# Enable stack protection, if supported by the compiler
# Prefer -fstack-protector-strong if supported, fall-back to -fstack-protector
check_c_compiler_flag(-fstack-protector-strong HAS_CFLAG_FSTACK_PROTECTOR_STRONG)
if (HAS_CFLAG_FSTACK_PROTECTOR_STRONG)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector-strong")
else()
check_c_compiler_flag(-fstack-protector HAS_CFLAG_FSTACK_PROTECTOR)
if (HAS_CFLAG_FSTACK_PROTECTOR)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
endif()
endif()
check_cxx_compiler_flag(-fstack-protector-strong HAS_CXXFLAG_FSTACK_PROTECTOR_STRONG)
if (HAS_CXXFLAG_FSTACK_PROTECTOR_STRONG)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong")
else()
check_cxx_compiler_flag(-fstack-protector HAS_CXXFLAG_FSTACK_PROTECTOR)
if (HAS_CXXFLAG_FSTACK_PROTECTOR)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector")
endif()
endif()
include(CheckCompilerFlagsOutput)
set(WZ_TARGET_ADDITIONAL_PROPERTIES) # Set below to any additional properties that should be added to Warzone targets (src/, lib/*/)
# Configure compiler warnings for WZ
# NOTE: This should be called after the 3rdparty/ libs are added, so it only affects WZ code & frameworks
macro(CONFIGURE_WZ_COMPILER_WARNINGS)
if(MSVC)
# MSVC
# Enable /W4
# NOTE: Do not use /Wall, as it enables *many* warnings that are off by default. MS recommends /W4 (max)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
# Enable some additional MSVC warnings (if compiling at warning level 3+)
# C4204: nonstandard extension used : non-constant aggregate initializer
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w34204")
# C4512: 'class' : assignment operator could not be generated
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w34512")
# Enable some additional MSVC warnings (that are off by default)
# C4005: 'identifier' : macro redefinition
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /we4005")
# C4191: unsafe conversion from 'type of expression' to 'type required'
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w34191")
# C4263: 'function': member function does not override any base class virtual member function
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w34263")
# C4264: 'virtual_function': no override available for virtual member function from base 'class'; function is hidden
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w34264")
# C4265: 'class': class has virtual functions, but destructor is not virtual
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w34265")
# C4266: 'function' : no override available for virtual member function from base 'type'; function is hidden
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w34266")
# C4905: wide string literal cast to 'LPSTR'
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w14905")
# C4906: string literal cast to 'LPWSTR'
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w14906")
# C4928: illegal copy-initialization; more than one user-defined conversion has been implicitly applied
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w14928")
# C4289: nonstandard extension used : 'var' : loop control variable declared in the for-loop is used outside the for-loop scope
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w44289")
# C4836: nonstandard extension used : 'type' : local types or unnamed types cannot be used as template arguments
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w14836")
# # NOTE: The following cannot currently be enabled because of Qt headers (at least Qt 5.6.x)
# # C4946: reinterpret_cast used between related classes: 'class1' and 'class2'
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w14946")
if (WZ_ENABLE_WARNINGS_AS_ERRORS)
# Enable /WX
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
else()
message( STATUS "WZ will *NOT* enable /WX" )
endif()
# Disable some warnings for WZ (permanently)
# C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning)
# This warning is no longer generated in Visual Studio 2017+
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4800")
# Disable some warnings for WZ (FIXME)
# C4100: unreferenced formal parameter
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4100")
# C4244: 'conversion' conversion from 'type1' to 'type2', possible loss of data // FIXME!!
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244")
# C4456: declaration of 'identifier' hides previous local declaration
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4456")
# C4459: declaration of 'identifier' hides global declaration
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4459")
# C4702: unreachable code
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4702")
# C4245: 'conversion' : conversion from 'type1' to 'type2', signed/unsigned mismatch
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4245")
# C4701: Potentially uninitialized local variable 'name' used
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4701")
# C4706: assignment within conditional expression
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4706")
# Qt headers (at least 5.6.x) necessitate disabling some warnings
# C4127: conditional expression is constant
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4127")
elseif(CMAKE_GENERATOR STREQUAL "Xcode")
# Set Xcode generator project-level configuration + warning flags
# Enable Objective-C ARC
set(CMAKE_XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES)
# Debugging Symbols
set(CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT "dwarf-with-dsym")
# WORKAROUND: Ensure debugging symbols are always generated for Release builds
#
# Required because the CMake Xcode generator (at least, as of CMake 3.11.x) automatically
# sets "Generate Debugging Symbols" to NO for Release builds, and cannot be overridden by
# setting CMAKE_XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS.
add_compile_options($<$<CONFIG:MinSizeRel>:-g>)
add_compile_options($<$<CONFIG:Release>:-g>)
# Make sure the CLANG_CXX_LANGUAGE_STANDARD Xcode attribute matches the CMAKE_CXX_STANDARD
if (CMAKE_CXX_STANDARD EQUAL 11)
set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++0x")
elseif (CMAKE_CXX_STANDARD EQUAL 14)
set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++14")
elseif (CMAKE_CXX_STANDARD EQUAL 17)
set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++1z")
else()
# Additional mapping required for CMAKE_CXX_STANDARD => Xcode's CLANG_CXX_LANGUAGE_STANDARD attribute (above)
# Also may need to bump the minimum supported version of Xcode for compilation
message( FATAL_ERROR "Don't know how to map from CMAKE_CXX_STANDARD \"${CMAKE_CXX_STANDARD}\" => Xcode's CLANG_CXX_LANGUAGE_STANDARD. See CMakeLists.txt" )
endif()
# -stdlib=libc++
set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
# Linking
set(CMAKE_XCODE_ATTRIBUTE_DEAD_CODE_STRIPPING YES)
# Apple LLVM - Code Generation
set(CMAKE_XCODE_ATTRIBUTE_GCC_NO_COMMON_BLOCKS YES) # -fno-common
# Apple Clang - Custom Compiler Flags
# Custom Warning Flags (for which an Xcode attribute is not available)
set(CMAKE_XCODE_ATTRIBUTE_WARNING_CFLAGS "-Wall -Wextra -Wcast-align -Wwrite-strings -Wpointer-arith")
# Custom Disabling Warning Flags (which are required because of warning flags specified above
# and by CMake's Xcode project generator)
set(CMAKE_XCODE_ATTRIBUTE_WARNING_CFLAGS "${CMAKE_XCODE_ATTRIBUTE_WARNING_CFLAGS} -Wno-sign-compare")
set(CMAKE_XCODE_ATTRIBUTE_WARNING_CFLAGS "${CMAKE_XCODE_ATTRIBUTE_WARNING_CFLAGS} -Wno-unused-parameter")
# Custom Warning Flags - No Error Tweaks
set(CMAKE_XCODE_ATTRIBUTE_WARNING_CFLAGS "${CMAKE_XCODE_ATTRIBUTE_WARNING_CFLAGS} -Wno-error=deprecated-declarations")
# Apple Clang - Preprocessing
set(CMAKE_XCODE_ATTRIBUTE_ENABLE_STRICT_OBJC_MSGSEND YES)
# Apple Clang - Warning Policies
# set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_PEDANTIC YES) # Cannot currently enable in Xcode because of Qt headers
if (WZ_ENABLE_WARNINGS_AS_ERRORS)
# Enable GCC_TREAT_WARNINGS_AS_ERRORS for WZ targets only
list(APPEND WZ_TARGET_ADDITIONAL_PROPERTIES XCODE_ATTRIBUTE_GCC_TREAT_WARNINGS_AS_ERRORS YES)
else()
message( STATUS "WZ will *NOT* enable \"Warnings As Errors\" for WZ targets" )
endif()
# Apple Clang - Warnings - All languages
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING YES) # -Wblock-capture-autoreleasing
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_CHECK_SWITCH_STATEMENTS YES) # -Wswitch
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS YES) # -Wdeprecated-declarations
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_DOCUMENTATION_COMMENTS NO) # -Wdocumentation [DISABLED]
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_EMPTY_BODY YES) # -Wempty-body
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_FOUR_CHARACTER_CONSTANTS YES) # -Wfour-char-constants
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_SHADOW NO) # -Wshadow [DISABLED] - FIXME
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_BOOL_CONVERSION YES) # -Wbool-conversion
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_CONSTANT_CONVERSION YES) # -Wconstant-conversion
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_64_TO_32_BIT_CONVERSION NO) # -Wshorten-64-to-32 [DISABLED] - FIXME
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_ENUM_CONVERSION YES) # -Wenum-conversion
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_FLOAT_CONVERSION NO) # -Wfloat-conversion [DISABLED] - FIXME
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_INT_CONVERSION YES) # -Wint-conversion
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_NON_LITERAL_NULL_CONVERSION YES) # -Wnon-literal-null-conversion
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_IMPLICIT_SIGN_CONVERSION NO) # -Wsign-conversion [DISABLED] - FIXME
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_INFINITE_RECURSION YES) # -Winfinite-recursion
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED YES) # -Wmissing-braces
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_RETURN_TYPE YES) # -Wreturn-type
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_MISSING_PARENTHESES YES) # -Wparentheses
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS YES) # -Wmissing-field-initializers
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_PROTOTYPES NO) # -Wmissing-prototypes [DISABLED]
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_NEWLINE YES) # -Wnewline-eof
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_ASSIGN_ENUM YES) # -Wassign-enum (TODO: ADD BELOW TO CLANG?)
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_POINTER_SIGNEDNESS YES) # -Wpointer-sign
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_SEMICOLON_BEFORE_METHOD_BODY YES) # -Wsemicolon-before-method-body
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_SIGN_COMPARE NO) # -Wsign-compare [DISABLED]
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_STRICT_PROTOTYPES NO) # -Wstrict-prototypes [DISABLED]
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_COMMA YES) # -Wcomma
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION NO) ## [DISABLED] - FIXME
set(CMAKE_XCODE_ATTRIBUTE_GCC_TREAT_INCOMPATIBLE_POINTER_TYPE_WARNINGS_AS_ERRORS YES)
set(CMAKE_XCODE_ATTRIBUTE_GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS NO)
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_TYPECHECK_CALLS_TO_PRINTF YES) # -Wformat
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_UNGUARDED_AVAILABILITY YES_AGGRESSIVE) # -Wunguarded-availability
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNINITIALIZED_AUTOS YES_AGGRESSIVE) # -Wuninitialized
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNKNOWN_PRAGMAS YES) # -Wunknown-pragmas
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_UNREACHABLE_CODE NO) # -Wunreachable-code [DISABLED] - FIXME
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_FUNCTION YES) # -Wunused-function
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_LABEL YES) # -Wunused-label
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_PARAMETER NO) # -Wunused-parameter [DISABLED] - FIXME?
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VALUE YES) # -Wunused-value
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VARIABLE YES) # -Wunused-variable
# Apple Clang - Warnings - C++
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN__EXIT_TIME_DESTRUCTORS NO) # -Wexit-time-destructors [DISABLED]
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_NON_VIRTUAL_DESTRUCTOR YES) # -Wnon-virtual-dtor
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS YES) # -Woverloaded-virtual
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_RANGE_LOOP_ANALYSIS YES) # -Wrange-loop-analysis
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_SUSPICIOUS_MOVE YES) # -Wmove
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO YES) # -Winvalid-offsetof
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_CXX0X_EXTENSIONS YES) # -Wc++11-extensions
# Apple Clang - Warnings - Objective-C
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_DIRECT_OBJC_ISA_USAGE YES_ERROR) # -Wdeprecated-objc-isa-usage
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN__DUPLICATE_METHOD_MATCH YES) # -Wduplicate-method-match
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_OBJC_IMPLICIT_ATOMIC_PROPERTIES YES) # -Wmplicit-atomic-properties
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_OBJC_LITERAL_CONVERSION YES) # -Wobjc-literal-conversion
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL YES) # -Wprotocol
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_OBJC_INTERFACE_IVARS YES) # -Wobjc-interface-ivars
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS YES) # -Wdeprecated-implementations
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_STRICT_SELECTOR_MATCH YES) # -Wstrict-selector-match
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNDECLARED_SELECTOR YES) # -Wundeclared-selector
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_OBJC_ROOT_CLASS YES_ERROR) # -Wobjc-root-class
# Apple LLVM - Warnings - Objective-C and ARC
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_OBJC_EXPLICIT_OWNERSHIP_TYPE YES) # -Wexplicit-ownership-type
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF YES) # -Wimplicit-retain-self
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK YES) # -Warc-repeated-use-of-weak
set(CMAKE_XCODE_ATTRIBUTE_CLANG_WARN__ARC_BRIDGE_CAST_NONARC YES) # -Warc-bridge-casts-disallowed-in-nonarc
else()
# GCC, Clang, etc
# Comments are provided next to each warning option detailing expected compiler support (from GCC 3.4+, Clang 3.2+ - earlier versions may / may not support these options)
set(_supported_c_compiler_flags "")
set(_supported_cxx_compiler_flags "")
# Enable -Wpedantic (if supported)
check_compiler_flags_output("-Werror -Wpedantic -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wpedantic" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wpedantic -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wpedantic" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# Enable -Wall (if supported)
check_compiler_flags_output("-Werror -Wall -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wall" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wall -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wall" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# Enable -Wextra (if supported)
check_compiler_flags_output("-Werror -Wextra -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wextra" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wextra -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wextra" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# Enable -fno-common (if supported)
check_compiler_flags_output("-Werror -fno-common -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-fno-common" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -fno-common -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-fno-common" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# Enable -fno-math-errno (if supported)
check_compiler_flags_output("-Werror -fno-math-errno -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-fno-math-errno" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -fno-math-errno -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-fno-math-errno" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wcast-align (GCC 3.4+, Clang 3.2+)
check_compiler_flags_output("-Werror -Wcast-align -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wcast-align" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wcast-align -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wcast-align" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wcast-qual (GCC 3.4+, Clang 3.2+ (no-op until 3.6+))
check_compiler_flags_output("-Werror -Wcast-qual -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wcast-qual" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wcast-qual -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wcast-qual" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wctor-dtor-privacy (GCC 3.4+, Clang 3.2+ (no-op through at least 6.0)) [C++-only]
check_compiler_flags_output("-Werror -Wctor-dtor-privacy -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wctor-dtor-privacy" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Winit-self (GCC 3.4+, Clang 3.2+ (no-op through at least 6.0))
check_compiler_flags_output("-Werror -Winit-self -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Winit-self" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Winit-self -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Winit-self" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# # NOTE: Currently disabled
# # -Wmissing-declarations (GCC 3.4+, Clang 3.2+)
# check_compiler_flags_output("-Werror -Wmissing-declarations -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wmissing-declarations" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
# check_compiler_flags_output("-Werror -Wmissing-declarations -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wmissing-declarations" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# # NOTE: Currently disabled because of miniupnpc (pending fix)
# # -Wmissing-include-dirs (GCC 4.0+, Clang 3.2+ (no-op through at least 6.0))
# check_compiler_flags_output("-Werror -Wmissing-include-dirs -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wmissing-include-dirs" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
# check_compiler_flags_output("-Werror -Wmissing-include-dirs -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wmissing-include-dirs" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# # NOTE: Currently disabled because of GLM
# # -Wnoexcept (GCC 4.6+) [C++-only]
# check_compiler_flags_output("-Werror -Wnoexcept -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wnoexcept" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Woverloaded-virtual (GCC 3.4+, Clang 3.2+) [C++-only]
check_compiler_flags_output("-Werror -Woverloaded-virtual -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Woverloaded-virtual" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wstrict-null-sentinel (GCC 4.0+) [C++-only]
check_compiler_flags_output("-Werror -Wstrict-null-sentinel -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wstrict-null-sentinel" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wwrite-strings (GCC 3.4+, Clang 3.2+)
check_compiler_flags_output("-Werror -Wwrite-strings -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wwrite-strings" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wwrite-strings -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wwrite-strings" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wpointer-arith (GCC 3.4+, Clang 3.2+)
check_compiler_flags_output("-Werror -Wpointer-arith -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wpointer-arith" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wpointer-arith -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wpointer-arith" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wstrict-prototypes (GCC 3.4+, Clang 3.2+ (no-op through at least 6.0)) [C-only]
check_compiler_flags_output("-Werror -Wstrict-prototypes -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wstrict-prototypes" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
# # TODO: Enable this, and verify all code functions as expected
# # -Wfloat-equal (GCC 3.4+)
# check_compiler_flags_output("-Werror -Wfloat-equal -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wfloat-equal" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
# check_compiler_flags_output("-Werror -Wfloat-equal -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wfloat-equal" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wmissing-noreturn (GCC 3.4+, Clang 3.3+)
check_compiler_flags_output("-Werror -Wmissing-noreturn -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wmissing-noreturn" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wmissing-noreturn -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wmissing-noreturn" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# # -Wundef (GCC 3.4+, Clang (supported, but min version unclear))
# check_compiler_flags_output("-Werror -Wundef -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wundef" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
# check_compiler_flags_output("-Werror -Wundef -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wundef" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wnon-virtual-dtor (GCC 3.4+, Clang 3.2+) [C++ only]
check_compiler_flags_output("-Werror -Wnon-virtual-dtor -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wnon-virtual-dtor" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# # FUTURE-TODO: Enable -Wshadow (lots of warnings to fix, some due to 3rdparty dependencies?)
# # -Wshadow (GCC 3.4+, Clang 3.2+)
# check_compiler_flags_output("-Werror -Wshadow -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wshadow" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
# check_compiler_flags_output("-Werror -Wshadow -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wshadow" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# # FUTURE-TODO: Enable -Wuseless-cast (large number of warnings to fix)
# # -Wuseless-cast (GCC 4.8+)
# check_compiler_flags_output("-Werror -Wuseless-cast -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wuseless-cast" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
# check_compiler_flags_output("-Werror -Wuseless-cast -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wuseless-cast" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wnull-dereference (GCC 6.0+, Clang 3.2+)
check_compiler_flags_output("-Werror -Wnull-dereference -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wnull-dereference" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wnull-dereference -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wnull-dereference" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wduplicated-cond (GCC 6.0+)
check_compiler_flags_output("-Werror -Wduplicated-cond -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wduplicated-cond" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wduplicated-cond -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wduplicated-cond" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Walloc-zero (GCC 7.0+)
check_compiler_flags_output("-Werror -Walloc-zero -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Walloc-zero" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Walloc-zero -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Walloc-zero" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Walloca-larger-than=1024 (GCC 7.0+)
check_compiler_flags_output("-Werror -Walloca-larger-than=1024 -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Walloca-larger-than=1024" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Walloca-larger-than=1024 -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Walloca-larger-than=1024" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wrestrict (GCC 7.0+)
check_compiler_flags_output("-Werror -Wrestrict -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wrestrict" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wrestrict -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wrestrict" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wnewline-eof (Clang 3.4+)
check_compiler_flags_output("-Werror -Wnewline-eof -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wnewline-eof" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wnewline-eof -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wnewline-eof" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wrange-loop-analysis (Clang 3.7+)
check_compiler_flags_output("-Werror -Wrange-loop-analysis -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wrange-loop-analysis" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wcomma (Clang 3.9+)
check_compiler_flags_output("-Werror -Wcomma -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wcomma" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wcomma -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wcomma" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wfloat-conversion (GCC 4.9+, Clang 3.5+)
check_compiler_flags_output("-Werror -Wfloat-conversion -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wfloat-conversion" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wfloat-conversion -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wfloat-conversion" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wformat-security
check_compiler_flags_output("-Werror -Wformat-security -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wformat-security" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wformat-security -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wformat-security" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# -Wstringop-truncation (GCC 8.0+)
check_compiler_flags_output("-Werror -Wstringop-truncation -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wstringop-truncation" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wstringop-truncation -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wstringop-truncation" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
if (WZ_ENABLE_WARNINGS_AS_ERRORS)
# Enable -Werror (if supported)
check_compiler_flags_output("-Werror" COMPILER_TYPE C OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror" COMPILER_TYPE CXX OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
else()
message( STATUS "WZ will *NOT* enable -Werror" )
endif()
# Enable -Wlogical-op (if supported) (warning-only for now)
check_compiler_flags_output("-Werror ${WZ_Wno_}logical-op -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "${WZ_Wno_}logical-op" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror ${WZ_Wno_}logical-op -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "${WZ_Wno_}logical-op" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# Handle -Wfloat-conversion (warning-only for now)
check_compiler_flags_output("-Werror ${WZ_Wno_}float-conversion -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "${WZ_Wno_}float-conversion" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror ${WZ_Wno_}float-conversion -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "${WZ_Wno_}float-conversion" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# Handle "sign-compare" (warning-only for now)
check_compiler_flags_output("-Werror ${WZ_Wno_}sign-compare -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "${WZ_Wno_}sign-compare" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror ${WZ_Wno_}sign-compare -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "${WZ_Wno_}sign-compare" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# Disable -Wunused-parameter (FIXME)
check_compiler_flags_output("-Werror -Wno-unused-parameter -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wno-unused-parameter" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wno-unused-parameter -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wno-unused-parameter" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
# Disable -Wformat-truncation (FIXME?) (Test with GCC 8.0+)
check_compiler_flags_output("-Werror -Wformat-truncation -Wno-error=cpp" COMPILER_TYPE C OUTPUT_FLAGS "-Wno-format-truncation" OUTPUT_VARIABLE _supported_c_compiler_flags APPEND)
check_compiler_flags_output("-Werror -Wformat-truncation -Wno-error=cpp" COMPILER_TYPE CXX OUTPUT_FLAGS "-Wno-format-truncation" OUTPUT_VARIABLE _supported_cxx_compiler_flags APPEND)
message( STATUS "Supported C compiler_flags=${_supported_c_compiler_flags}" )
message( STATUS "Supported CXX compiler_flags=${_supported_cxx_compiler_flags}" )
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_supported_c_compiler_flags}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_supported_cxx_compiler_flags}")
endif()
endmacro(CONFIGURE_WZ_COMPILER_WARNINGS)
add_definitions("-DHAVE_CONFIG_H")
# CMAKE_CURRENT_BINARY_DIR should come before the current source directory
# so that any build products are preferentially included over in-source build
# products that might have been generated by a different compilation method / run
include_directories("${CMAKE_CURRENT_BINARY_DIR}")
include_directories(".")
include_directories("3rdparty")
include_directories(SYSTEM "3rdparty/glm")
SET(STDC_HEADERS ON)
SET(PACKAGE "warzone2100")
SET(PACKAGE_BUGREPORT "http://wz2100.net/")
SET(PACKAGE_NAME "Warzone 2100")
SET(PACKAGE_TARNAME "warzone2100")
SET(PACKAGE_DISTRIBUTOR "${WZ_DISTRIBUTOR}")
SET(_ALL_SOURCE 1)
SET(_GNU_SOURCE 1)
SET(_POSIX_PTHREAD_SEMANTICS 1)
SET(_TANDEM_SOURCE 1)
if(CMAKE_SYSTEM_NAME MATCHES "SunOS") # Solaris / SunOS
SET(__EXTENSIONS__ 1)
endif()
SET(_DARWIN_C_SOURCE 1)
SET(_MINIX OFF)
SET(_POSIX_1_SOURCE OFF)
SET(_POSIX_SOURCE OFF)
if(NOT CMAKE_SYSTEM_NAME MATCHES "BSD") # Do not set _XOPEN_SOURCE on FreeBSD (etc)
SET(_XOPEN_SOURCE 700) # Enable POSIX extensions if present
endif()
INCLUDE (CheckIncludeFiles)
CHECK_INCLUDE_FILES(alloca.h HAVE_ALLOCA_H)
CHECK_INCLUDE_FILES(inttypes.h HAVE_INTTYPES_H)
CHECK_INCLUDE_FILES(memory.h HAVE_MEMORY_H)
CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H)
CHECK_INCLUDE_FILES(stdlib.h HAVE_STDLIB_H)
CHECK_INCLUDE_FILES(strings.h HAVE_STRINGS_H)
CHECK_INCLUDE_FILES(string.h HAVE_STRING_H)
CHECK_INCLUDE_FILES("sys/stat.h" HAVE_SYS_STAT_H)
CHECK_INCLUDE_FILES("sys/types.h" HAVE_SYS_TYPES_H)
CHECK_INCLUDE_FILES("sys/ucontext.h" HAVE_SYS_UCONTEXT_H)
CHECK_INCLUDE_FILES(unistd.h HAVE_UNISTD_H)
INCLUDE (CheckFunctionExists)
INCLUDE (CMakePushCheckState)
INCLUDE (CheckCXXSymbolExists)
cmake_reset_check_state()
list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_ALL_SOURCE=${_ALL_SOURCE}")
list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_GNU_SOURCE=${_GNU_SOURCE}")
list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_POSIX_PTHREAD_SEMANTICS=${_POSIX_PTHREAD_SEMANTICS}")
list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_TANDEM_SOURCE=${_TANDEM_SOURCE}")
if(__EXTENSIONS__)
list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D__EXTENSIONS__=${__EXTENSIONS__}")
endif()
list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_DARWIN_C_SOURCE=${_DARWIN_C_SOURCE}")
if(_XOPEN_SOURCE)
list(APPEND CMAKE_REQUIRED_DEFINITIONS "-D_XOPEN_SOURCE=${_XOPEN_SOURCE}")
endif()
message(STATUS "CMAKE_REQUIRED_DEFINITIONS=${CMAKE_REQUIRED_DEFINITIONS}")
CHECK_FUNCTION_EXISTS(gettext HAVE_GETTEXT)
CHECK_FUNCTION_EXISTS(iconv HAVE_ICONV)
CHECK_CXX_SYMBOL_EXISTS(strlcat "string.h" HAVE_SYSTEM_STRLCAT)
CHECK_CXX_SYMBOL_EXISTS(strlcpy "string.h" HAVE_SYSTEM_STRLCPY)
CHECK_CXX_SYMBOL_EXISTS(strlcat "string.h" HAVE_VALID_STRLCAT)
CHECK_CXX_SYMBOL_EXISTS(strlcpy "string.h" HAVE_VALID_STRLCPY)
CHECK_CXX_SYMBOL_EXISTS(putenv "stdlib.h" HAVE_PUTENV)
CHECK_CXX_SYMBOL_EXISTS(setenv "stdlib.h" HAVE_SETENV)
cmake_reset_check_state()
set(WZ_BINDIR "${CMAKE_INSTALL_BINDIR}")
set(WZ_LOCALEDIR "${CMAKE_INSTALL_LOCALEDIR}")
message(STATUS "WZ_BINDIR=\"${WZ_BINDIR}\"")
message(STATUS "WZ_LOCALEDIR=\"${WZ_LOCALEDIR}\"")
function(CHECK_IS_ABSOLUTE_PATH _var _output)
if(IS_ABSOLUTE "${${_var}}")
set(${_output} ON PARENT_SCOPE)
else()
unset(${_output} PARENT_SCOPE)
endif()
endfunction()
CHECK_IS_ABSOLUTE_PATH(WZ_DATADIR WZ_DATADIR_ISABSOLUTE)
CHECK_IS_ABSOLUTE_PATH(WZ_LOCALEDIR WZ_LOCALEDIR_ISABSOLUTE)
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
# Attempt to find Miniupnpc (minimum supported API version = 9)
# NOTE: This is not available on every platform / distro
find_package(Miniupnpc 9)
if(MINIUPNPC_FOUND)
set(WZ_USE_IMPORTED_MINIUPNPC ON)
else()
message(STATUS "Using in-tree Miniupnpc")
set(WZ_USE_IMPORTED_MINIUPNPC OFF)
SET(UPNPC_BUILD_STATIC ON CACHE BOOL "miniupnpc - Build static library" FORCE)
SET(UPNPC_BUILD_SHARED OFF CACHE BOOL "miniupnpc - Build shared library" FORCE)
SET(UPNPC_BUILD_TESTS OFF CACHE BOOL "miniupnpc - Build tests" FORCE)
SET(UPNPC_BUILD_SAMPLE OFF CACHE BOOL "miniupnpc - Build samples" FORCE)
SET(UPNPC_NO_INSTALL TRUE CACHE BOOL "miniupnpc - Disable installation" FORCE)
add_subdirectory(3rdparty/miniupnp/miniupnpc)
set_property(TARGET libminiupnpc-static PROPERTY FOLDER "3rdparty")
endif()
add_subdirectory(3rdparty)
set(wz2100_ROOT_FILES ChangeLog AUTHORS COPYING.NONGPL COPYING COPYING.README README.md)
CONFIGURE_WZ_COMPILER_WARNINGS()
add_subdirectory(lib)
add_subdirectory(data)
add_subdirectory(doc)
add_subdirectory(icons)
add_subdirectory(po)
add_subdirectory(src)
add_subdirectory(pkg)
# Install base text / info files
if(CMAKE_SYSTEM_NAME MATCHES "Windows")
# Target system is Windows
# Must convert the wz2100_ROOT_FILES to Windows line endings, and rename with ".txt" at the end
set(_new_wz2100_ROOT_FILES)
foreach(rfile ${wz2100_ROOT_FILES})
get_filename_component(_rfile_filename ${rfile} NAME)
# Read in the file
file(READ ${rfile} _contents)
# Strip all CRs
string(REPLACE "\r" "" _contents ${_contents})
# Convert all LFs to CRLFs
string(REPLACE "\n" "\r\n" _contents ${_contents})
# Write out the converted file
set(_rfile_newfilename "${CMAKE_CURRENT_BINARY_DIR}/${_rfile_filename}.txt")
file(WRITE "${_rfile_newfilename}" ${_contents})
list(APPEND _new_wz2100_ROOT_FILES "${_rfile_newfilename}")
endforeach()
set(wz2100_ROOT_FILES ${_new_wz2100_ROOT_FILES})
else()
# Just copy the files to the build directory
foreach(rfile ${wz2100_ROOT_FILES})
get_filename_component(_rfile_filename ${rfile} NAME)
configure_file(${rfile} "${CMAKE_CURRENT_BINARY_DIR}/${_rfile_filename}" COPYONLY)
endforeach()
endif()
foreach(rfile ${wz2100_ROOT_FILES})
install(FILES ${rfile}
COMPONENT Info
DESTINATION "${CMAKE_INSTALL_DOCDIR}"
)
endforeach()
# Add "dist" target alias (using CPack package_source)
get_filename_component(_cmake_path ${CMAKE_COMMAND} PATH)
find_program(CPACK_COMMAND cpack ${_cmake_path})
unset(_cmake_path)
if(CPACK_COMMAND)
add_custom_target(dist
COMMAND ${CPACK_COMMAND} --config ${CMAKE_CURRENT_BINARY_DIR}/CPackSourceConfig.cmake
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
set_property(TARGET dist PROPERTY FOLDER "_WZAliasTargets")
endif()
|