cmake examples

ornladios/ADIOS2 cmake/upstream/FindMPI.cmake :622

string(REGEX MATCHALL "(^| )${_MPI_PREPROCESSOR_FLAG_REGEX}-D *([^\" ]+|\"[^\"]+\")" MPI_ALL_COMPILE_DEFINITIONS "${MPI_COMPILE_CMDLINE}")

ornladios/ADIOS2 cmake/upstream/FindMPI.cmake :654

string(REGEX MATCHALL "(^| )${CMAKE_LIBRARY_PATH_FLAG} *([^\" ]+|\"[^\"]+\")" MPI_DIRECT_LINK_PATHS "${MPI_LINK_CMDLINE}")

ornladios/ADIOS2 cmake/upstream/FindPython/Support.cmake :546

string (REGEX MATCHALL "-(l|framework)[ ]*[^ ]+" _values "${_values}")

ornladios/ADIOS2 cmake/upstream/FindPython/Support.cmake :601

string (REGEX MATCHALL "[0-9]+" versions "${version}")

catchorg/Catch2 extras/ParseAndAddCatchTests.cmake :136

    string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^,^\"]*" TestTypeAndFixture "${TestName}")
    string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)" TestType "${TestTypeAndFixture}")
    string(REGEX REPLACE "${TestType}\\([ \t]*" "" TestFixture "${TestTypeAndFixture}")

    # Get string parts of test definition
    string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")

    # Strip wrapping quotation marks
    string(REGEX REPLACE "^\"(.*)\"$" "\\1" TestStrings "${TestStrings}")
    string(REPLACE "\";\"" ";" TestStrings "${TestStrings}")

    # Validate that a test name and tags have been provided
    list(LENGTH TestStrings TestStringsLength)
    if(TestStringsLength GREATER 2 OR TestStringsLength LESS 1)
      message(FATAL_ERROR "You must provide a valid test name and tags for all tests in ${SourceFile}")
    endif()

    # Assign name and tags
    list(GET TestStrings 0 Name)
    if("${TestType}" STREQUAL "SCENARIO")
      set(Name "Scenario: ${Name}")
    endif()
    if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND "${TestType}" MATCHES "(CATCH_)?TEST_CASE_METHOD" AND TestFixture)
      set(CTestName "${TestFixture}:${Name}")
    else()
      set(CTestName "${Name}")
    endif()
    if(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME)
      set(CTestName "${TestTarget}:${CTestName}")
    endif()
    # add target to labels to enable running all tests added from this target
    set(Labels ${TestTarget})
    if(TestStringsLength EQUAL 2)
      list(GET TestStrings 1 Tags)
      string(TOLOWER "${Tags}" Tags)
      # remove target from labels if the test is hidden
      if("${Tags}" MATCHES ".*\\[!?(hide|\\.)\\].*")
        list(REMOVE_ITEM Labels ${TestTarget})
      endif()
      string(REPLACE "]" ";" Tags "${Tags}")
      string(REPLACE "[" "" Tags "${Tags}")
    else()
      # unset tags variable from previous loop
      unset(Tags)
    endif()

    list(APPEND Labels ${Tags})

    set(HiddenTagFound OFF)
    foreach(label ${Labels})
      string(REGEX MATCH "^!hide|^\\." result ${label})
      if(result)
        set(HiddenTagFound ON)
        break()
      endif()
    endforeach(label)
    if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
      ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
    else()
      ParseAndAddCatchTests_PrintDebugMessage("Adding test \"${CTestName}\"")
      if(Labels)
        ParseAndAddCatchTests_PrintDebugMessage("Setting labels to ${Labels}")
      endif()

      # Escape commas in the test spec
      string(REPLACE "," "\\," Name ${Name})

      # Work around CMake 3.18.0 change in `add_test()`, before the escaped quotes were necessary,
      # only with CMake 3.18.0 the escaped double quotes confuse the call. This change is reverted in 3.18.1
      # And properly introduced in 3.19 with the CMP0110 policy
      if(_cmp0110_value STREQUAL "NEW" OR ${CMAKE_VERSION} VERSION_EQUAL "3.18")
        ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to NEW, no need for add_test(\"\") workaround")
      else()
        ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to OLD adding \"\" for add_test() workaround")
        set(CTestName "\"${CTestName}\"")
      endif()

      # Handle template test cases
      if("${TestTypeAndFixture}" MATCHES ".*TEMPLATE_.*")
        set(Name "${Name} - *")
      endif()

      # Add the test and set its properties
      add_test(NAME "${CTestName}" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
      # Old CMake versions do not document VERSION_GREATER_EQUAL, so we use VERSION_GREATER with 3.8 instead
      if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_GREATER "3.8")
        ParseAndAddCatchTests_PrintDebugMessage("Setting DISABLED test property")
        set_tests_properties("${CTestName}" PROPERTIES DISABLED ON)
      else()
        set_tests_properties("${CTestName}" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
                                                LABELS "${Labels}")
      endif()
      set_property(
        TARGET ${TestTarget}
        APPEND
        PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
      set_property(
        SOURCE ${SourceFile}
        APPEND
        PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
    endif()
  endforeach()
endfunction()

# entry point
function(ParseAndAddCatchTests TestTarget)
  message(DEPRECATION "ParseAndAddCatchTest: function deprecated because of possibility of missed test cases. Consider using 'catch_discover_tests' from 'Catch.cmake'")
  ParseAndAddCatchTests_PrintDebugMessage("Started parsing ${TestTarget}")
  get_target_property(SourceFiles ${TestTarget} SOURCES)
  ParseAndAddCatchTests_PrintDebugMessage("Found the following sources: ${SourceFiles}")
  foreach(SourceFile ${SourceFiles})
    ParseAndAddCatchTests_ParseFile(${SourceFile} ${TestTarget})
  endforeach()
  ParseAndAddCatchTests_PrintDebugMessage("Finished parsing ${TestTarget}")
endfunction()

catchorg/Catch2 extras/ParseAndAddCatchTests.cmake :138

    string(REGEX REPLACE "${TestType}\\([ \t]*" "" TestFixture "${TestTypeAndFixture}")

    # Get string parts of test definition
    string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")

    # Strip wrapping quotation marks
    string(REGEX REPLACE "^\"(.*)\"$" "\\1" TestStrings "${TestStrings}")
    string(REPLACE "\";\"" ";" TestStrings "${TestStrings}")

    # Validate that a test name and tags have been provided
    list(LENGTH TestStrings TestStringsLength)
    if(TestStringsLength GREATER 2 OR TestStringsLength LESS 1)
      message(FATAL_ERROR "You must provide a valid test name and tags for all tests in ${SourceFile}")
    endif()

    # Assign name and tags
    list(GET TestStrings 0 Name)
    if("${TestType}" STREQUAL "SCENARIO")
      set(Name "Scenario: ${Name}")
    endif()
    if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND "${TestType}" MATCHES "(CATCH_)?TEST_CASE_METHOD" AND TestFixture)
      set(CTestName "${TestFixture}:${Name}")
    else()
      set(CTestName "${Name}")
    endif()
    if(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME)
      set(CTestName "${TestTarget}:${CTestName}")
    endif()
    # add target to labels to enable running all tests added from this target
    set(Labels ${TestTarget})
    if(TestStringsLength EQUAL 2)
      list(GET TestStrings 1 Tags)
      string(TOLOWER "${Tags}" Tags)
      # remove target from labels if the test is hidden
      if("${Tags}" MATCHES ".*\\[!?(hide|\\.)\\].*")
        list(REMOVE_ITEM Labels ${TestTarget})
      endif()
      string(REPLACE "]" ";" Tags "${Tags}")
      string(REPLACE "[" "" Tags "${Tags}")
    else()
      # unset tags variable from previous loop
      unset(Tags)
    endif()

    list(APPEND Labels ${Tags})

    set(HiddenTagFound OFF)
    foreach(label ${Labels})
      string(REGEX MATCH "^!hide|^\\." result ${label})
      if(result)
        set(HiddenTagFound ON)
        break()
      endif()
    endforeach(label)
    if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
      ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
    else()
      ParseAndAddCatchTests_PrintDebugMessage("Adding test \"${CTestName}\"")
      if(Labels)
        ParseAndAddCatchTests_PrintDebugMessage("Setting labels to ${Labels}")
      endif()

      # Escape commas in the test spec
      string(REPLACE "," "\\," Name ${Name})

      # Work around CMake 3.18.0 change in `add_test()`, before the escaped quotes were necessary,
      # only with CMake 3.18.0 the escaped double quotes confuse the call. This change is reverted in 3.18.1
      # And properly introduced in 3.19 with the CMP0110 policy
      if(_cmp0110_value STREQUAL "NEW" OR ${CMAKE_VERSION} VERSION_EQUAL "3.18")
        ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to NEW, no need for add_test(\"\") workaround")
      else()
        ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to OLD adding \"\" for add_test() workaround")
        set(CTestName "\"${CTestName}\"")
      endif()

      # Handle template test cases
      if("${TestTypeAndFixture}" MATCHES ".*TEMPLATE_.*")
        set(Name "${Name} - *")
      endif()

      # Add the test and set its properties
      add_test(NAME "${CTestName}" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
      # Old CMake versions do not document VERSION_GREATER_EQUAL, so we use VERSION_GREATER with 3.8 instead
      if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_GREATER "3.8")
        ParseAndAddCatchTests_PrintDebugMessage("Setting DISABLED test property")
        set_tests_properties("${CTestName}" PROPERTIES DISABLED ON)
      else()
        set_tests_properties("${CTestName}" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
                                                LABELS "${Labels}")
      endif()
      set_property(
        TARGET ${TestTarget}
        APPEND
        PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
      set_property(
        SOURCE ${SourceFile}
        APPEND
        PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
    endif()
  endforeach()
endfunction()

# entry point
function(ParseAndAddCatchTests TestTarget)
  message(DEPRECATION "ParseAndAddCatchTest: function deprecated because of possibility of missed test cases. Consider using 'catch_discover_tests' from 'Catch.cmake'")
  ParseAndAddCatchTests_PrintDebugMessage("Started parsing ${TestTarget}")
  get_target_property(SourceFiles ${TestTarget} SOURCES)
  ParseAndAddCatchTests_PrintDebugMessage("Found the following sources: ${SourceFiles}")
  foreach(SourceFile ${SourceFiles})
    ParseAndAddCatchTests_ParseFile(${SourceFile} ${TestTarget})
  endforeach()
  ParseAndAddCatchTests_PrintDebugMessage("Finished parsing ${TestTarget}")
endfunction()

catchorg/Catch2 extras/ParseAndAddCatchTests.cmake :141

string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")

CGAL/cgal Installation/cmake/modules/display-third-party-libs-versions.cmake :72

string(REGEX MATCHALL "#include[ \t]+\"([^\"]+)\"" INCLUDED_HEADERS "${GMP_HEADER_CONTENT}")

CGAL/cgal Installation/cmake/modules/process_dependencies.cmake :15

string(REGEX MATCHALL "^\\.* ${CGAL_PACKAGES_PREFIX}/([A-Za-z0-9_.-]*)/include/(CGAL/[A-Za-z0-9_/.-]*\\.h)" header ${line})

projectchrono/chrono cmake/FindCudaArch.cmake :145

STRING(REGEX MATCHALL "[0-9()]+" __cuda_arch_bin "${__cuda_arch_bin}")

cpputest/cpputest cmake/Modules/_CppUTestDiscovery.cmake :66

string(REGEX MATCHALL "[^\n]+\n" discovered_test_lines "${discovered_tests}")

dftbplus/dftbplus cmake/DftbPlusUtils.cmake :178

string(REGEX MATCHALL "[0-9]+" _api_list "${_api}")

davisking/dlib dlib/CMakeLists.txt :681

string(REGEX MATCHALL "-D[^ ]*" FLAGS_FOR_NVCC "${CMAKE_CXX_FLAGS}")

spnda/fastgltf deps/CMakeLists.txt :25

string(REGEX MATCHALL "[0-9.]+" SIMDJSON_HEADER_VERSION "${SIMDJSON_HEADER_VERSION_LINE}")

fontforge/fontforge cmake/backports/3.15.7/FindPython/Support.cmake :719

string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${${_PYTHON_PREFIX}_VERSION}")

fontforge/fontforge cmake/backports/3.15.7/FindPython/Support.cmake :1135

string (REGEX MATCHALL "-lpython[^ ]+" _${_PYTHON_PREFIX}_LIB_NAMES "${_${_PYTHON_PREFIX}_FLAGS}")

fontforge/fontforge cmake/backports/3.15.7/FindPython/Support.cmake :1554

string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${_${_PYTHON_PREFIX}_VERSION}")

FreeCAD/FreeCAD cMake/FindNETGEN.cmake :108

string(REGEX MATCHALL "[0-9]+" NETGEN_VERSION_expr ${NETGEN_VERSION})

frontistr/frontistr CMakeLists.txt :103

string(REGEX MATCHALL "[0-9]" verlist "${vertxt}")

gnuradio/gnuradio cmake/Modules/FindCodec2.cmake :42

string(REGEX MATCHALL "FREEDV_MODE[_a-z0-9A-Z]+" FREEDV_MODES
             "${_FREEDV_API_H_CONTENTS}")

InsightSoftwareConsortium/ITK CMake/ExternalData.cmake :489

string(REGEX MATCHALL "${data_regex}|${other_regex}" pieces "${tmp}")

KhronosGroup/KTX cmake/modules/FindVulkan.cmake :648

string(REGEX MATCHALL "[0-9]+" VulkanHeaderVersion2 "${VulkanHeaderVersionLine2}")

KhronosGroup/KTX cmake/modules/FindVulkan.cmake :665

string(REGEX MATCHALL "[0-9]+" _Vulkan_MoltenVK_VERSION_MAJOR "${_Vulkan_MoltenVK_VERSION_MAJOR}")

lammps/lammps unittest/force-styles/CMakeLists.txt :19

string(REGEX MATCHALL "[^, \t\r\n]+" TAGS "${TAGS_LINE}")

strukturag/libheif cmake/modules/FindLIBDE265.cmake :27

string(REGEX MATCHALL "[0-9.]+" LIBDE265_VERSION ${TMP})

strukturag/libheif cmake/modules/FindX265.cmake :27

string(REGEX MATCHALL "[0-9.]+" X265_BUILD ${TMP})

analogdevicesinc/libiio cmake/LinuxPackaging.cmake :217

STRING(REGEX MATCHALL "libc6|glibc" TEMP_TEST ${match})

libLAS/libLAS cmake/modules/FindGDAL.cmake :225

STRING(REGEX MATCHALL "[-][L]([^ ;])+" GDAL_LINK_DIRECTORIES_WITH_PREFIX "${GDAL_CONFIG_LIBS}")

Framstag/libosmscout cmake/WinResource.cmake :45

string(REGEX MATCHALL "[.]" matches "${_version}")

sbmlteam/libsbml src/bindings/octave/FindOctave.cmake :59

string(REGEX MATCHALL "(^| )-l([./+-_\\a-zA-Z]*)" _mkoctfile_libs "${_mkoctfile_libs}")

webmproject/libwebp CMakeLists.txt :228

string(REGEX MATCHALL "[0-9a-z\\._]+" FILES ${FILES})

webmproject/libwebp cmake/deps.cmake :153

string(REGEX MATCHALL "\\[([0-9a-z\\.:/]*)\\]" CONFIGURE_AC_PACKAGE_INFO
             ${CONFIGURE_AC})

mfem/mfem config/cmake/modules/ResolveCompilerPaths.cmake :70

string (REGEX MATCHALL "((-L|-l|-Wl)([^\" ]+|\"[^\"]+\")|[^\" ]+\\.(a|so|dll|lib))" _all_tokens "${LINK_LINE}")

mfem/mfem config/cmake/modules/ResolveCompilerPaths.cmake :117

string (REGEX MATCHALL "-I([^\" ]+|\"[^\"]+\")" _all_tokens "${COMPILE_LINE}")

tpaviot/oce adm/cmake/cotire.cmake :2180

string (REGEX MATCHALL "COTIRE_[A-Za-z0-9_]+" _matchVars "${_vars}")

tpaviot/oce adm/cmake/cotire.cmake :2182

string (REGEX MATCHALL "COTIRE_[A-Za-z0-9_]+_INIT" _initVars "${_matchVars}")

tpaviot/oce adm/cmake/occt_macros.cmake :17

string (REGEX MATCHALL "(^|;)${GROUPNAME}[A-Za-z0-9_]*" GROUPNAME_VARS "${VARS}")

tpaviot/oce adm/cmake/occt_toolkit.cmake :313

string (REGEX MATCHALL "(^|;)3RDPARTY_[^;]+_LIBRARY[^;]*" ALL_CACHE_VARIABLES "${ALL_CACHE_VARIABLES}")

OpenImageDenoise/oidn cmake/FindOpenImageIO.cmake :75

string (REGEX MATCHALL "[0-9]+" OPENIMAGEIO_VERSION_MINOR ${TMP})

OpenImageDenoise/oidn cmake/FindOpenImageIO.cmake :80

string (REGEX MATCHALL "[0-9]+" OPENIMAGEIO_VERSION_TWEAK ${TMP})

OpenMathLib/OpenBLAS cmake/utils.cmake :8

string(REGEX MATCHALL "[0-9_a-zA-Z]+" SPLIT_VAR "${GETARCH_LINE}")

OpenMathLib/OpenBLAS cmake/utils.cmake :114

string(REGEX MATCHALL "\\$\\(([0-9_a-zA-Z]+)\\)" make_var_matches ${var_value})

AcademySoftwareFoundation/OpenColorIO share/cmake/modules/FindOSL.cmake :54

string (REGEX MATCHALL "[0-9]+" OSL_VERSION_MAJOR ${TMP})

AcademySoftwareFoundation/OpenColorIO src/OpenColorIO/CMakeLists.txt :265

string(REGEX MATCHALL "([A-Za-z0-9][A-Za-z0-9])" SEPARATED_HEX "${HEX_CONTENTS}")

opencv/opencv cmake/FindCUDA.cmake :1447

string(REGEX MATCHALL "/M[DT][d]?" flags ${flag_string})

opencv/opencv cmake/FindCUDA.cmake :1450

string(REGEX MATCHALL "-fPIC" flags ${flag_string})

opencv/opencv cmake/OpenCVDetectCUDAUtils.cmake :257

string(REGEX MATCHALL "[0-9]+\\.[0-9]" __cuda_arch_bin "${_nvcc_out}")

opencv/opencv cmake/OpenCVFindIPP.cmake :64

string(REGEX MATCHALL "[0-9]+" _MAJOR ${STR1})

opencv/opencv cmake/OpenCVFindIPP.cmake :65

string(REGEX MATCHALL "[0-9]+" _MINOR ${STR2})

opencv/opencv cmake/OpenCVFindIPP.cmake :66

string(REGEX MATCHALL "[0-9]+" _BUILD ${STR3})

opencv/opencv cmake/OpenCVFindIPP.cmake :67

string(REGEX MATCHALL "[0-9]+[.]+[0-9]+[^\"]+|[0-9]+[.]+[0-9]+" _VERSION_STR ${STR4})

opencv/opencv cmake/OpenCVFindMKL.cmake :37

string(REGEX MATCHALL "[0-9]+" MKL_VERSION_MAJOR ${STR1})

opencv/opencv_contrib modules/matlab/cmake/OpenCVFindMatlab.cmake :97

string(REGEX MATCHALL "[0-9]\\.[0-9]" VERSION_STRINGS_ ${QUERY_RESPONSE_})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/FindFFmpeg.cmake :74

string (REGEX MATCHALL "[0-9]+[.0-9]+" LIBAVCODEC_VERSION_MICRO "${TMP}")

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/FindJXL.cmake :24

string (REGEX MATCHALL "[0-9]+" JPEGXL_PATCH_VERSION ${TMP})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/Findlibuhdr.cmake :32

string (REGEX MATCHALL "[0-9]+" LIBUHDR_VERSION_MINOR ${TMP})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/FindOpenJPEG.cmake :143

string (REGEX MATCHALL "[0-9]+" OPJ_VERSION_BUILD ${TMP})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/FindOpenVDB.cmake :50

string (REGEX MATCHALL "[0-9]+" OPENVDB_VERSION_MAJOR ${TMP})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/FindOpenVDB.cmake :52

string (REGEX MATCHALL "[0-9]+" OPENVDB_VERSION_MINOR ${TMP})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/FindOpenVDB.cmake :54

string (REGEX MATCHALL "[0-9]+" OPENVDB_VERSION_PATCH ${TMP})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/FindPtex.cmake :106

string(REGEX MATCHALL "[0-9]+" API ${TMP})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/FindPtex.cmake :112

string(REGEX MATCHALL "[0-9]+" MINOR ${TMP})

AcademySoftwareFoundation/OpenImageIO src/cmake/modules/Findpugixml.cmake :44

string (REGEX MATCHALL "[0-9]+" PUGIXML_CODED_VERSION ${TMP})

openscad/openscad cmake/Modules/openscad_version.cmake :6

string(REGEX MATCHALL "^[0-9]+|[0-9]+|[0-9]+$" VERSIONLIST "${OPENSCAD_SHORTVERSION}")

AcademySoftwareFoundation/OpenShadingLanguage src/cmake/modules/Findpugixml.cmake :45

string (REGEX MATCHALL "[0-9]+" PUGIXML_CODED_VERSION ${TMP})

PixarAnimationStudios/OpenSubdiv cmake/FindOpenCL.cmake :184

string(REGEX MATCHALL "[0-9]+" VERSION ${LINE})

PixarAnimationStudios/OpenSubdiv cmake/FindPTex.cmake :127

string(REGEX MATCHALL "[0-9]+" MAJOR ${TMP})

openscenegraph/osgQt CMakeModules/OsgDetermineCompiler.cmake :46

STRING(REGEX MATCHALL "[0-9]+" CL_VERSION_LIST "${vc_compiler_version}")

ICLDisco/parsec cmake_modules/FindOTF2.cmake :34

string(REGEX MATCHALL "(^| +)-[^I][^ ]*" OTF2_CONFIG_CXXFLAGS "${OTF2_CONFIG_FLAGS}")

podofo/podofo test/common/cmake/ParseAndAddCatchTests.cmake :137

        string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^,^\"]*" TestTypeAndFixture "${TestName}")
        string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)" TestType "${TestTypeAndFixture}")
        string(REGEX REPLACE "${TestType}\\([ \t]*" "" TestFixture "${TestTypeAndFixture}")

        # Get string parts of test definition
        string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")

        # Strip wrapping quotation marks
        string(REGEX REPLACE "^\"(.*)\"$" "\\1" TestStrings "${TestStrings}")
        string(REPLACE "\";\"" ";" TestStrings "${TestStrings}")

        # Validate that a test name and tags have been provided
        list(LENGTH TestStrings TestStringsLength)
        if(TestStringsLength GREATER 2 OR TestStringsLength LESS 1)
            message(FATAL_ERROR "You must provide a valid test name and tags for all tests in ${SourceFile}")
        endif()

        # Assign name and tags
        list(GET TestStrings 0 Name)
        if("${TestType}" STREQUAL "SCENARIO")
            set(Name "Scenario: ${Name}")
        endif()
        if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND "${TestType}" MATCHES "(CATCH_)?TEST_CASE_METHOD" AND TestFixture )
            set(CTestName "${TestFixture}:${Name}")
        else()
            set(CTestName "${Name}")
        endif()
        if(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME)
            set(CTestName "${TestTarget}:${CTestName}")
        endif()
        # add target to labels to enable running all tests added from this target
        set(Labels ${TestTarget})
        if(TestStringsLength EQUAL 2)
            list(GET TestStrings 1 Tags)
            string(TOLOWER "${Tags}" Tags)
            # remove target from labels if the test is hidden
            if("${Tags}" MATCHES ".*\\[!?(hide|\\.)\\].*")
                list(REMOVE_ITEM Labels ${TestTarget})
            endif()
            string(REPLACE "]" ";" Tags "${Tags}")
            string(REPLACE "[" "" Tags "${Tags}")
        else()
          # unset tags variable from previous loop
          unset(Tags)
        endif()

        list(APPEND Labels ${Tags})

        set(HiddenTagFound OFF)
        foreach(label ${Labels})
            string(REGEX MATCH "^!hide|^\\." result ${label})
            if(result)
                set(HiddenTagFound ON)
                break()
            endif(result)
        endforeach(label)
        if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
            ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
        else()
            ParseAndAddCatchTests_PrintDebugMessage("Adding test \"${CTestName}\"")
            if(Labels)
                ParseAndAddCatchTests_PrintDebugMessage("Setting labels to ${Labels}")
            endif()

            # Escape commas in the test spec
            string(REPLACE "," "\\," Name ${Name})

            # Work around CMake 3.18.0 change in `add_test()`, before the escaped quotes were necessary,
            # only with CMake 3.18.0 the escaped double quotes confuse the call. This change is reverted in 3.18.1
            # And properly introduced in 3.19 with the CMP0110 policy
            if(_cmp0110_value STREQUAL "NEW" OR ${CMAKE_VERSION} VERSION_EQUAL "3.18")
                ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to NEW, no need for add_test(\"\") workaround")
            else()
                ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to OLD adding \"\" for add_test() workaround")
                set(CTestName "\"${CTestName}\"")
            endif()

            # Handle template test cases
            if("${TestTypeAndFixture}" MATCHES ".*TEMPLATE_.*")
              set(Name "${Name} - *")
            endif()

            # Add the test and set its properties
            add_test(NAME "${CTestName}" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
            # Old CMake versions do not document VERSION_GREATER_EQUAL, so we use VERSION_GREATER with 3.8 instead
            if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_GREATER "3.8")
                ParseAndAddCatchTests_PrintDebugMessage("Setting DISABLED test property")
                set_tests_properties("${CTestName}" PROPERTIES DISABLED ON)
            else()
                set_tests_properties("${CTestName}" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
                                                        LABELS "${Labels}")
            endif()
            set_property(
              TARGET ${TestTarget}
              APPEND
              PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
            set_property(
              SOURCE ${SourceFile}
              APPEND
              PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
        endif()


    endforeach()
endfunction()

# entry point
function(ParseAndAddCatchTests TestTarget)
    message(DEPRECATION "ParseAndAddCatchTest: function deprecated because of possibility of missed test cases. Consider using 'catch_discover_tests' from 'Catch.cmake'")
    ParseAndAddCatchTests_PrintDebugMessage("Started parsing ${TestTarget}")
    get_target_property(SourceFiles ${TestTarget} SOURCES)
    ParseAndAddCatchTests_PrintDebugMessage("Found the following sources: ${SourceFiles}")
    foreach(SourceFile ${SourceFiles})
        ParseAndAddCatchTests_ParseFile(${SourceFile} ${TestTarget})
    endforeach()
    ParseAndAddCatchTests_PrintDebugMessage("Finished parsing ${TestTarget}")
endfunction()

podofo/podofo test/common/cmake/ParseAndAddCatchTests.cmake :139

        string(REGEX REPLACE "${TestType}\\([ \t]*" "" TestFixture "${TestTypeAndFixture}")

        # Get string parts of test definition
        string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")

        # Strip wrapping quotation marks
        string(REGEX REPLACE "^\"(.*)\"$" "\\1" TestStrings "${TestStrings}")
        string(REPLACE "\";\"" ";" TestStrings "${TestStrings}")

        # Validate that a test name and tags have been provided
        list(LENGTH TestStrings TestStringsLength)
        if(TestStringsLength GREATER 2 OR TestStringsLength LESS 1)
            message(FATAL_ERROR "You must provide a valid test name and tags for all tests in ${SourceFile}")
        endif()

        # Assign name and tags
        list(GET TestStrings 0 Name)
        if("${TestType}" STREQUAL "SCENARIO")
            set(Name "Scenario: ${Name}")
        endif()
        if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND "${TestType}" MATCHES "(CATCH_)?TEST_CASE_METHOD" AND TestFixture )
            set(CTestName "${TestFixture}:${Name}")
        else()
            set(CTestName "${Name}")
        endif()
        if(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME)
            set(CTestName "${TestTarget}:${CTestName}")
        endif()
        # add target to labels to enable running all tests added from this target
        set(Labels ${TestTarget})
        if(TestStringsLength EQUAL 2)
            list(GET TestStrings 1 Tags)
            string(TOLOWER "${Tags}" Tags)
            # remove target from labels if the test is hidden
            if("${Tags}" MATCHES ".*\\[!?(hide|\\.)\\].*")
                list(REMOVE_ITEM Labels ${TestTarget})
            endif()
            string(REPLACE "]" ";" Tags "${Tags}")
            string(REPLACE "[" "" Tags "${Tags}")
        else()
          # unset tags variable from previous loop
          unset(Tags)
        endif()

        list(APPEND Labels ${Tags})

        set(HiddenTagFound OFF)
        foreach(label ${Labels})
            string(REGEX MATCH "^!hide|^\\." result ${label})
            if(result)
                set(HiddenTagFound ON)
                break()
            endif(result)
        endforeach(label)
        if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
            ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
        else()
            ParseAndAddCatchTests_PrintDebugMessage("Adding test \"${CTestName}\"")
            if(Labels)
                ParseAndAddCatchTests_PrintDebugMessage("Setting labels to ${Labels}")
            endif()

            # Escape commas in the test spec
            string(REPLACE "," "\\," Name ${Name})

            # Work around CMake 3.18.0 change in `add_test()`, before the escaped quotes were necessary,
            # only with CMake 3.18.0 the escaped double quotes confuse the call. This change is reverted in 3.18.1
            # And properly introduced in 3.19 with the CMP0110 policy
            if(_cmp0110_value STREQUAL "NEW" OR ${CMAKE_VERSION} VERSION_EQUAL "3.18")
                ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to NEW, no need for add_test(\"\") workaround")
            else()
                ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to OLD adding \"\" for add_test() workaround")
                set(CTestName "\"${CTestName}\"")
            endif()

            # Handle template test cases
            if("${TestTypeAndFixture}" MATCHES ".*TEMPLATE_.*")
              set(Name "${Name} - *")
            endif()

            # Add the test and set its properties
            add_test(NAME "${CTestName}" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
            # Old CMake versions do not document VERSION_GREATER_EQUAL, so we use VERSION_GREATER with 3.8 instead
            if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_GREATER "3.8")
                ParseAndAddCatchTests_PrintDebugMessage("Setting DISABLED test property")
                set_tests_properties("${CTestName}" PROPERTIES DISABLED ON)
            else()
                set_tests_properties("${CTestName}" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
                                                        LABELS "${Labels}")
            endif()
            set_property(
              TARGET ${TestTarget}
              APPEND
              PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
            set_property(
              SOURCE ${SourceFile}
              APPEND
              PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
        endif()


    endforeach()
endfunction()

# entry point
function(ParseAndAddCatchTests TestTarget)
    message(DEPRECATION "ParseAndAddCatchTest: function deprecated because of possibility of missed test cases. Consider using 'catch_discover_tests' from 'Catch.cmake'")
    ParseAndAddCatchTests_PrintDebugMessage("Started parsing ${TestTarget}")
    get_target_property(SourceFiles ${TestTarget} SOURCES)
    ParseAndAddCatchTests_PrintDebugMessage("Found the following sources: ${SourceFiles}")
    foreach(SourceFile ${SourceFiles})
        ParseAndAddCatchTests_ParseFile(${SourceFile} ${TestTarget})
    endforeach()
    ParseAndAddCatchTests_PrintDebugMessage("Finished parsing ${TestTarget}")
endfunction()

podofo/podofo test/common/cmake/ParseAndAddCatchTests.cmake :142

string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")

precice/precice cmake/modules/FindPETSc.cmake :66

string(REGEX MATCHALL "[0-9]+" _petsc_versions ${PETSc_VERSION})

qgis/QGIS cmake/FindGDAL.cmake :143

STRING(REGEX MATCHALL "[-][L]([^ ;])+" 
    GDAL_LINK_DIRECTORIES_WITH_PREFIX 
    "${GDAL_CONFIG_LIBS}" )

qgis/QGIS cmake/FindGDAL.cmake :157

STRING(REGEX MATCHALL "[-][l]([^ ;])+" 
    GDAL_LIB_NAME_WITH_PREFIX 
    "${GDAL_CONFIG_LIBS}" )

qgis/QGIS cmake/FindGEOS.cmake :116

STRING(REGEX MATCHALL "[-][L]([^ ;])+"
    GEOS_LINK_DIRECTORIES_WITH_PREFIX
    "${GEOS_CONFIG_LIBS}" )

qgis/QGIS src/providers/grass/CMakeLists.txt :720

    string( REGEX REPLACE ".*(G_[^\\(]*)\\(.*" "\\1" FUNCTION_NAME "${ROW}" )
    foreach( FN ${FUNCTIONS_ALL})
      if ( "${FN}" STREQUAL "${FUNCTION_NAME}" )
        # \\*? and \\** patterns do not work, why?
        string( REGEX REPLACE "^[ \t]*(.*)G_.*" "\\1" FUNCTION_TYPE "${ROW}" )
        string( REGEX REPLACE "\\*" "" FUNCTION_TYPE "${FUNCTION_TYPE}" )
        string( REGEX REPLACE "[^*]*(\\*+) *G_.*" "\\1" POINTER "${ROW}" )
        if ( (NOT "${POINTER}" STREQUAL "*") AND (NOT "${POINTER}" STREQUAL "**") )
          set ( POINTER "" )
        endif()
        string( REGEX REPLACE ".*G_[^\\(]*\\((.*)\\).*" "\\1" PARAM_TYPES "${ROW}" )
        set ( PARAM_NAMES "" )
        set ( PARAMS "" )
        if ( NOT "${PARAM_TYPES}" STREQUAL "void" )
          string ( REGEX MATCHALL "[^,]+" PARAM_TYPE_LIST ${PARAM_TYPES} )
          set ( I 0 )
          foreach( PARAM_TYPE ${PARAM_TYPE_LIST} )
            list ( APPEND PARAM_NAMES "p${I}" )
            list ( APPEND PARAMS "${PARAM_TYPE} p${I}" )
            math(EXPR  I "${I} + 1")
          endforeach ( PARAM_TYPE )
        endif()

        string( REPLACE ";" ", " PARAM_NAMES "${PARAM_NAMES}" )
        string( REPLACE ";" ", " PARAMS "${PARAMS}" )

        # Declare all
        list ( APPEND PROTOTYPES "${FUNCTION_TYPE} GRASS_LIB_EXPORT ${POINTER} ${FUNCTION_NAME} ( ${PARAM_TYPES} )\;\n" )

        # Define only those not implemented in qgsgrassgislib.cpp
        list (FIND FUNCTIONS "${FUNCTION_NAME}" FUNCTION_IDX)
        if( ${FUNCTION_IDX} GREATER -1 )
          list ( APPEND FUNCTIONS_MAP "// ${ROW}\n" )
          # Declare function type
          list ( APPEND FUNCTIONS_MAP "typedef ${FUNCTION_TYPE} ${POINTER} ${FUNCTION_NAME}_type(${PARAM_TYPES})\;\n\n" )
          list ( APPEND FUNCTIONS_MAP "${FUNCTION_TYPE} GRASS_LIB_EXPORT ${POINTER} ${FUNCTION_NAME} ( ${PARAMS} ) {\n" )
	  #list ( APPEND FUNCTIONS_MAP "  QgsDebugMsgLevel( \"Entered\", 4 )\;\n" )
          list ( APPEND FUNCTIONS_MAP "  ${FUNCTION_NAME}_type* fn = (${FUNCTION_NAME}_type*) cast_to_fptr (QgsGrassGisLib::instance()->resolve( \"${FUNCTION_NAME}\" ))\;\n" )
          list ( APPEND FUNCTIONS_MAP "  return fn( ${PARAM_NAMES} )\;\n")
          list ( APPEND FUNCTIONS_MAP "}\n\n" )
        endif()
      endif()
    endforeach ( FN )
  endforeach( ROW )

  list ( APPEND PROTOTYPES "}\n" )

  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/qgsgrassgislibfunctions.cpp" ${FUNCTIONS_MAP})
  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/qgsgrassgislibfunctions.h" ${PROTOTYPES})

  endif() # process functions

  # Build fake library
  if(MSVC)
    set (FAKE_LIB_GRASS_GIS "libgrass_gis.${GRASS_VERSION}")
  else()
    set (FAKE_LIB_GRASS_GIS "grass_gis.${GRASS_VERSION}")
  endif()
  add_library(${FAKE_LIB_GRASS_GIS} MODULE qgsgrassgislib.cpp qgsgrassgislibfunctions.cpp )

  # require c++17
  target_compile_features(${FAKE_LIB_GRASS_GIS} PRIVATE cxx_std_17)

  # GRASS_LIBRARY_gis is path to the GRASS library used for compilation, it is the same
  # on runtime on Linux and Mac but on Windows with OSGEO4W the GRASS may be installed
  # in different directory
  set_target_properties(${FAKE_LIB_GRASS_GIS} PROPERTIES
    CLEAN_DIRECT_OUTPUT 1
    COMPILE_FLAGS "-DGRASS_VERSION=\\\"${GRASS_VERSION}\\\" -DGRASS_LIBRARY_GIS=\\\"${GRASS_LIBRARY_gis}\\\" \"-I${CMAKE_CURRENT_SOURCE_DIR}\" ")

  if (NOT APPLE)
    set_target_properties(${FAKE_LIB_GRASS_GIS} PROPERTIES
      VERSION ${COMPLETE_VERSION}
      SOVERSION ${COMPLETE_VERSION}
      )
  endif()

  target_link_libraries(${FAKE_LIB_GRASS_GIS}
    qgis_core
  )


  install(TARGETS ${FAKE_LIB_GRASS_GIS}
    RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
    LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
endif()

qgis/QGIS src/providers/grass/CMakeLists.txt :730

        string( REGEX REPLACE ".*G_[^\\(]*\\((.*)\\).*" "\\1" PARAM_TYPES "${ROW}" )
        set ( PARAM_NAMES "" )
        set ( PARAMS "" )
        if ( NOT "${PARAM_TYPES}" STREQUAL "void" )
          string ( REGEX MATCHALL "[^,]+" PARAM_TYPE_LIST ${PARAM_TYPES} )
          set ( I 0 )
          foreach( PARAM_TYPE ${PARAM_TYPE_LIST} )
            list ( APPEND PARAM_NAMES "p${I}" )
            list ( APPEND PARAMS "${PARAM_TYPE} p${I}" )
            math(EXPR  I "${I} + 1")
          endforeach ( PARAM_TYPE )
        endif()

        string( REPLACE ";" ", " PARAM_NAMES "${PARAM_NAMES}" )
        string( REPLACE ";" ", " PARAMS "${PARAMS}" )

        # Declare all
        list ( APPEND PROTOTYPES "${FUNCTION_TYPE} GRASS_LIB_EXPORT ${POINTER} ${FUNCTION_NAME} ( ${PARAM_TYPES} )\;\n" )

        # Define only those not implemented in qgsgrassgislib.cpp
        list (FIND FUNCTIONS "${FUNCTION_NAME}" FUNCTION_IDX)
        if( ${FUNCTION_IDX} GREATER -1 )
          list ( APPEND FUNCTIONS_MAP "// ${ROW}\n" )
          # Declare function type
          list ( APPEND FUNCTIONS_MAP "typedef ${FUNCTION_TYPE} ${POINTER} ${FUNCTION_NAME}_type(${PARAM_TYPES})\;\n\n" )
          list ( APPEND FUNCTIONS_MAP "${FUNCTION_TYPE} GRASS_LIB_EXPORT ${POINTER} ${FUNCTION_NAME} ( ${PARAMS} ) {\n" )
	  #list ( APPEND FUNCTIONS_MAP "  QgsDebugMsgLevel( \"Entered\", 4 )\;\n" )
          list ( APPEND FUNCTIONS_MAP "  ${FUNCTION_NAME}_type* fn = (${FUNCTION_NAME}_type*) cast_to_fptr (QgsGrassGisLib::instance()->resolve( \"${FUNCTION_NAME}\" ))\;\n" )
          list ( APPEND FUNCTIONS_MAP "  return fn( ${PARAM_NAMES} )\;\n")
          list ( APPEND FUNCTIONS_MAP "}\n\n" )
        endif()
      endif()
    endforeach ( FN )
  endforeach( ROW )

  list ( APPEND PROTOTYPES "}\n" )

  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/qgsgrassgislibfunctions.cpp" ${FUNCTIONS_MAP})
  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/qgsgrassgislibfunctions.h" ${PROTOTYPES})

  endif() # process functions

  # Build fake library
  if(MSVC)
    set (FAKE_LIB_GRASS_GIS "libgrass_gis.${GRASS_VERSION}")
  else()
    set (FAKE_LIB_GRASS_GIS "grass_gis.${GRASS_VERSION}")
  endif()
  add_library(${FAKE_LIB_GRASS_GIS} MODULE qgsgrassgislib.cpp qgsgrassgislibfunctions.cpp )

  # require c++17
  target_compile_features(${FAKE_LIB_GRASS_GIS} PRIVATE cxx_std_17)

  # GRASS_LIBRARY_gis is path to the GRASS library used for compilation, it is the same
  # on runtime on Linux and Mac but on Windows with OSGEO4W the GRASS may be installed
  # in different directory
  set_target_properties(${FAKE_LIB_GRASS_GIS} PROPERTIES
    CLEAN_DIRECT_OUTPUT 1
    COMPILE_FLAGS "-DGRASS_VERSION=\\\"${GRASS_VERSION}\\\" -DGRASS_LIBRARY_GIS=\\\"${GRASS_LIBRARY_gis}\\\" \"-I${CMAKE_CURRENT_SOURCE_DIR}\" ")

  if (NOT APPLE)
    set_target_properties(${FAKE_LIB_GRASS_GIS} PROPERTIES
      VERSION ${COMPLETE_VERSION}
      SOVERSION ${COMPLETE_VERSION}
      )
  endif()

  target_link_libraries(${FAKE_LIB_GRASS_GIS}
    qgis_core
  )


  install(TARGETS ${FAKE_LIB_GRASS_GIS}
    RUNTIME DESTINATION ${QGIS_PLUGIN_DIR}
    LIBRARY DESTINATION ${QGIS_PLUGIN_DIR})
endif()

qtwebkit/qtwebkit Source/JavaScriptCore/PlatformGTK.cmake :69

string(REGEX MATCHALL "-L[^ ]*" INTROSPECTION_ADDITIONAL_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")

qtwebkit/qtwebkit Source/ThirdParty/libwebrtc/Source/third_party/yasm/modules/CMakeLists.txt :24

STRING(REGEX MATCHALL "[^\n]*\n" _lines "${_old_init_plugin_c}")

qtwebkit/qtwebkit Source/ThirdParty/libwebrtc/Source/third_party/yasm/modules/CMakeLists.txt :68

STRING(REGEX MATCHALL "[a-zA-Z][a-zA-Z0-9]+" _modulepath ${module})

qtwebkit/qtwebkit Source/WebKit/PlatformGTK.cmake :604

string(REGEX MATCHALL "-L[^ ]*"
    INTROSPECTION_ADDITIONAL_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")

eliaskosunen/scnlib cmake/icm_build_failure_parse_and_run.cmake :32

string(REGEX MATCHALL "//[ ]*build error:[^\n]+" matchErrors ${sourceText})

ossia/score cmake/ScoreFunctions.cmake :46

string(REGEX MATCHALL "SCORE_COMMAND_DECL_T\\([A-Za-z_0-9\,\:<>\+\r\n\t ]*\\)"
       templateCommands "${fileContent}")

sandialabs/seacas cmake/tribits/common_tpls/find_modules/FindHDF5.cmake :129

string(REGEX MATCHALL "-L([^\" ]+|\"[^\"]+\")" _lib_path_flags ${_ldflags})

sandialabs/seacas cmake/tribits/common_tpls/find_modules/FindHDF5.cmake :164

string( REGEX MATCHALL "[, ]-l([^\", ]+)|^-l([^\", ]+)" _library_name_flags ${_library_flags})

sandialabs/seacas cmake/tribits/common_tpls/find_modules/FindHDF5.cmake :232

string(REGEX MATCHALL "-I([^\" ]+|\"[^\"]+\")" _inc_path_flags ${_cflags})

pothosware/SoapySDR swig/python/cmake/FindPython/Support.cmake :267

string (REGEX MATCHALL "(-I|-iwithsysroot)[ ]*[^ ]+" _values "${_values}")

pothosware/SoapySDR swig/python/cmake/FindPython/Support.cmake :1159

string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${${_PYTHON_PREFIX}_VERSION}")

pothosware/SoapySDR swig/python/cmake/FindPython/Support.cmake :1407

string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${_${_PYTHON_PREFIX}_VERSION}")

DrTimothyAldenDavis/SuiteSparse LAGraph/deps/json_h/test/CMakeLists.txt :33

string(REGEX MATCHALL "```c[^`]*```" snippets "${readme_md}")

LLNL/sundials cmake/tpl/FindMAGMA.cmake :59

string(REGEX MATCHALL "[0-9]" _version_full "${_version_string}")

LLNL/sundials cmake/tpl/FindSUPERLUDIST.cmake :90

string(REGEX MATCHALL "[0-9][0-9]" SUPERLUDIST_INDEX_SIZE
             "${_index_size_string}")

LLNL/sundials cmake/tpl/FindSUPERLUDIST.cmake :130

string(REGEX MATCHALL "[0-9]" _version_patch "${_version_string}")

texus/TGUI cmake/Config.cmake :48

string(REGEX MATCHALL ".*(tdm[64]*-[1-9]).*" TGUI_COMPILER_GCC_TDM "${GCC_COMPILER_VERSION}")

trilinos/Trilinos cmake/tribits/common_tpls/find_modules/FindHDF5.cmake :129

string(REGEX MATCHALL "-L([^\" ]+|\"[^\"]+\")" _lib_path_flags ${_ldflags})

trilinos/Trilinos cmake/tribits/common_tpls/find_modules/FindHDF5.cmake :164

string( REGEX MATCHALL "[, ]-l([^\", ]+)|^-l([^\", ]+)" _library_name_flags ${_library_flags})

trilinos/Trilinos cmake/tribits/common_tpls/find_modules/FindHDF5.cmake :232

string(REGEX MATCHALL "-I([^\" ]+|\"[^\"]+\")" _inc_path_flags ${_cflags})

trilinos/Trilinos packages/compadre/CMakeLists.txt :550

#  string (REGEX MATCHALL "(^|;)${_prefix}[A-Za-z0-9_]*" _matchedVars "${_vars}")

microsoft/vcpkg ports/qt5-base/portfile.cmake :366

string(REGEX MATCHALL "QT_MAC_SDK_VERSION_MIN[ \t]*=[ \t]*(([0-9]+)(\\.([0-9]+))*)" KEY_VALUE "${QT_MK_MAC_CONTENT}")

cmake string(MATCHALL) examples