cmake/OpenCVUtils.cmake

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