Add backend-specific EXCLUDE options

The LLVM backedn excludes by regex, and the LCOV backend excludes by
glob, which are incompatible with each other. Thus, to better accomodate
workflows that may utilize either/both backends, add new LLVM_EXCLUDE
and LCOV_EXCLUDE that apply only to that backend.

The original EXCLUDE option will still apply to both and can be useful
for items such as full file paths.

Author: StableCoder

README.md

@@ -192,11 +192,11 @@ To enable any code coverage instrumentation/targets, the single CMake option of
 From this point, there are two primary methods for adding instrumentation to targets:
 1. A blanket instrumentation by calling `add_code_coverage()`, where all targets in that directory and all subdirectories are automatically instrumented.
 2. Per-target instrumentation by calling `target_code_coverage(<TARGET_NAME>)`, where the target is given and thus only that target is instrumented and executables have ccov* targets created. This applies to both libraries and executables.
-3. Automatically add coverage for each target with `-DCCOV_TARGETS_HOOK=On` and `-DCCOV_TARGETS_HOOK_ARGS=...` for default values, requires `add_code_coverage()` or similar.
+3. Automatically add coverage for each target with `-DCCOV_TARGETS_HOOK=ON` and `-DCCOV_TARGETS_HOOK_ARGS=...` for default values, requires `add_code_coverage()` or similar.
 
 To add coverage targets, such as calling `make ccov` to generate the actual coverage information for perusal or consumption, call `target_code_coverage(<TARGET_NAME>)` on an *executable* target.
 
-**NOTE:** For more options, please check the actual [`code-coverage.cmake`](code-coverage.cmake) file.
+**NOTE:** For more options, please check the documentation for each function in the [`code-coverage.cmake`](code-coverage.cmake) file.
 
 #### Example 1 - All targets instrumented
 
@@ -235,10 +235,21 @@ target_code_coverage(theExe EXCLUDE non_covered.cpp) # As an executable target,
 #### Example 3: Target added to the 'ccov' and 'ccov-all' targets
 
 ```
-add_code_coverage_all_targets(EXCLUDE test/*) # Adds the 'ccov-all' target set and sets it to exclude all files in test/ folders.
+# Adds the 'ccov-all' target set and sets it to exclude a specific 
+# file and all files in test/ folders.
+add_code_coverage_all_targets(
+  EXCLUDE non_covered.cpp
+  LCOV_EXCLUDE test/*
+  LLVM_EXCLUDE test/.*)
 
 add_executable(theExe main.cpp non_covered.cpp)
-target_code_coverage(theExe AUTO ALL EXCLUDE non_covered.cpp test/*) # As an executable target, adds to the 'ccov' and ccov-all' targets, and the reports will exclude the non-covered.cpp file, and any files in a test/ folder.
+# As an executable target, adds to the 'ccov' and ccov-all' targets, and
+# the reports will exclude the non-covered.cpp file, and any files in a test/ folder.
+target_code_coverage(theExe AUTO ALL 
+  EXCLUDE non_covered.cpp  # a file path which applies to both backends
+  LCOV_EXCLUDE test/*   # the GCC/lcov backend excludes by glob
+  LLVM_EXCLUDE test/.*  # the clang/LLVM backend exclude by regext
+  )
 ```
 
 #### Example 4: Hook all targets

code-coverage.cmake

@@ -61,13 +61,18 @@
 #
 # ~~~
 # add_executable(theExe main.cpp non_covered.cpp)
-# target_code_coverage(theExe EXCLUDE non_covered.cpp test/*) # As an executable target, the reports will exclude the non-covered.cpp file, and any files in a test/ folder.
+# target_code_coverage(theExe
+#     EXCLUDE non_covered.cpp
+#     LCOV_EXCLUDE test/*
+#     LLVM_EXCLUDE test/.*) # As an executable target, the reports will exclude the non-covered.cpp file, and any files in a test/ folder.
 # ~~~
 #
 # Example 3: Target added to the 'ccov' and 'ccov-all' targets
 #
 # ~~~
