Merge remote-tracking branch 'origin/2.4' into merge-2.4
[profile/ivi/opencv.git] / 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()