SFML/cmake/CompilerWarnings.cmake

94 lines
5.5 KiB
CMake
Raw Normal View History

2021-04-19 04:20:43 +02:00
# from here:
#
# https://github.com/lefticus/cppbestpractices/blob/master/02-Use_the_Tools_Available.md
# Helper function to enable compiler warnings for a specific target
function(set_target_warnings target)
Only enable compiler warnings in developer builds Compiler warnings are a tool we enable as developers to detect issues with our source code that go beyond the basic requirements of compiling C++ code. For example, many implicit conversions are perfectly correct, and defined behavior in C++ but we choose to disallow them with -Wconversion. This is something only us devs have to care about. Someone using SFML wants the library to work well but does not need to concern themselves with such low level details about its implementation. By disabling warnings in non-developer builds, we ensure that non- developer users of SFML are not going to see console noise due to warnings and it prevents issues like GCC's bug 82952 which causes compilation to halt indefitely due to a bug in how a compiler warning is implemented. This also improves compatibility with older compilers. If we enable warnings in all builds no matter what, we have to protect against compilers we don't expect. Perhaps someone uses an older version of GCC that we haven't tested with. This compiler is perfectly fine compiling our C++ but we happen to use a warning flag it does not recognize so the build fails. This is not a good reason for a build to fail but nevertheless it's something we have to deal with so long as we always enable warnings. SFML_WARNINGS_AS_ERRORS is now named somewhat incorrectly but I retained the name for compatibility's sake. We can rename it to SFML_ENABLE_WARNINGS or something similar in SFML 4.
2025-02-13 11:37:37 -05:00
option(SFML_WARNINGS_AS_ERRORS "Enable and enforce compiler warnings" OFF)
# Disable certain deprecation warnings
if(SFML_OS_WINDOWS)
target_compile_definitions(${target} PRIVATE -D_CRT_SECURE_NO_WARNINGS)
target_compile_definitions(${target} PRIVATE -D_WINSOCK_DEPRECATED_NO_WARNINGS)
endif()
if(SFML_COMPILER_CLANG OR SFML_COMPILER_CLANG_CL)
target_compile_options(${target} PRIVATE
-Wno-unknown-warning-option # do not warn on GCC-specific warning diagnostic pragmas
)
endif()
# Short-circuit function to prevent adding any warnings
if(NOT SFML_WARNINGS_AS_ERRORS)
return()
endif()
2021-04-19 04:20:43 +02:00
if(SFML_COMPILER_MSVC)
target_compile_options(${target} PRIVATE
Only enable compiler warnings in developer builds Compiler warnings are a tool we enable as developers to detect issues with our source code that go beyond the basic requirements of compiling C++ code. For example, many implicit conversions are perfectly correct, and defined behavior in C++ but we choose to disallow them with -Wconversion. This is something only us devs have to care about. Someone using SFML wants the library to work well but does not need to concern themselves with such low level details about its implementation. By disabling warnings in non-developer builds, we ensure that non- developer users of SFML are not going to see console noise due to warnings and it prevents issues like GCC's bug 82952 which causes compilation to halt indefitely due to a bug in how a compiler warning is implemented. This also improves compatibility with older compilers. If we enable warnings in all builds no matter what, we have to protect against compilers we don't expect. Perhaps someone uses an older version of GCC that we haven't tested with. This compiler is perfectly fine compiling our C++ but we happen to use a warning flag it does not recognize so the build fails. This is not a good reason for a build to fail but nevertheless it's something we have to deal with so long as we always enable warnings. SFML_WARNINGS_AS_ERRORS is now named somewhat incorrectly but I retained the name for compatibility's sake. We can rename it to SFML_ENABLE_WARNINGS or something similar in SFML 4.
2025-02-13 11:37:37 -05:00
/WX
/W4 # Baseline reasonable warnings
/w14242 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
/w14254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
/w14263 # 'function': member function does not override any base class virtual member function
/w14265 # 'classname': class has virtual functions, but destructor is not virtual instances of this class may not be destructed correctly
/w14287 # 'operator': unsigned/negative constant mismatch
/we4289 # nonstandard extension used: 'variable': loop control variable declared in the for-loop is used outside the for-loop scope
/w14296 # 'operator': expression is always 'boolean_value'
/w14311 # 'variable': pointer truncation from 'type1' to 'type2'
/w14545 # expression before comma evaluates to a function which is missing an argument list
/w14546 # function call before comma missing argument list
/w14547 # 'operator': operator before comma has no effect; expected operator with side-effect
/w14549 # 'operator': operator before comma has no effect; did you intend 'operator'?
/w14555 # expression has no effect; expected expression with side- effect
/w14619 # pragma warning: there is no warning number 'number'
/w14640 # Enable warning on thread un-safe static member initialization
/w14826 # Conversion from 'type1' to 'type_2' is sign-extended. This may cause unexpected runtime behavior.
/w14905 # wide string literal cast to 'LPSTR'
/w14906 # string literal cast to 'LPWSTR'
/w14928 # illegal copy-initialization; more than one user-defined conversion has been implicitly applied
/permissive- # standards conformance mode
2021-04-19 04:20:43 +02:00
# Disables, remove when appropriate
/wd4068 # disable warnings about unknown pragmas (e.g. #pragma GCC)
/wd4505 # disable warnings about unused functions that might be platform-specific
/wd4800 # disable warnings regarding implicit conversions to bool
2024-08-20 15:30:38 -06:00
/wd4275 # disable warnings about exporting non DLL-interface classes
)
2022-08-06 22:13:40 -06:00
endif()
if(SFML_COMPILER_GCC OR SFML_COMPILER_CLANG)
target_compile_options(${target} PRIVATE
Only enable compiler warnings in developer builds Compiler warnings are a tool we enable as developers to detect issues with our source code that go beyond the basic requirements of compiling C++ code. For example, many implicit conversions are perfectly correct, and defined behavior in C++ but we choose to disallow them with -Wconversion. This is something only us devs have to care about. Someone using SFML wants the library to work well but does not need to concern themselves with such low level details about its implementation. By disabling warnings in non-developer builds, we ensure that non- developer users of SFML are not going to see console noise due to warnings and it prevents issues like GCC's bug 82952 which causes compilation to halt indefitely due to a bug in how a compiler warning is implemented. This also improves compatibility with older compilers. If we enable warnings in all builds no matter what, we have to protect against compilers we don't expect. Perhaps someone uses an older version of GCC that we haven't tested with. This compiler is perfectly fine compiling our C++ but we happen to use a warning flag it does not recognize so the build fails. This is not a good reason for a build to fail but nevertheless it's something we have to deal with so long as we always enable warnings. SFML_WARNINGS_AS_ERRORS is now named somewhat incorrectly but I retained the name for compatibility's sake. We can rename it to SFML_ENABLE_WARNINGS or something similar in SFML 4.
2025-02-13 11:37:37 -05:00
-Werror
-Wall
-Wextra # reasonable and standard
-Wshadow # warn the user if a variable declaration shadows one from a parent context
-Wnon-virtual-dtor # warn the user if a class with virtual functions has a non-virtual destructor. This helps catch hard to track down memory errors
-Wcast-align # warn for potential performance problem casts
-Wunused # warn on anything being unused
-Woverloaded-virtual # warn if you overload (not override) a virtual function
-Wconversion # warn on type conversions that may lose data
-Wsign-conversion # warn on sign conversions
-Wdouble-promotion # warn if float is implicit promoted to double
-Wformat=2 # warn on security issues around functions that format output (ie printf)
-Wimplicit-fallthrough # warn when a missing break causes control flow to continue at the next case in a switch statement
-Wsuggest-override # warn when 'override' could be used on a member function overriding a virtual function
-Wnull-dereference # warn if a null dereference is detected
-Wold-style-cast # warn for c-style casts
-Wpedantic # warn if non-standard C++ is used
$<$<BOOL:${SFML_OS_ANDROID}>:-Wno-main> # allow main() to be called
)
endif()
if(SFML_COMPILER_GCC)
# Don't enable -Wduplicated-branches for GCC < 8.1 since it will lead to false positives
# https://github.com/gcc-mirror/gcc/commit/6bebae75035889a4844eb4d32a695bebf412bcd7
target_compile_options(${target} PRIVATE
-Wmisleading-indentation # warn if indentation implies blocks where blocks do not exist
-Wduplicated-cond # warn if if / else chain has duplicated conditions
-Wlogical-op # warn about logical operations being used where bitwise were probably wanted
# -Wuseless-cast # warn if you perform a cast to the same type (disabled because it is not portable as some type aliases might vary between platforms)
$<$<VERSION_GREATER_EQUAL:${CMAKE_CXX_COMPILER_VERSION},8.1>:-Wduplicated-branches> # warn if if / else branches have duplicated code
2021-04-19 04:20:43 +02:00
)
endif()
endfunction()