-# add_code_coverage_all_targets(EXCLUDE test/*) # Adds the 'ccov-all' target set and sets it to exclude all files in test/ folders.
+# add_code_coverage_all_targets(
+#     LCOV_EXCLUDE test/*
+#     LLVM_EXCLUDE test/.*)# Adds the 'ccov-all' target set and sets it to exclude all files in test/ folders.
 #
 # add_executable(theExe main.cpp non_covered.cpp)
 # target_code_coverage(theExe AUTO ALL EXCLUDE non_covered.cpp test/*) # As an executable target, adds to the 'ccov' and ccov-all' targets, and the reports will exclude the non-covered.cpp file, and any files in a test/ folder.
@@ -234,7 +239,9 @@ endif()
 # ALL - Adds the target to the 'ccov-all-*' targets created by a prior call to `add_code_coverage_all_targets` Effective on executable targets.
 # EXTERNAL - For GCC's lcov, allows the profiling of 'external' files from the processing directory
 # COVERAGE_TARGET_NAME - For executables ONLY, changes the outgoing target name so instead of `ccov-${TARGET_NAME}` it becomes `ccov-${COVERAGE_TARGET_NAME}`.
-# EXCLUDE <PATTERNS> - Excludes files of the patterns provided from coverage. Note that GCC/lcov excludes by glob pattern, and clang/LLVM excludes via regex! **These do not copy to the 'all' targets.**
+# EXCLUDE <PATTERNS> - Excludes files of the patterns provided from coverage. Added to any lcov/llvm specific excludes. sNote that GCC/lcov excludes by glob pattern, and clang/LLVM excludes via regex! **These do not copy to the 'all' targets.**
+# LLVM_EXCLUDE <PATTERNS> - Excludes files that match the provided patterns, LLVM excludes by regex patterns.
+# LCOV_EXCLUDE <PATTERNS> - Excludes files that match the provided patterns. LCOV exclude by glob patterns.
 # OBJECTS <TARGETS> - For executables ONLY, if the provided targets are static or shared libraries, adds coverage information to the output
 # PRE_ARGS <ARGUMENTS> - For executables ONLY, prefixes given arguments to the associated ccov-run-${TARGET_NAME} executable call ($<PRE_ARGS> ccov-*)
 # ARGS <ARGUMENTS> - For executables ONLY, appends the given arguments to the associated ccov-run-${TARGET_NAME} executable call (ccov-* $<ARGS>)
@@ -247,7 +254,8 @@ function(target_code_coverage TARGET_NAME)
   # Argument parsing
   set(options AUTO ALL EXTERNAL PUBLIC INTERFACE PLAIN)
   set(single_value_keywords COVERAGE_TARGET_NAME)
-  set(multi_value_keywords EXCLUDE OBJECTS PRE_ARGS ARGS)
+  set(multi_value_keywords EXCLUDE LLVM_EXCLUDE LCOV_EXCLUDE OBJECTS PRE_ARGS
+                           ARGS)
   cmake_parse_arguments(
     target_code_coverage "${options}" "${single_value_keywords}"
     "${multi_value_keywords}" ${ARGN})
@@ -392,11 +400,16 @@ function(target_code_coverage TARGET_NAME)
         DEPENDS ${target_code_coverage_COVERAGE_TARGET_NAME}.profraw)
 
       # Ignore regex only works on LLVM >= 7
+      set(EXCLUDE_REGEX)
       if(LLVM_COV_VERSION VERSION_GREATER_EQUAL "7.0.0")
         foreach(EXCLUDE_ITEM ${target_code_coverage_EXCLUDE})
           set(EXCLUDE_REGEX ${EXCLUDE_REGEX}
                             -ignore-filename-regex='${EXCLUDE_ITEM}')
         endforeach()
