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 HIGHGUI_INCLUDE_DIRS ${${P}})
 269         endif()
 270       endforeach()
 271
 272       foreach(P "${ALIAS_LIBRARY_DIRS}")
 273         if(${P})
 274           list(APPEND HIGHGUI_LIBRARY_DIRS ${${P}})
 275         endif()
 276       endforeach()
 277
 278       list(APPEND HIGHGUI_LIBRARIES ${${ALIAS_LIBRARIES}})
 279     endif()
 280   endif()
 281 endmacro()
 282
 283
 284 set(OPENCV_BUILD_INFO_FILE "${OpenCV_BINARY_DIR}/version_string.tmp")
 285 file(REMOVE "${OPENCV_BUILD_INFO_FILE}")
 286 function(ocv_output_status msg)
 287   message(STATUS "${msg}")
 288   string(REPLACE "\\" "\\\\" msg "${msg}")
 289   string(REPLACE "\"" "\\\"" msg "${msg}")
 290   file(APPEND "${OPENCV_BUILD_INFO_FILE}" "\"${msg}\\n\"\n")
 291 endfunction()
 292
 293 macro(ocv_finalize_status)
 294   if(NOT OPENCV_SKIP_STATUS_FINALIZATION)
 295     if(TARGET opencv_core)
 296       execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_BUILD_INFO_FILE}" "${opencv_core_BINARY_DIR}/version_string.inc" OUTPUT_QUIET)
 297     endif()
 298   endif()
 299 endmacro()
 300
 301
 302 # Status report function.
 303 # Automatically align right column and selects text based on condition.
 304 # Usage:
 305 #   status(<text>)
 306 #   status(<heading> <value1> [<value2> ...])
 307 #   status(<heading> <condition> THEN <text for TRUE> ELSE <text for FALSE> )
 308 function(status text)
 309   set(status_cond)
 310   set(status_then)
 311   set(status_else)
 312
 313   set(status_current_name "cond")
 314   foreach(arg ${ARGN})
 315     if(arg STREQUAL "THEN")
 316       set(status_current_name "then")
 317     elseif(arg STREQUAL "ELSE")
 318       set(status_current_name "else")
 319     else()
 320       list(APPEND status_${status_current_name} ${arg})
 321     endif()
 322   endforeach()
 323
 324   if(DEFINED status_cond)
 325     set(status_placeholder_length 32)
 326     string(RANDOM LENGTH ${status_placeholder_length} ALPHABET " " status_placeholder)
 327     string(LENGTH "${text}" status_text_length)
 328     if(status_text_length LESS status_placeholder_length)
 329       string(SUBSTRING "${text}${status_placeholder}" 0 ${status_placeholder_length} status_text)
 330     elseif(DEFINED status_then OR DEFINED status_else)
 331       ocv_output_status("${text}")
 332       set(status_text "${status_placeholder}")
 333     else()
 334       set(status_text "${text}")
 335     endif()
 336
 337     if(DEFINED status_then OR DEFINED status_else)
 338       if(${status_cond})
 339         string(REPLACE ";" " " status_then "${status_then}")
 340         string(REGEX REPLACE "^[ \t]+" "" status_then "${status_then}")
 341         ocv_output_status("${status_text} ${status_then}")
 342       else()
 343         string(REPLACE ";" " " status_else "${status_else}")
 344         string(REGEX REPLACE "^[ \t]+" "" status_else "${status_else}")
 345         ocv_output_status("${status_text} ${status_else}")
 346       endif()
 347     else()
 348       string(REPLACE ";" " " status_cond "${status_cond}")
 349       string(REGEX REPLACE "^[ \t]+" "" status_cond "${status_cond}")
 350       ocv_output_status("${status_text} ${status_cond}")
 351     endif()
 352   else()
 353     ocv_output_status("${text}")
 354   endif()
 355 endfunction()
 356
 357
 358 # splits cmake libraries list of format "general;item1;debug;item2;release;item3" to two lists
 359 macro(ocv_split_libs_list lst lstdbg lstopt)
 360   set(${lstdbg} "")
 361   set(${lstopt} "")
 362   set(perv_keyword "")
 363   foreach(word ${${lst}})
 364     if(word STREQUAL "debug" OR word STREQUAL "optimized")
 365       set(perv_keyword ${word})
 366     elseif(word STREQUAL "general")
 367       set(perv_keyword "")
 368     elseif(perv_keyword STREQUAL "debug")
 369       list(APPEND ${lstdbg} "${word}")
 370       set(perv_keyword "")
 371     elseif(perv_keyword STREQUAL "optimized")
 372       list(APPEND ${lstopt} "${word}")
 373       set(perv_keyword "")
 374     else()
 375       list(APPEND ${lstdbg} "${word}")
 376       list(APPEND ${lstopt} "${word}")
 377       set(perv_keyword "")
 378     endif()
 379   endforeach()
 380 endmacro()
 381
 382
 383 # remove all matching elements from the list
 384 macro(ocv_list_filterout lst regex)
 385   foreach(item ${${lst}})
 386     if(item MATCHES "${regex}")
 387       list(REMOVE_ITEM ${lst} "${item}")
 388     endif()
 389   endforeach()
 390 endmacro()
 391
 392
 393 # stable & safe duplicates removal macro
 394 macro(ocv_list_unique __lst)
 395   if(${__lst})
 396     list(REMOVE_DUPLICATES ${__lst})
 397   endif()
 398 endmacro()
 399
 400
 401 # safe list reversal macro
 402 macro(ocv_list_reverse __lst)
 403   if(${__lst})
 404     list(REVERSE ${__lst})
 405   endif()
 406 endmacro()
 407
 408
 409 # safe list sorting macro
 410 macro(ocv_list_sort __lst)
 411   if(${__lst})
 412     list(SORT ${__lst})
 413   endif()
 414 endmacro()
 415
 416
 417 # add prefix to each item in the list
 418 macro(ocv_list_add_prefix LST PREFIX)
 419   set(__tmp "")
 420   foreach(item ${${LST}})
 421     list(APPEND __tmp "${PREFIX}${item}")
 422   endforeach()
 423   set(${LST} ${__tmp})
 424   unset(__tmp)
 425 endmacro()
 426
 427
 428 # add suffix to each item in the list
 429 macro(ocv_list_add_suffix LST SUFFIX)
 430   set(__tmp "")
 431   foreach(item ${${LST}})
 432     list(APPEND __tmp "${item}${SUFFIX}")
 433   endforeach()
 434   set(${LST} ${__tmp})
 435   unset(__tmp)
 436 endmacro()
 437
 438
 439 # gets and removes the first element from list
 440 macro(ocv_list_pop_front LST VAR)
 441   if(${LST})
 442     list(GET ${LST} 0 ${VAR})
 443     list(REMOVE_AT ${LST} 0)
 444   else()
 445     set(${VAR} "")
 446   endif()
 447 endmacro()
 448
 449
 450 # simple regex escaping routine (does not cover all cases!!!)
 451 macro(ocv_regex_escape var regex)
 452   string(REGEX REPLACE "([+.*^$])" "\\\\1" ${var} "${regex}")
 453 endmacro()
 454
 455
 456 # convert list of paths to full paths
 457 macro(ocv_convert_to_full_paths VAR)
 458   if(${VAR})
 459     set(__tmp "")
 460     foreach(path ${${VAR}})
 461       get_filename_component(${VAR} "${path}" ABSOLUTE)
 462       list(APPEND __tmp "${${VAR}}")
 463     endforeach()
 464     set(${VAR} ${__tmp})
 465     unset(__tmp)
 466   endif()
 467 endmacro()
 468
 469
 470 # add install command
 471 function(ocv_install_target)
 472   install(TARGETS ${ARGN})
 473
 474   set(isPackage 0)
 475   unset(__package)
 476   unset(__target)
 477   foreach(e ${ARGN})
 478     if(NOT DEFINED __target)
 479       set(__target "${e}")
 480     endif()
 481     if(isPackage EQUAL 1)
 482       set(__package "${e}")
 483       break()
 484     endif()
 485     if(e STREQUAL "EXPORT")
 486       set(isPackage 1)
 487     endif()
 488   endforeach()
 489
 490   if(DEFINED __package)
 491     list(APPEND ${__package}_TARGETS ${__target})
 492     set(${__package}_TARGETS "${${__package}_TARGETS}" CACHE INTERNAL "List of ${__package} targets")
 493   endif()
 494
 495   if(INSTALL_CREATE_DISTRIB)
 496     if(MSVC AND NOT BUILD_SHARED_LIBS)
 497       set(__target "${ARGV0}")
 498
 499       set(isArchive 0)
 500       set(isDst 0)
 501       unset(__dst)
 502       foreach(e ${ARGN})
 503         if(isDst EQUAL 1)
 504           set(__dst "${e}")
 505           break()
 506         endif()
 507         if(isArchive EQUAL 1 AND e STREQUAL "DESTINATION")
 508           set(isDst 1)
 509         endif()
 510         if(e STREQUAL "ARCHIVE")
 511           set(isArchive 1)
 512         else()
 513           set(isArchive 0)
 514         endif()
 515       endforeach()
 516
 517 #      message(STATUS "Process ${__target} dst=${__dst}...")
 518       if(DEFINED __dst)
 519         get_target_property(fname ${__target} LOCATION_DEBUG)
 520         if(fname MATCHES "\\.lib$")
 521           string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
 522           install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Debug)
 523         endif()
 524
 525         get_target_property(fname ${__target} LOCATION_RELEASE)
 526         if(fname MATCHES "\\.lib$")
 527           string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
 528           install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Release)
 529         endif()
 530       endif()
 531     endif()
 532   endif()
 533 endfunction()
 534
 535
 536 # read set of version defines from the header file
 537 macro(ocv_parse_header FILENAME FILE_VAR)
 538   set(vars_regex "")
 539   set(__parnet_scope OFF)
 540   set(__add_cache OFF)
 541   foreach(name ${ARGN})
 542     if("${name}" STREQUAL "PARENT_SCOPE")
 543       set(__parnet_scope ON)
 544     elseif("${name}" STREQUAL "CACHE")
 545       set(__add_cache ON)
 546     elseif(vars_regex)
 547       set(vars_regex "${vars_regex}|${name}")
 548     else()
 549       set(vars_regex "${name}")
 550     endif()
 551   endforeach()
 552   if(EXISTS "${FILENAME}")
 553     file(STRINGS "${FILENAME}" ${FILE_VAR} REGEX "#define[ \t]+(${vars_regex})[ \t]+[0-9]+" )
 554   else()
 555     unset(${FILE_VAR})
 556   endif()
 557   foreach(name ${ARGN})
 558     if(NOT "${name}" STREQUAL "PARENT_SCOPE" AND NOT "${name}" STREQUAL "CACHE")
 559       if(${FILE_VAR})
 560         if(${FILE_VAR} MATCHES ".+[ \t]${name}[ \t]+([0-9]+).*")
 561           string(REGEX REPLACE ".+[ \t]${name}[ \t]+([0-9]+).*" "\\1" ${name} "${${FILE_VAR}}")
 562         else()
 563           set(${name} "")
 564         endif()
 565         if(__add_cache)
 566           set(${name} ${${name}} CACHE INTERNAL "${name} parsed from ${FILENAME}" FORCE)
 567         elseif(__parnet_scope)
 568           set(${name} "${${name}}" PARENT_SCOPE)
 569         endif()
 570       else()
 571         unset(${name} CACHE)
 572       endif()
 573     endif()
 574   endforeach()
 575 endmacro()
 576
 577 # read single version define from the header file
 578 macro(ocv_parse_header2 LIBNAME HDR_PATH VARNAME)
 579   ocv_clear_vars(${LIBNAME}_VERSION_MAJOR
 580                  ${LIBNAME}_VERSION_MAJOR
 581                  ${LIBNAME}_VERSION_MINOR
 582                  ${LIBNAME}_VERSION_PATCH
 583                  ${LIBNAME}_VERSION_TWEAK
 584                  ${LIBNAME}_VERSION_STRING)
 585   set(${LIBNAME}_H "")
 586   if(EXISTS "${HDR_PATH}")
 587     file(STRINGS "${HDR_PATH}" ${LIBNAME}_H REGEX "^#define[ \t]+${VARNAME}[ \t]+\"[^\"]*\".*$" LIMIT_COUNT 1)
 588   endif()
 589
 590   if(${LIBNAME}_H)
 591     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MAJOR "${${LIBNAME}_H}")
 592     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MINOR  "${${LIBNAME}_H}")
 593     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_PATCH "${${LIBNAME}_H}")
 594     set(${LIBNAME}_VERSION_MAJOR ${${LIBNAME}_VERSION_MAJOR} ${ARGN})
 595     set(${LIBNAME}_VERSION_MINOR ${${LIBNAME}_VERSION_MINOR} ${ARGN})
 596     set(${LIBNAME}_VERSION_PATCH ${${LIBNAME}_VERSION_PATCH} ${ARGN})
 597     set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_MAJOR}.${${LIBNAME}_VERSION_MINOR}.${${LIBNAME}_VERSION_PATCH}")
 598
 599     # append a TWEAK version if it exists:
 600     set(${LIBNAME}_VERSION_TWEAK "")
 601     if("${${LIBNAME}_H}" MATCHES "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.[0-9]+\\.([0-9]+).*$")
 602       set(${LIBNAME}_VERSION_TWEAK "${CMAKE_MATCH_1}" ${ARGN})
 603     endif()
 604     if(${LIBNAME}_VERSION_TWEAK)
 605       set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}.${${LIBNAME}_VERSION_TWEAK}" ${ARGN})
 606     else()
 607       set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}" ${ARGN})
 608     endif()
 609   endif()
 610 endmacro()
 611
 612 # read single version info from the pkg file
 613 macro(ocv_parse_pkg LIBNAME PKG_PATH SCOPE)
 614   if(EXISTS "${PKG_PATH}/${LIBNAME}.pc")
 615     file(STRINGS "${PKG_PATH}/${LIBNAME}.pc" line_to_parse REGEX "^Version:[ \t]+[0-9.]*.*$" LIMIT_COUNT 1)
 616     STRING(REGEX REPLACE ".*Version: ([^ ]+).*" "\\1" ALIASOF_${LIBNAME}_VERSION "${line_to_parse}" )
 617   endif()
 618 endmacro()
 619
 620 ################################################################################################
 621 # short command to setup source group
 622 function(ocv_source_group group)
 623   cmake_parse_arguments(SG "" "DIRBASE" "GLOB;GLOB_RECURSE;FILES" ${ARGN})
 624   set(files "")
 625   if(SG_FILES)
 626     list(APPEND files ${SG_FILES})
 627   endif()
 628   if(SG_GLOB)
 629     file(GLOB srcs ${SG_GLOB})
 630     list(APPEND files ${srcs})
 631   endif()
 632   if(SG_GLOB_RECURSE)
 633     file(GLOB_RECURSE srcs ${SG_GLOB_RECURSE})
 634     list(APPEND files ${srcs})
 635   endif()
 636   if(SG_DIRBASE)
 637     foreach(f ${files})
 638       file(RELATIVE_PATH fpart "${SG_DIRBASE}" "${f}")
 639       if(fpart MATCHES "^\\.\\.")
 640         message(AUTHOR_WARNING "Can't detect subpath for source_group command: Group=${group} FILE=${f} DIRBASE=${SG_DIRBASE}")
 641         set(fpart "")
 642       else()
 643         get_filename_component(fpart "${fpart}" PATH)
 644         if(fpart)
 645           set(fpart "/${fpart}") # add '/'
 646           string(REPLACE "/" "\\" fpart "${fpart}")
 647         endif()
 648       endif()
 649       source_group("${group}${fpart}" FILES ${f})
 650     endforeach()
 651   else()
 652     source_group(${group} FILES ${files})
 653   endif()
 654 endfunction()