cmakemodules/pedantic.cmake

# This cmake module is used to set pedantic flags for the C and C++ compiler of your system

If ( __PEDANTIC_INCLUDED )
	Return ( )
EndIf ( )
set ( __PEDANTIC_INCLUDED TRUE )

Include ( CheckCCompilerFlag )
Include ( CheckCXXCompilerFlag )

# Macro to replace the '-Wno' perfix of a flag with '-W'
# VAR_IN  - Input variable
# VAR_OUT - Output variable
Macro ( __PEDANTIC_INVERT_WNO_FLAG VAR_IN VAR_OUT )
    If ( ${VAR_IN} MATCHES "-Wno" )
        String ( REPLACE "-Wno-" "-W" ${VAR_OUT} ${VAR_IN} )
    Else ( )
        Set ( ${VAR_OUT} ${VAR_IN} )
    EndIf ( )
EndMacro ( )

# Macro to create a unique name for the given flag.
# PREFIX - Prefix to add to the name
# FLAG   - Flag to convert to a valid variable name
# OUTPUT - Variable to store output in
Macro ( __PEDANTIC_MAKE_UNIQUE_NAME PREFIX FLAG OUTPUT )
    String ( REGEX REPLACE "[^0-9a-zA-Z]" "_" TMP_NAME ${FLAG} )
    String ( SUBSTRING ${TMP_NAME} 1 -1 TMP_NAME )
    String ( TOUPPER ${TMP_NAME} TMP_NAME )
    Set ( TMP_NAME "${PREFIX}_${TMP_NAME}" )
    Set ( ${OUTPUT} ${TMP_NAME} )
EndMacro ( )

# Macro to check if the C compiler supports the given flag.
# If so the flag is added to the PEDANTIC_C_FLAGS variable.
# FLAG - Compiler flag to check
Macro ( __PEDANTIC_CHECK_AND_ADD_C_FLAG LIST FLAG )
    __PEDANTIC_MAKE_UNIQUE_NAME ( "HAVE_C_FLAG" ${FLAG} FLAG_NAME )
    __PEDANTIC_INVERT_WNO_FLAG ( ${FLAG} TEST_FLAG )
    Set ( OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} )
    Set ( CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${TEST_FLAG} -Werror" )
    CHECK_CXX_COMPILER_FLAG ( ${TEST_FLAG} ${FLAG_NAME} )
    Set ( CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS} )
    If ( ${FLAG_NAME} )
        List ( APPEND "${LIST}" "${FLAG}" )
    EndIf ( )
EndMacro ( )


# Macro to check if the C++ compiler supports the given flag.
# If so the flag is added to the PEDANTIC_C_FLAGS variable.
# FLAG - Compiler flag to check
Macro ( __PEDANTIC_CHECK_AND_ADD_CXX_FLAG LIST FLAG )
    __PEDANTIC_MAKE_UNIQUE_NAME ( "HAVE_CXX_FLAG" ${FLAG} FLAG_NAME )
    __PEDANTIC_INVERT_WNO_FLAG ( ${FLAG} TEST_FLAG )
    Set ( OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} )
    Set ( CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${TEST_FLAG} -Werror" )
    CHECK_CXX_COMPILER_FLAG ( ${TEST_FLAG} ${FLAG_NAME} )
    Set ( CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS} )
    If ( ${FLAG_NAME} )
        List ( APPEND "${LIST}" "${FLAG}" )
    EndIf ( )
EndMacro ( )

Set ( PEDANTIC_C_FLAGS )
Set ( PEDANTIC_CXX_FLAGS )

