cmake/OpenCVUtils.cmake

   1 # Debugging function
   2 function(ocv_cmake_dump_vars)
   3   cmake_parse_arguments(DUMP "" "TOFILE" "" ${ARGN})
   4   set(regex "${DUMP_UNPARSED_ARGUMENTS}")
   5   get_cmake_property(_variableNames VARIABLES)
   6   set(VARS "")
   7   foreach(_variableName ${_variableNames})
   8     if(_variableName MATCHES "${regex}")
   9       set(VARS "${VARS}${_variableName}=${${_variableName}}\n")
  10     endif()
  11   endforeach()
  12   if(DUMP_TOFILE)
  13     file(WRITE ${CMAKE_BINARY_DIR}/${DUMP_TOFILE} "${VARS}")
  14   else()
  15     message(AUTHOR_WARNING "${VARS}")
  16   endif()
  17 endfunction()
  18
  19
  20 # Search packages for host system instead of packages for target system
  21 # in case of cross compilation thess macro should be defined by toolchain file
  22 if(NOT COMMAND find_host_package)
  23   macro(find_host_package)
  24     find_package(${ARGN})
  25   endmacro()
  26 endif()
  27 if(NOT COMMAND find_host_program)
  28   macro(find_host_program)
  29     find_program(${ARGN})
  30   endmacro()
  31 endif()
  32
  33 # assert macro
  34 # Note: it doesn't support lists in arguments
  35 # Usage samples:
  36 #   ocv_assert(MyLib_FOUND)
  37 #   ocv_assert(DEFINED MyLib_INCLUDE_DIRS)
  38 macro(ocv_assert)
  39   if(NOT (${ARGN}))
  40     string(REPLACE ";" " " __assert_msg "${ARGN}")
  41     message(AUTHOR_WARNING "Assertion failed: ${__assert_msg}")
  42   endif()
  43 endmacro()
  44
  45 macro(ocv_check_environment_variables)
  46   foreach(_var ${ARGN})
  47     if(NOT DEFINED ${_var} AND DEFINED ENV{${_var}})
  48       set(__value "$ENV{${_var}}")
  49       file(TO_CMAKE_PATH "${__value}" __value) # Assume that we receive paths
  50       set(${_var} "${__value}")
  51       message(STATUS "Update variable ${_var} from environment: ${${_var}}")
  52     endif()
  53   endforeach()
  54 endmacro()
  55
  56 # adds include directories in such way that directories from the OpenCV source tree go first
  57 function(ocv_include_directories)
  58   set(__add_before "")
  59   foreach(dir ${ARGN})
  60     get_filename_component(__abs_dir "${dir}" ABSOLUTE)
  61     if("${__abs_dir}" MATCHES "^${OpenCV_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${OpenCV_BINARY_DIR}")
  62       list(APPEND __add_before "${dir}")
  63     else()
  64       include_directories(AFTER SYSTEM "${dir}")
  65     endif()
  66   endforeach()
  67   include_directories(BEFORE ${__add_before})
  68 endfunction()
  69
  70 # clears all passed variables
  71 macro(ocv_clear_vars)
  72   foreach(_var ${ARGN})
  73     unset(${_var} CACHE)
  74   endforeach()
  75 endmacro()
  76
  77 set(OCV_COMPILER_FAIL_REGEX
  78     "command line option .* is valid for .* but not for C\\+\\+" # GNU
  79     "command line option .* is valid for .* but not for C" # GNU
  80     "unrecognized .*option"                     # GNU
  81     "unknown .*option"                          # Clang
  82     "ignoring unknown option"                   # MSVC
  83     "warning D9002"                             # MSVC, any lang
  84     "option .*not supported"                    # Intel
  85     "[Uu]nknown option"                         # HP
  86     "[Ww]arning: [Oo]ption"                     # SunPro
  87     "command option .* is not recognized"       # XL
  88     "not supported in this configuration; ignored"       # AIX
  89     "File with unknown suffix passed to linker" # PGI
  90     "WARNING: unknown flag:"                    # Open64
  91   )
  92
  93 MACRO(ocv_check_compiler_flag LANG FLAG RESULT)
  94   if(NOT DEFINED ${RESULT})
  95     if("_${LANG}_" MATCHES "_CXX_")
  96       set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.cxx")
  97       if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
  98         FILE(WRITE "${_fname}" "int main() { return 0; }\n")
  99       else()
 100         FILE(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n")
 101       endif()
 102     elseif("_${LANG}_" MATCHES "_C_")
 103       set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c")
 104       if("${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_C_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
 105         FILE(WRITE "${_fname}" "int main(void) { return 0; }\n")
 106       else()
 107         FILE(WRITE "${_fname}" "#pragma\nint main(void) { return 0; }\n")
 108       endif()
 109     elseif("_${LANG}_" MATCHES "_OBJCXX_")
 110       set(_fname "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.mm")
 111       if("${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror " OR "${CMAKE_CXX_FLAGS} ${FLAG} " MATCHES "-Werror=unknown-pragmas ")
 112         FILE(WRITE "${_fname}" "int main() { return 0; }\n")
 113       else()
 114         FILE(WRITE "${_fname}" "#pragma\nint main() { return 0; }\n")
 115       endif()
 116     else()
 117       unset(_fname)
 118     endif()
 119     if(_fname)
 120       MESSAGE(STATUS "Performing Test ${RESULT}")
 121       TRY_COMPILE(${RESULT}
 122         "${CMAKE_BINARY_DIR}"
 123         "${_fname}"
 124         COMPILE_DEFINITIONS "${FLAG}"
 125         OUTPUT_VARIABLE OUTPUT)
 126
 127       FOREACH(_regex ${OCV_COMPILER_FAIL_REGEX})
 128         IF("${OUTPUT}" MATCHES "${_regex}")
 129           SET(${RESULT} 0)
 130           break()
 131         ENDIF()
 132       ENDFOREACH()
 133
 134       IF(${RESULT})
 135         SET(${RESULT} 1 CACHE INTERNAL "Test ${RESULT}")
 136         MESSAGE(STATUS "Performing Test ${RESULT} - Success")
 137       ELSE(${RESULT})
 138         MESSAGE(STATUS "Performing Test ${RESULT} - Failed")
 139         SET(${RESULT} "" CACHE INTERNAL "Test ${RESULT}")
 140       ENDIF(${RESULT})
 141     else()
 142       SET(${RESULT} 0)
 143     endif()
 144   endif()
 145 ENDMACRO()
 146
 147 macro(ocv_check_flag_support lang flag varname)
 148   if("_${lang}_" MATCHES "_CXX_")
 149     set(_lang CXX)
 150   elseif("_${lang}_" MATCHES "_C_")
 151     set(_lang C)
 152   elseif("_${lang}_" MATCHES "_OBJCXX_")
 153     set(_lang OBJCXX)
 154   else()
 155     set(_lang ${lang})
 156   endif()
 157
 158   string(TOUPPER "${flag}" ${varname})
 159   string(REGEX REPLACE "^(/|-)" "HAVE_${_lang}_" ${varname} "${${varname}}")
 160   string(REGEX REPLACE " -|-|=| |\\." "_" ${varname} "${${varname}}")
 161
 162   ocv_check_compiler_flag("${_lang}" "${ARGN} ${flag}" ${${varname}})
 163 endmacro()
 164
 165 # turns off warnings
 166 macro(ocv_warnings_disable)
 167   if(NOT ENABLE_NOISY_WARNINGS)
 168     set(_flag_vars "")
 169     set(_msvc_warnings "")
 170     set(_gxx_warnings "")
 171     foreach(arg ${ARGN})
 172       if(arg MATCHES "^CMAKE_")
 173         list(APPEND _flag_vars ${arg})
 174       elseif(arg MATCHES "^/wd")
 175         list(APPEND _msvc_warnings ${arg})
 176       elseif(arg MATCHES "^-W")
 177         list(APPEND _gxx_warnings ${arg})
 178       endif()
 179     endforeach()
 180     if(MSVC AND _msvc_warnings AND _flag_vars)
 181       foreach(var ${_flag_vars})
 182         foreach(warning ${_msvc_warnings})
 183           set(${var} "${${var}} ${warning}")
 184         endforeach()
 185       endforeach()
 186     elseif((CMAKE_COMPILER_IS_GNUCXX OR (UNIX AND CV_ICC)) AND _gxx_warnings AND _flag_vars)
 187       foreach(var ${_flag_vars})
 188         foreach(warning ${_gxx_warnings})
 189           if(NOT warning MATCHES "^-Wno-")
 190             string(REPLACE "${warning}" "" ${var} "${${var}}")
 191             string(REPLACE "-W" "-Wno-" warning "${warning}")
 192           endif()
 193           ocv_check_flag_support(${var} "${warning}" _varname)
 194           if(${_varname})
 195             set(${var} "${${var}} ${warning}")
 196           endif()
 197         endforeach()
 198       endforeach()
 199     endif()
 200     unset(_flag_vars)
 201     unset(_msvc_warnings)
 202     unset(_gxx_warnings)
 203   endif(NOT ENABLE_NOISY_WARNINGS)
 204 endmacro()
 205
 206 # Provides an option that the user can optionally select.
 207 # Can accept condition to control when option is available for user.
 208 # Usage:
 209 #   option(<option_variable> "help string describing the option" <initial value or boolean expression> [IF <condition>])
 210 macro(OCV_OPTION variable description value)
 211   set(__value ${value})
 212   set(__condition "")
 213   set(__varname "__value")
 214   foreach(arg ${ARGN})
 215     if(arg STREQUAL "IF" OR arg STREQUAL "if")
 216       set(__varname "__condition")
 217     else()
 218       list(APPEND ${__varname} ${arg})
 219     endif()
 220   endforeach()
 221   unset(__varname)
 222   if("${__condition}" STREQUAL "")
 223     set(__condition 2 GREATER 1)
 224   endif()
 225
 226   if(${__condition})
 227     if("${__value}" MATCHES ";")
 228       if(${__value})
 229         option(${variable} "${description}" ON)
 230       else()
 231         option(${variable} "${description}" OFF)
 232       endif()
 233     elseif(DEFINED ${__value})
 234       if(${__value})
 235         option(${variable} "${description}" ON)
 236       else()
 237         option(${variable} "${description}" OFF)
 238       endif()
 239     else()
 240       option(${variable} "${description}" ${__value})
 241     endif()
 242   else()
 243     unset(${variable} CACHE)
 244   endif()
 245   unset(__condition)
 246   unset(__value)
 247 endmacro()
 248
 249
 250 # Macros that checks if module have been installed.
 251 # After it adds module to build and define
 252 # constants passed as second arg
 253 macro(CHECK_MODULE module_name define)
 254   set(${define} 0)
 255   if(PKG_CONFIG_FOUND)
 256     set(ALIAS               ALIASOF_${module_name})
 257     set(ALIAS_FOUND                 ${ALIAS}_FOUND)
 258     set(ALIAS_INCLUDE_DIRS   ${ALIAS}_INCLUDE_DIRS)
 259     set(ALIAS_LIBRARY_DIRS   ${ALIAS}_LIBRARY_DIRS)
 260     set(ALIAS_LIBRARIES         ${ALIAS}_LIBRARIES)
 261
 262     PKG_CHECK_MODULES(${ALIAS} ${module_name})
 263
 264     if(${ALIAS_FOUND})
 265       set(${define} 1)
 266       foreach(P "${ALIAS_INCLUDE_DIRS}")
 267         if(${P})
 268           list(APPEND VIDEOIO_INCLUDE_DIRS ${${P}})
 269           list(APPEND HIGHGUI_INCLUDE_DIRS ${${P}})
 270         endif()
 271       endforeach()
 272
 273       foreach(P "${ALIAS_LIBRARY_DIRS}")
 274         if(${P})
 275           list(APPEND VIDEOIO_LIBRARY_DIRS ${${P}})
 276           list(APPEND HIGHGUI_LIBRARY_DIRS ${${P}})
 277         endif()
 278       endforeach()
 279
 280       list(APPEND VIDEOIO_LIBRARIES ${${ALIAS_LIBRARIES}})
 281       list(APPEND HIGHGUI_LIBRARIES ${${ALIAS_LIBRARIES}})
 282     endif()
 283   endif()
 284 endmacro()
 285
 286
 287 set(OPENCV_BUILD_INFO_FILE "${OpenCV_BINARY_DIR}/version_string.tmp")
 288 file(REMOVE "${OPENCV_BUILD_INFO_FILE}")
 289 function(ocv_output_status msg)
 290   message(STATUS "${msg}")
 291   string(REPLACE "\\" "\\\\" msg "${msg}")
 292   string(REPLACE "\"" "\\\"" msg "${msg}")
 293   file(APPEND "${OPENCV_BUILD_INFO_FILE}" "\"${msg}\\n\"\n")
 294 endfunction()
 295
 296 macro(ocv_finalize_status)
 297   if(NOT OPENCV_SKIP_STATUS_FINALIZATION)
 298     if(TARGET opencv_core)
 299       execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_BUILD_INFO_FILE}" "${opencv_core_BINARY_DIR}/version_string.inc" OUTPUT_QUIET)
 300     endif()
 301   endif()
 302 endmacro()
 303
 304
 305 # Status report function.
 306 # Automatically align right column and selects text based on condition.
 307 # Usage:
 308 #   status(<text>)
 309 #   status(<heading> <value1> [<value2> ...])
 310 #   status(<heading> <condition> THEN <text for TRUE> ELSE <text for FALSE> )
 311 function(status text)
 312   set(status_cond)
 313   set(status_then)
 314   set(status_else)
 315
 316   set(status_current_name "cond")
 317   foreach(arg ${ARGN})
 318     if(arg STREQUAL "THEN")
 319       set(status_current_name "then")
 320     elseif(arg STREQUAL "ELSE")
 321       set(status_current_name "else")
 322     else()
 323       list(APPEND status_${status_current_name} ${arg})
 324     endif()
 325   endforeach()
 326
 327   if(DEFINED status_cond)
 328     set(status_placeholder_length 32)
 329     string(RANDOM LENGTH ${status_placeholder_length} ALPHABET " " status_placeholder)
 330     string(LENGTH "${text}" status_text_length)
 331     if(status_text_length LESS status_placeholder_length)
 332       string(SUBSTRING "${text}${status_placeholder}" 0 ${status_placeholder_length} status_text)
 333     elseif(DEFINED status_then OR DEFINED status_else)
 334       ocv_output_status("${text}")
 335       set(status_text "${status_placeholder}")
 336     else()
 337       set(status_text "${text}")
 338     endif()
 339
 340     if(DEFINED status_then OR DEFINED status_else)
 341       if(${status_cond})
 342         string(REPLACE ";" " " status_then "${status_then}")
 343         string(REGEX REPLACE "^[ \t]+" "" status_then "${status_then}")
 344         ocv_output_status("${status_text} ${status_then}")
 345       else()
 346         string(REPLACE ";" " " status_else "${status_else}")
 347         string(REGEX REPLACE "^[ \t]+" "" status_else "${status_else}")
 348         ocv_output_status("${status_text} ${status_else}")
 349       endif()
 350     else()
 351       string(REPLACE ";" " " status_cond "${status_cond}")
 352       string(REGEX REPLACE "^[ \t]+" "" status_cond "${status_cond}")
 353       ocv_output_status("${status_text} ${status_cond}")
 354     endif()
 355   else()
 356     ocv_output_status("${text}")
 357   endif()
 358 endfunction()
 359
 360
 361 # splits cmake libraries list of format "general;item1;debug;item2;release;item3" to two lists
 362 macro(ocv_split_libs_list lst lstdbg lstopt)
 363   set(${lstdbg} "")
 364   set(${lstopt} "")
 365   set(perv_keyword "")
 366   foreach(word ${${lst}})
 367     if(word STREQUAL "debug" OR word STREQUAL "optimized")
 368       set(perv_keyword ${word})
 369     elseif(word STREQUAL "general")
 370       set(perv_keyword "")
 371     elseif(perv_keyword STREQUAL "debug")
 372       list(APPEND ${lstdbg} "${word}")
 373       set(perv_keyword "")
 374     elseif(perv_keyword STREQUAL "optimized")
 375       list(APPEND ${lstopt} "${word}")
 376       set(perv_keyword "")
 377     else()
 378       list(APPEND ${lstdbg} "${word}")
 379       list(APPEND ${lstopt} "${word}")
 380       set(perv_keyword "")
 381     endif()
 382   endforeach()
 383 endmacro()
 384
 385
 386 # remove all matching elements from the list
 387 macro(ocv_list_filterout lst regex)
 388   foreach(item ${${lst}})
 389     if(item MATCHES "${regex}")
 390       list(REMOVE_ITEM ${lst} "${item}")
 391     endif()
 392   endforeach()
 393 endmacro()
 394
 395
 396 # stable & safe duplicates removal macro
 397 macro(ocv_list_unique __lst)
 398   if(${__lst})
 399     list(REMOVE_DUPLICATES ${__lst})
 400   endif()
 401 endmacro()
 402
 403
 404 # safe list reversal macro
 405 macro(ocv_list_reverse __lst)
 406   if(${__lst})
 407     list(REVERSE ${__lst})
 408   endif()
 409 endmacro()
 410
 411
 412 # safe list sorting macro
 413 macro(ocv_list_sort __lst)
 414   if(${__lst})
 415     list(SORT ${__lst})
 416   endif()
 417 endmacro()
 418
 419
 420 # add prefix to each item in the list
 421 macro(ocv_list_add_prefix LST PREFIX)
 422   set(__tmp "")
 423   foreach(item ${${LST}})
 424     list(APPEND __tmp "${PREFIX}${item}")
 425   endforeach()
 426   set(${LST} ${__tmp})
 427   unset(__tmp)
 428 endmacro()
 429
 430
 431 # add suffix to each item in the list
 432 macro(ocv_list_add_suffix LST SUFFIX)
 433   set(__tmp "")
 434   foreach(item ${${LST}})
 435     list(APPEND __tmp "${item}${SUFFIX}")
 436   endforeach()
 437   set(${LST} ${__tmp})
 438   unset(__tmp)
 439 endmacro()
 440
 441
 442 # gets and removes the first element from list
 443 macro(ocv_list_pop_front LST VAR)
 444   if(${LST})
 445     list(GET ${LST} 0 ${VAR})
 446     list(REMOVE_AT ${LST} 0)
 447   else()
 448     set(${VAR} "")
 449   endif()
 450 endmacro()
 451
 452
 453 # simple regex escaping routine (does not cover all cases!!!)
 454 macro(ocv_regex_escape var regex)
 455   string(REGEX REPLACE "([+.*^$])" "\\\\1" ${var} "${regex}")
 456 endmacro()
 457
 458
 459 # convert list of paths to full paths
 460 macro(ocv_convert_to_full_paths VAR)
 461   if(${VAR})
 462     set(__tmp "")
 463     foreach(path ${${VAR}})
 464       get_filename_component(${VAR} "${path}" ABSOLUTE)
 465       list(APPEND __tmp "${${VAR}}")
 466     endforeach()
 467     set(${VAR} ${__tmp})
 468     unset(__tmp)
 469   endif()
 470 endmacro()
 471
 472
 473 # convert list of paths to libraries names without lib prefix
 474 macro(ocv_convert_to_lib_name var)
 475   set(__tmp "")
 476   foreach(path ${ARGN})
 477     get_filename_component(__tmp_name "${path}" NAME_WE)
 478     string(REGEX REPLACE "^lib" "" __tmp_name ${__tmp_name})
 479     list(APPEND __tmp "${__tmp_name}")
 480   endforeach()
 481   set(${var} ${__tmp})
 482   unset(__tmp)
 483   unset(__tmp_name)
 484 endmacro()
 485
 486
 487 # add install command
 488 function(ocv_install_target)
 489   install(TARGETS ${ARGN})
 490
 491   set(isPackage 0)
 492   unset(__package)
 493   unset(__target)
 494   foreach(e ${ARGN})
 495     if(NOT DEFINED __target)
 496       set(__target "${e}")
 497     endif()
 498     if(isPackage EQUAL 1)
 499       set(__package "${e}")
 500       break()
 501     endif()
 502     if(e STREQUAL "EXPORT")
 503       set(isPackage 1)
 504     endif()
 505   endforeach()
 506
 507   if(DEFINED __package)
 508     list(APPEND ${__package}_TARGETS ${__target})
 509     set(${__package}_TARGETS "${${__package}_TARGETS}" CACHE INTERNAL "List of ${__package} targets")
 510   endif()
 511
 512   if(INSTALL_CREATE_DISTRIB)
 513     if(MSVC AND NOT BUILD_SHARED_LIBS)
 514       set(__target "${ARGV0}")
 515
 516       set(isArchive 0)
 517       set(isDst 0)
 518       unset(__dst)
 519       foreach(e ${ARGN})
 520         if(isDst EQUAL 1)
 521           set(__dst "${e}")
 522           break()
 523         endif()
 524         if(isArchive EQUAL 1 AND e STREQUAL "DESTINATION")
 525           set(isDst 1)
 526         endif()
 527         if(e STREQUAL "ARCHIVE")
 528           set(isArchive 1)
 529         else()
 530           set(isArchive 0)
 531         endif()
 532       endforeach()
 533
 534 #      message(STATUS "Process ${__target} dst=${__dst}...")
 535       if(DEFINED __dst)
 536         get_target_property(fname ${__target} LOCATION_DEBUG)
 537         if(fname MATCHES "\\.lib$")
 538           string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
 539           install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Debug)
 540         endif()
 541
 542         get_target_property(fname ${__target} LOCATION_RELEASE)
 543         if(fname MATCHES "\\.lib$")
 544           string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
 545           install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Release)
 546         endif()
 547       endif()
 548     endif()
 549   endif()
 550 endfunction()
 551
 552
 553 # read set of version defines from the header file
 554 macro(ocv_parse_header FILENAME FILE_VAR)
 555   set(vars_regex "")
 556   set(__parnet_scope OFF)
 557   set(__add_cache OFF)
 558   foreach(name ${ARGN})
 559     if("${name}" STREQUAL "PARENT_SCOPE")
 560       set(__parnet_scope ON)
 561     elseif("${name}" STREQUAL "CACHE")
 562       set(__add_cache ON)
 563     elseif(vars_regex)
 564       set(vars_regex "${vars_regex}|${name}")
 565     else()
 566       set(vars_regex "${name}")
 567     endif()
 568   endforeach()
 569   if(EXISTS "${FILENAME}")
 570     file(STRINGS "${FILENAME}" ${FILE_VAR} REGEX "#define[ \t]+(${vars_regex})[ \t]+[0-9]+" )
 571   else()
 572     unset(${FILE_VAR})
 573   endif()
 574   foreach(name ${ARGN})
 575     if(NOT "${name}" STREQUAL "PARENT_SCOPE" AND NOT "${name}" STREQUAL "CACHE")
 576       if(${FILE_VAR})
 577         if(${FILE_VAR} MATCHES ".+[ \t]${name}[ \t]+([0-9]+).*")
 578           string(REGEX REPLACE ".+[ \t]${name}[ \t]+([0-9]+).*" "\\1" ${name} "${${FILE_VAR}}")
 579         else()
 580           set(${name} "")
 581         endif()
 582         if(__add_cache)
 583           set(${name} ${${name}} CACHE INTERNAL "${name} parsed from ${FILENAME}" FORCE)
 584         elseif(__parnet_scope)
 585           set(${name} "${${name}}" PARENT_SCOPE)
 586         endif()
 587       else()
 588         unset(${name} CACHE)
 589       endif()
 590     endif()
 591   endforeach()
 592 endmacro()
 593
 594 # read single version define from the header file
 595 macro(ocv_parse_header2 LIBNAME HDR_PATH VARNAME)
 596   ocv_clear_vars(${LIBNAME}_VERSION_MAJOR
 597                  ${LIBNAME}_VERSION_MAJOR
 598                  ${LIBNAME}_VERSION_MINOR
 599                  ${LIBNAME}_VERSION_PATCH
 600                  ${LIBNAME}_VERSION_TWEAK
 601                  ${LIBNAME}_VERSION_STRING)
 602   set(${LIBNAME}_H "")
 603   if(EXISTS "${HDR_PATH}")
 604     file(STRINGS "${HDR_PATH}" ${LIBNAME}_H REGEX "^#define[ \t]+${VARNAME}[ \t]+\"[^\"]*\".*$" LIMIT_COUNT 1)
 605   endif()
 606
 607   if(${LIBNAME}_H)
 608     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MAJOR "${${LIBNAME}_H}")
 609     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MINOR  "${${LIBNAME}_H}")
 610     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_PATCH "${${LIBNAME}_H}")
 611     set(${LIBNAME}_VERSION_MAJOR ${${LIBNAME}_VERSION_MAJOR} ${ARGN})
 612     set(${LIBNAME}_VERSION_MINOR ${${LIBNAME}_VERSION_MINOR} ${ARGN})
 613     set(${LIBNAME}_VERSION_PATCH ${${LIBNAME}_VERSION_PATCH} ${ARGN})
 614     set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_MAJOR}.${${LIBNAME}_VERSION_MINOR}.${${LIBNAME}_VERSION_PATCH}")
 615
 616     # append a TWEAK version if it exists:
 617     set(${LIBNAME}_VERSION_TWEAK "")
 618     if("${${LIBNAME}_H}" MATCHES "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.[0-9]+\\.([0-9]+).*$")
 619       set(${LIBNAME}_VERSION_TWEAK "${CMAKE_MATCH_1}" ${ARGN})
 620     endif()
 621     if(${LIBNAME}_VERSION_TWEAK)
 622       set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}.${${LIBNAME}_VERSION_TWEAK}" ${ARGN})
 623     else()
 624       set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}" ${ARGN})
 625     endif()
 626   endif()
 627 endmacro()
 628
 629 # read single version info from the pkg file
 630 macro(ocv_parse_pkg LIBNAME PKG_PATH SCOPE)
 631   if(EXISTS "${PKG_PATH}/${LIBNAME}.pc")
 632     file(STRINGS "${PKG_PATH}/${LIBNAME}.pc" line_to_parse REGEX "^Version:[ \t]+[0-9.]*.*$" LIMIT_COUNT 1)
 633     STRING(REGEX REPLACE ".*Version: ([^ ]+).*" "\\1" ALIASOF_${LIBNAME}_VERSION "${line_to_parse}" )
 634   endif()
 635 endmacro()
 636
 637 ################################################################################################
 638 # short command to setup source group
 639 function(ocv_source_group group)
 640   cmake_parse_arguments(SG "" "DIRBASE" "GLOB;GLOB_RECURSE;FILES" ${ARGN})
 641   set(files "")
 642   if(SG_FILES)
 643     list(APPEND files ${SG_FILES})
 644   endif()
 645   if(SG_GLOB)
 646     file(GLOB srcs ${SG_GLOB})
 647     list(APPEND files ${srcs})
 648   endif()
 649   if(SG_GLOB_RECURSE)
 650     file(GLOB_RECURSE srcs ${SG_GLOB_RECURSE})
 651     list(APPEND files ${srcs})
 652   endif()
 653   if(SG_DIRBASE)
 654     foreach(f ${files})
 655       file(RELATIVE_PATH fpart "${SG_DIRBASE}" "${f}")
 656       if(fpart MATCHES "^\\.\\.")
 657         message(AUTHOR_WARNING "Can't detect subpath for source_group command: Group=${group} FILE=${f} DIRBASE=${SG_DIRBASE}")
 658         set(fpart "")
 659       else()
 660         get_filename_component(fpart "${fpart}" PATH)
 661         if(fpart)
 662           set(fpart "/${fpart}") # add '/'
 663           string(REPLACE "/" "\\" fpart "${fpart}")
 664         endif()
 665       endif()
 666       source_group("${group}${fpart}" FILES ${f})
 667     endforeach()
 668   else()
 669     source_group(${group} FILES ${files})
 670   endif()
 671 endfunction()