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 # convert list of paths to libraries names without lib prefix
 471 macro(ocv_convert_to_lib_name var)
 472   set(__tmp "")
 473   foreach(path ${ARGN})
 474     get_filename_component(__tmp_name "${path}" NAME_WE)
 475     string(REGEX REPLACE "^lib" "" __tmp_name ${__tmp_name})
 476     list(APPEND __tmp "${__tmp_name}")
 477   endforeach()
 478   set(${var} ${__tmp})
 479   unset(__tmp)
 480   unset(__tmp_name)
 481 endmacro()
 482
 483
 484 # add install command
 485 function(ocv_install_target)
 486   install(TARGETS ${ARGN})
 487
 488   set(isPackage 0)
 489   unset(__package)
 490   unset(__target)
 491   foreach(e ${ARGN})
 492     if(NOT DEFINED __target)
 493       set(__target "${e}")
 494     endif()
 495     if(isPackage EQUAL 1)
 496       set(__package "${e}")
 497       break()
 498     endif()
 499     if(e STREQUAL "EXPORT")
 500       set(isPackage 1)
 501     endif()
 502   endforeach()
 503
 504   if(DEFINED __package)
 505     list(APPEND ${__package}_TARGETS ${__target})
 506     set(${__package}_TARGETS "${${__package}_TARGETS}" CACHE INTERNAL "List of ${__package} targets")
 507   endif()
 508
 509   if(INSTALL_CREATE_DISTRIB)
 510     if(MSVC AND NOT BUILD_SHARED_LIBS)
 511       set(__target "${ARGV0}")
 512
 513       set(isArchive 0)
 514       set(isDst 0)
 515       unset(__dst)
 516       foreach(e ${ARGN})
 517         if(isDst EQUAL 1)
 518           set(__dst "${e}")
 519           break()
 520         endif()
 521         if(isArchive EQUAL 1 AND e STREQUAL "DESTINATION")
 522           set(isDst 1)
 523         endif()
 524         if(e STREQUAL "ARCHIVE")
 525           set(isArchive 1)
 526         else()
 527           set(isArchive 0)
 528         endif()
 529       endforeach()
 530
 531 #      message(STATUS "Process ${__target} dst=${__dst}...")
 532       if(DEFINED __dst)
 533         get_target_property(fname ${__target} LOCATION_DEBUG)
 534         if(fname MATCHES "\\.lib$")
 535           string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
 536           install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Debug)
 537         endif()
 538
 539         get_target_property(fname ${__target} LOCATION_RELEASE)
 540         if(fname MATCHES "\\.lib$")
 541           string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
 542           install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Release)
 543         endif()
 544       endif()
 545     endif()
 546   endif()
 547 endfunction()
 548
 549
 550 # read set of version defines from the header file
 551 macro(ocv_parse_header FILENAME FILE_VAR)
 552   set(vars_regex "")
 553   set(__parnet_scope OFF)
 554   set(__add_cache OFF)
 555   foreach(name ${ARGN})
 556     if("${name}" STREQUAL "PARENT_SCOPE")
 557       set(__parnet_scope ON)
 558     elseif("${name}" STREQUAL "CACHE")
 559       set(__add_cache ON)
 560     elseif(vars_regex)
 561       set(vars_regex "${vars_regex}|${name}")
 562     else()
 563       set(vars_regex "${name}")
 564     endif()
 565   endforeach()
 566   if(EXISTS "${FILENAME}")
 567     file(STRINGS "${FILENAME}" ${FILE_VAR} REGEX "#define[ \t]+(${vars_regex})[ \t]+[0-9]+" )
 568   else()
 569     unset(${FILE_VAR})
 570   endif()
 571   foreach(name ${ARGN})
 572     if(NOT "${name}" STREQUAL "PARENT_SCOPE" AND NOT "${name}" STREQUAL "CACHE")
 573       if(${FILE_VAR})
 574         if(${FILE_VAR} MATCHES ".+[ \t]${name}[ \t]+([0-9]+).*")
 575           string(REGEX REPLACE ".+[ \t]${name}[ \t]+([0-9]+).*" "\\1" ${name} "${${FILE_VAR}}")
 576         else()
 577           set(${name} "")
 578         endif()
 579         if(__add_cache)
 580           set(${name} ${${name}} CACHE INTERNAL "${name} parsed from ${FILENAME}" FORCE)
 581         elseif(__parnet_scope)
 582           set(${name} "${${name}}" PARENT_SCOPE)
 583         endif()
 584       else()
 585         unset(${name} CACHE)
 586       endif()
 587     endif()
 588   endforeach()
 589 endmacro()
 590
 591 # read single version define from the header file
 592 macro(ocv_parse_header2 LIBNAME HDR_PATH VARNAME)
 593   ocv_clear_vars(${LIBNAME}_VERSION_MAJOR
 594                  ${LIBNAME}_VERSION_MAJOR
 595                  ${LIBNAME}_VERSION_MINOR
 596                  ${LIBNAME}_VERSION_PATCH
 597                  ${LIBNAME}_VERSION_TWEAK
 598                  ${LIBNAME}_VERSION_STRING)
 599   set(${LIBNAME}_H "")
 600   if(EXISTS "${HDR_PATH}")
 601     file(STRINGS "${HDR_PATH}" ${LIBNAME}_H REGEX "^#define[ \t]+${VARNAME}[ \t]+\"[^\"]*\".*$" LIMIT_COUNT 1)
 602   endif()
 603
 604   if(${LIBNAME}_H)
 605     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MAJOR "${${LIBNAME}_H}")
 606     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_MINOR  "${${LIBNAME}_H}")
 607     string(REGEX REPLACE "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" ${LIBNAME}_VERSION_PATCH "${${LIBNAME}_H}")
 608     set(${LIBNAME}_VERSION_MAJOR ${${LIBNAME}_VERSION_MAJOR} ${ARGN})
 609     set(${LIBNAME}_VERSION_MINOR ${${LIBNAME}_VERSION_MINOR} ${ARGN})
 610     set(${LIBNAME}_VERSION_PATCH ${${LIBNAME}_VERSION_PATCH} ${ARGN})
 611     set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_MAJOR}.${${LIBNAME}_VERSION_MINOR}.${${LIBNAME}_VERSION_PATCH}")
 612
 613     # append a TWEAK version if it exists:
 614     set(${LIBNAME}_VERSION_TWEAK "")
 615     if("${${LIBNAME}_H}" MATCHES "^.*[ \t]${VARNAME}[ \t]+\"[0-9]+\\.[0-9]+\\.[0-9]+\\.([0-9]+).*$")
 616       set(${LIBNAME}_VERSION_TWEAK "${CMAKE_MATCH_1}" ${ARGN})
 617     endif()
 618     if(${LIBNAME}_VERSION_TWEAK)
 619       set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}.${${LIBNAME}_VERSION_TWEAK}" ${ARGN})
 620     else()
 621       set(${LIBNAME}_VERSION_STRING "${${LIBNAME}_VERSION_STRING}" ${ARGN})
 622     endif()
 623   endif()
 624 endmacro()
 625
 626 # read single version info from the pkg file
 627 macro(ocv_parse_pkg LIBNAME PKG_PATH SCOPE)
 628   if(EXISTS "${PKG_PATH}/${LIBNAME}.pc")
 629     file(STRINGS "${PKG_PATH}/${LIBNAME}.pc" line_to_parse REGEX "^Version:[ \t]+[0-9.]*.*$" LIMIT_COUNT 1)
 630     STRING(REGEX REPLACE ".*Version: ([^ ]+).*" "\\1" ALIASOF_${LIBNAME}_VERSION "${line_to_parse}" )
 631   endif()
 632 endmacro()
 633
 634 ################################################################################################
 635 # short command to setup source group
 636 function(ocv_source_group group)
 637   cmake_parse_arguments(SG "" "DIRBASE" "GLOB;GLOB_RECURSE;FILES" ${ARGN})
 638   set(files "")
 639   if(SG_FILES)
 640     list(APPEND files ${SG_FILES})
 641   endif()
 642   if(SG_GLOB)
 643     file(GLOB srcs ${SG_GLOB})
 644     list(APPEND files ${srcs})
 645   endif()
 646   if(SG_GLOB_RECURSE)
 647     file(GLOB_RECURSE srcs ${SG_GLOB_RECURSE})
 648     list(APPEND files ${srcs})
 649   endif()
 650   if(SG_DIRBASE)
 651     foreach(f ${files})
 652       file(RELATIVE_PATH fpart "${SG_DIRBASE}" "${f}")
 653       if(fpart MATCHES "^\\.\\.")
 654         message(AUTHOR_WARNING "Can't detect subpath for source_group command: Group=${group} FILE=${f} DIRBASE=${SG_DIRBASE}")
 655         set(fpart "")
 656       else()
 657         get_filename_component(fpart "${fpart}" PATH)
 658         if(fpart)
 659           set(fpart "/${fpart}") # add '/'
 660           string(REPLACE "/" "\\" fpart "${fpart}")
 661         endif()
 662       endif()
 663       source_group("${group}${fpart}" FILES ${f})
 664     endforeach()
 665   else()
 666     source_group(${group} FILES ${files})
 667   endif()
 668 endfunction()