# Function to get flags for the given compiler
Function ( __PEDANTIC_GET_FLAGS COMPILER OUT )

    Set ( OPTIONS )
    Set ( ONE_VALUE_ARGS )
    Set ( MULTI_VALUE_ARGS IGNORE ADDITIONAL )

    CMake_Parse_Arguments ( ARG "${OPTIONS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN} )

    # remove ignored
    Set ( TMP_PEDANTIC_FLAGS ${PEDANTIC_${COMPILER}_FLAGS} )
    If ( ARG_IGNORE )
        ForEach ( I IN LISTS ARG_IGNORE )
            List ( REMOVE_ITEM TMP_PEDANTIC_FLAGS ${I} )
        EndForEach ( )
    EndIf ( )

    # add additional
    If ( ARG_ADDITIONAL )
        ForEach ( I IN LISTS ARG_ADDITIONAL )
            If ( "${COMPILER}" STREQUAL "C" )
                __PEDANTIC_CHECK_AND_ADD_C_FLAG ( TMP_PEDANTIC_FLAGS ${I} )
            ElseIf ( "${COMPILER}" STREQUAL "CXX" )
                __PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( TMP_PEDANTIC_FLAGS ${I} )
            EndIf ( )
        EndForEach ( )
    EndIf ( )

    # output
    Set ( ${OUT} ${TMP_PEDANTIC_FLAGS} PARENT_SCOPE )

EndFunction ( )

# Function to apply all pedantic flags to the compiler flags
# C   - only add C compiler flags
# CXX - only add C++ compiler flags
# ALL - add all compiler flags
Function ( Pedantic_Apply_Flags )

    Set ( OPTIONS C CXX ALL )
    Set ( ONE_VALUE_ARGS )
    Set ( MULTI_VALUE_ARGS IGNORE IGNORE_C IGNORE_CXX ADDITIONAL ADDITIONAL_C ADDITIONAL_CXX )

    CMake_Parse_Arguments ( ARG "${OPTIONS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN} )

    # apply C flags
    If ( ARG_C OR ARG_ALL )
        __PEDANTIC_GET_FLAGS ( C TMP
                               IGNORE ${ARG_IGNORE};${ARG_IGNORE_C}
                               ADDITIONAL ${ARG_ADDITIONAL};${ARG_ADDITIONAL_C} )
        Set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${TMP}" PARENT_SCOPE )
    EndIf ( )

    # apply CXX flags
    If ( ARG_CXX OR ARG_ALL )
        __PEDANTIC_GET_FLAGS ( CXX TMP
                               IGNORE ${ARG_IGNORE};${ARG_IGNORE_CXX}
                               ADDITIONAL ${ARG_ADDITIONAL};${ARG_ADDITIONAL_CXX} )
        Set ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${TMP}" PARENT_SCOPE )
    EndIf ( )
EndFunction ( )

# Function to apply all pedantic flags to the given target
# C   - only add C compiler flags
# CXX - only add C++ compiler flags
# ALL - add all compiler flags
Function ( Pedantic_Apply_Flags_Target TARGET )

    Set ( OPTIONS C CXX ALL )
    Set ( ONE_VALUE_ARGS VISIBILITY )
    Set ( MULTI_VALUE_ARGS IGNORE IGNORE_C IGNORE_CXX ADDITIONAL ADDITIONAL_C ADDITIONAL_CXX )

    CMake_Parse_Arguments ( ARG "${OPTIONS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN} )

    # visibility
    If ( NOT ARG_VISIBILITY )
        Set ( ARG_VISIBILITY PRIVATE )
    EndIf ( )

    # apply C flags
    If ( ARG_C OR ARG_ALL )
        __PEDANTIC_GET_FLAGS ( C TMP
                               IGNORE ${ARG_IGNORE};${ARG_IGNORE_C}
                               ADDITIONAL ${ARG_ADDITIONAL};${ARG_ADDITIONAL_C} )
        ForEach ( I IN LISTS TMP )
            Target_Compile_Options ( ${TARGET}
                                     ${ARG_VISIBILITY}
                                       ${I} )
        EndForEach ( )
    EndIf ( )

    # apply CXX flags
    If ( ARG_CXX OR ARG_ALL )
        __PEDANTIC_GET_FLAGS ( CXX TMP
                               IGNORE ${ARG_IGNORE};${ARG_IGNORE_CXX}
                               ADDITIONAL ${ARG_ADDITIONAL};${ARG_ADDITIONAL_CXX} )
        ForEach ( I IN LISTS TMP )
            Target_Compile_Options ( ${TARGET}
                                     ${ARG_VISIBILITY}
                                       ${I} )
        EndForEach ( )
    EndIf ( )

EndFunction ( )

# Function to check the passed C flags
Function ( Pedantic_Test_Flags COMPILER OUT )

    Set ( TMP_FLAGS )
    ForEach ( I IN LISTS ARGN )
        If ( "${COMPILER}" STREQUAL "C" )
            __PEDANTIC_CHECK_AND_ADD_C_FLAG ( TMP_FLAGS ${I} )
        ElseIf ( "${COMPILER}" STREQUAL "CXX" )
            __PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( TMP_FLAGS ${I} )
        EndIf ( )
    EndForEach ( )
    Set ( ${OUT} ${TMP_FLAGS} PARENT_SCOPE )

EndFunction ( )

Enable_Language ( C )
Enable_Language ( CXX )

__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -g )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wall )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wextra )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wconversion )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Werror )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wno-unused-parameter )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wbad-function-cast )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wcast-align )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wcast-qual )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wconversion )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wdouble-promotion )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wfloat-equal )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wnested-externs )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wno-attributes )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wno-builtin-macro-redefined )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wno-vla )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wno-pragmas )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wno-unknown-pragmas )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wold-style-definition )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Woverlength-strings )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wshadow )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wwrite-strings )
__PEDANTIC_CHECK_AND_ADD_C_FLAG ( PEDANTIC_C_FLAGS -Wdocumentation )

__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -ftemplate-depth=2000 )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -g )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wall )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wextra )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wconversion )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Werror )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wno-reorder )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wno-unused-parameter )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wcast-align )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wcast-qual )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wconversion )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wdouble-promotion )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wfloat-equal )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wno-attributes )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wno-builtin-macro-redefined )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wno-vla )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wno-pragmas )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wno-unknown-pragmas )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Woverlength-strings )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wshadow )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wwrite-strings )
__PEDANTIC_CHECK_AND_ADD_CXX_FLAG ( PEDANTIC_CXX_FLAGS -Wdocumentation )