* improved pedantic flags module

pedantic.cmake

@@ -5,130 +5,232 @@ If ( __PEDANTIC_INCLUDED )
 EndIf ( )
 set ( __PEDANTIC_INCLUDED TRUE )
 
-Include (CheckCCompilerFlag)
-Include (CheckCXXCompilerFlag)
+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 ( __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 ( __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 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})
-        Set (PEDANTIC_C_FLAGS "${PEDANTIC_C_FLAGS} ${FLAG}")
+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 ()
+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 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})
-        Set (PEDANTIC_CXX_FLAGS "${PEDANTIC_CXX_FLAGS} ${FLAG}")
+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 "")
+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 )
+    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 )
-        Set ( CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   ${PEDANTIC_C_FLAGS}" PARENT_SCOPE )
+        __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 )
-        Set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${PEDANTIC_CXX_FLAGS}" PARENT_SCOPE )
+        __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(-g)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wall)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wextra)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wconversion)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Werror)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wno-unused-parameter)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wbad-function-cast)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wcast-align)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wcast-qual)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wconversion)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wdouble-promotion)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wfloat-equal)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wnested-externs)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wno-attributes)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wno-builtin-macro-redefined)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wno-vla)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wno-pragmas)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wno-unknown-pragmas)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wold-style-definition)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Woverlength-strings)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wshadow)
-__PEDANTIC_CHECK_AND_ADD_C_FLAG(-Wwrite-strings)
-
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-ftemplate-depth=2000)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-g)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wall)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wextra)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wconversion)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Werror)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wno-reorder)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wno-unused-parameter)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wcast-align)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wcast-qual)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wconversion)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wdouble-promotion)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wfloat-equal)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wno-attributes)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wno-builtin-macro-redefined)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wno-vla)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wno-pragmas)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wno-unknown-pragmas)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Woverlength-strings)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wshadow)
-__PEDANTIC_CHECK_AND_ADD_CXX_FLAG(-Wwrite-strings)
+__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 )