+        foreach(EXCLUDE_ITEM ${target_code_coverage_LLVM_EXCLUDE})
+          set(EXCLUDE_REGEX ${EXCLUDE_REGEX}
+                            -ignore-filename-regex='${EXCLUDE_ITEM}')
+        endforeach()
       endif()
 
       # Print out details of the coverage information to the command line
@@ -451,10 +464,15 @@ function(target_code_coverage TARGET_NAME)
       )
 
       # Generate exclusion string for use
+      set(EXCLUDE_REGEX)
       foreach(EXCLUDE_ITEM ${target_code_coverage_EXCLUDE})
         set(EXCLUDE_REGEX ${EXCLUDE_REGEX} --remove ${COVERAGE_INFO}
                           '${EXCLUDE_ITEM}')
       endforeach()
+      foreach(EXCLUDE_ITEM ${target_code_coverage_LCOV_EXCLUDE})
+        set(EXCLUDE_REGEX ${EXCLUDE_REGEX} --remove ${COVERAGE_INFO}
+                          '${EXCLUDE_ITEM}')
+      endforeach()
 
       if(EXCLUDE_REGEX)
         set(EXCLUDE_COMMAND ${LCOV_PATH} ${EXCLUDE_REGEX} --output-file
@@ -639,14 +657,16 @@ endfunction()
 #
 # Optional Parameters:
 # EXCLUDE <PATTERNS> - Excludes files of the patterns provided from coverage. Note that GCC/lcov excludes by glob pattern, and clang/LLVM excludes via regex!
+# LLVM_EXCLUDE <PATTERNS> - Excludes files that match the provided patterns, LLVM excludes by regex patterns.
+# LCOV_EXCLUDE <PATTERNS> - Excludes files that match the provided patterns. LCOV exclude by glob patterns.
 # ~~~
 function(add_code_coverage_all_targets)
   if(NOT CODE_COVERAGE)
     return()
   endif()
 
   # Argument parsing
-  set(multi_value_keywords EXCLUDE)
+  set(multi_value_keywords EXCLUDE LLVM_EXCLUDE LCOV_EXCLUDE)
   cmake_parse_arguments(add_code_coverage_all_targets "" ""
                         "${multi_value_keywords}" ${ARGN})
 
@@ -691,11 +711,16 @@ function(add_code_coverage_all_targets)
     endif()
 
     # Regex exclude only available for LLVM >= 7
+    set(EXCLUDE_REGEX)
     if(LLVM_COV_VERSION VERSION_GREATER_EQUAL "7.0.0")
       foreach(EXCLUDE_ITEM ${add_code_coverage_all_targets_EXCLUDE})
         set(EXCLUDE_REGEX ${EXCLUDE_REGEX}
                           -ignore-filename-regex='${EXCLUDE_ITEM}')
       endforeach()
+      foreach(EXCLUDE_ITEM ${add_code_coverage_all_targets_LLVM_EXCLUDE})
+        set(EXCLUDE_REGEX ${EXCLUDE_REGEX}
+                          -ignore-filename-regex='${EXCLUDE_ITEM}')
+      endforeach()
     endif()
 
     # Print summary of the code coverage information to the command line
@@ -781,6 +806,10 @@ function(add_code_coverage_all_targets)
       set(EXCLUDE_REGEX ${EXCLUDE_REGEX} --remove ${COVERAGE_INFO}
                         '${EXCLUDE_ITEM}')
     endforeach()
+    foreach(EXCLUDE_ITEM ${add_code_coverage_all_targets_LCOV_EXCLUDE})
+      set(EXCLUDE_REGEX ${EXCLUDE_REGEX} --remove ${COVERAGE_INFO}
+                        '${EXCLUDE_ITEM}')
+    endforeach()
 
     if(EXCLUDE_REGEX)
       set(EXCLUDE_COMMAND ${LCOV_PATH} ${EXCLUDE_REGEX} --output-file