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