#
# It uses various tools to obtain the list of required shared library files:
# dumpbin (Windows)
+# objdump (MinGW on Windows)
# ldd (Linux/Unix)
# otool (Mac OSX)
# The following functions are provided by this module:
if("${item}" STREQUAL "${value}")
set(contains 1)
break()
- endif("${item}" STREQUAL "${value}")
- endforeach(item)
+ endif()
+ endforeach()
if(NOT contains)
set(${list_var} ${${list_var}} "${value}" PARENT_SCOPE)
- endif(NOT contains)
-endfunction(gp_append_unique)
+ endif()
+endfunction()
function(is_file_executable file result_var)
if("${file_full_lower}" MATCHES "\\.exe$")
set(${result_var} 1 PARENT_SCOPE)
return()
- endif("${file_full_lower}" MATCHES "\\.exe$")
+ endif()
# A clause could be added here that uses output or return value of dumpbin
# to determine ${result_var}. In 99%+? practical cases, the exe name
# match will be sufficient...
#
- endif(WIN32 AND NOT UNIX)
+ endif()
# Use the information returned from the Unix shell command "file" to
# determine if ${file_full} should be considered an executable file...
if(UNIX)
if(NOT file_cmd)
find_program(file_cmd "file")
- endif(NOT file_cmd)
+ mark_as_advanced(file_cmd)
+ endif()
if(file_cmd)
execute_process(COMMAND "${file_cmd}" "${file_full}"
#message(STATUS "executable!")
if("${file_ov}" MATCHES "text")
#message(STATUS "but text, so *not* a binary executable!")
- else("${file_ov}" MATCHES "text")
+ else()
set(${result_var} 1 PARENT_SCOPE)
return()
- endif("${file_ov}" MATCHES "text")
- endif("${file_ov}" MATCHES "executable")
+ endif()
+ endif()
# Also detect position independent executables on Linux,
# where "file" gives "shared object ... (uses shared libraries)"
return()
endif()
- else(file_cmd)
+ else()
message(STATUS "warning: No 'file' command, skipping execute_process...")
- endif(file_cmd)
- endif(UNIX)
-endfunction(is_file_executable)
+ endif()
+ endif()
+endfunction()
function(gp_item_default_embedded_path item default_embedded_path_var)
if(item MATCHES "\\.dylib$")
set(path "@executable_path/../MacOS")
set(overridden 1)
- endif(item MATCHES "\\.dylib$")
+ endif()
# Embed frameworks in the embedded "Frameworks" directory (sibling of MacOS):
#
if(item MATCHES "[^/]+\\.framework/")
set(path "@executable_path/../Frameworks")
set(overridden 1)
- endif(item MATCHES "[^/]+\\.framework/")
- endif(NOT overridden)
+ endif()
+ endif()
endif()
# Provide a hook so that projects can override the default embedded location
#
if(COMMAND gp_item_default_embedded_path_override)
gp_item_default_embedded_path_override("${item}" path)
- endif(COMMAND gp_item_default_embedded_path_override)
+ endif()
set(${default_embedded_path_var} "${path}" PARENT_SCOPE)
-endfunction(gp_item_default_embedded_path)
+endfunction()
function(gp_resolve_item context item exepath dirs resolved_item_var)
#
if(IS_ABSOLUTE "${resolved_item}" AND EXISTS "${resolved_item}")
set(resolved 1)
- endif(IS_ABSOLUTE "${resolved_item}" AND EXISTS "${resolved_item}")
+ endif()
if(NOT resolved)
if(item MATCHES "@executable_path")
#message(STATUS "info: embedded item exists (${ri})")
set(resolved 1)
set(resolved_item "${ri}")
- else(EXISTS "${ri}")
+ else()
message(STATUS "warning: embedded item does not exist '${ri}'")
- endif(EXISTS "${ri}")
- endif(item MATCHES "@executable_path")
- endif(NOT resolved)
+ endif()
+ endif()
+ endif()
if(NOT resolved)
if(item MATCHES "@loader_path")
#message(STATUS "info: embedded item exists (${ri})")
set(resolved 1)
set(resolved_item "${ri}")
- else(EXISTS "${ri}")
+ else()
message(STATUS "warning: embedded item does not exist '${ri}'")
- endif(EXISTS "${ri}")
- endif(item MATCHES "@loader_path")
- endif(NOT resolved)
+ endif()
+ endif()
+ endif()
if(NOT resolved)
if(item MATCHES "@rpath")
set(resolved 1)
set(resolved_item "${ri}")
set(ri "ri-NOTFOUND")
- endif(ri)
+ endif()
- endif(item MATCHES "@rpath")
- endif(NOT resolved)
+ endif()
+ endif()
if(NOT resolved)
set(ri "ri-NOTFOUND")
set(resolved 1)
set(resolved_item "${ri}")
set(ri "ri-NOTFOUND")
- endif(ri)
- endif(NOT resolved)
+ endif()
+ endif()
if(NOT resolved)
if(item MATCHES "[^/]+\\.framework/")
set(resolved 1)
set(resolved_item "${fw}")
set(fw "fw-NOTFOUND")
- endif(fw)
- endif(item MATCHES "[^/]+\\.framework/")
- endif(NOT resolved)
+ endif()
+ endif()
+ endif()
# Using find_program on Windows will find dll files that are in the PATH.
# (Converting simple file names into full path names if found.)
set(resolved 1)
set(resolved_item "${ri}")
set(ri "ri-NOTFOUND")
- endif(ri)
- endif(NOT resolved)
- endif(WIN32 AND NOT UNIX)
+ endif()
+ endif()
+ endif()
# Provide a hook so that projects can override item resolution
# by whatever logic they choose:
#
if(COMMAND gp_resolve_item_override)
gp_resolve_item_override("${context}" "${item}" "${exepath}" "${dirs}" resolved_item resolved)
- endif(COMMAND gp_resolve_item_override)
+ endif()
if(NOT resolved)
message(STATUS "
# resolved_item_var='${resolved_item_var}'
#******************************************************************************
#")
- endif(NOT resolved)
+ endif()
set(${resolved_item_var} "${resolved_item}" PARENT_SCOPE)
-endfunction(gp_resolve_item)
+endfunction()
function(gp_resolved_file_type original_file file exepath dirs type_var)
if(lower MATCHES "^(${sysroot}/sys(tem|wow)|${windir}/sys(tem|wow)|(.*/)*msvc[^/]+dll)")
set(is_system 1)
endif()
- endif(CYGPATH_EXECUTABLE)
- endif(UNIX)
- endif(WIN32)
+ endif()
+ endif()
+ endif()
if(NOT is_system)
get_filename_component(original_path "${original_lower}" PATH)
gp_resolved_file_type("${original_file}" "${file}" "${exepath}" "" type)
set(${type_var} "${type}" PARENT_SCOPE)
-endfunction(gp_file_type)
+endfunction()
function(get_prerequisites target prerequisites_var exclude_system recurse exepath dirs)
if(NOT IS_ABSOLUTE "${target}")
message("warning: target '${target}' is not absolute...")
- endif(NOT IS_ABSOLUTE "${target}")
+ endif()
if(NOT EXISTS "${target}")
message("warning: target '${target}' does not exist...")
- endif(NOT EXISTS "${target}")
+ endif()
+
+ set(gp_cmd_paths ${gp_cmd_paths}
+ "C:/Program Files/Microsoft Visual Studio 9.0/VC/bin"
+ "C:/Program Files (x86)/Microsoft Visual Studio 9.0/VC/bin"
+ "C:/Program Files/Microsoft Visual Studio 8/VC/BIN"
+ "C:/Program Files (x86)/Microsoft Visual Studio 8/VC/BIN"
+ "C:/Program Files/Microsoft Visual Studio .NET 2003/VC7/BIN"
+ "C:/Program Files (x86)/Microsoft Visual Studio .NET 2003/VC7/BIN"
+ "/usr/local/bin"
+ "/usr/bin"
+ )
# <setup-gp_tool-vars>
#
#
if("${gp_tool}" STREQUAL "")
set(gp_tool "ldd")
+
if(APPLE)
set(gp_tool "otool")
- endif(APPLE)
+ endif()
+
if(WIN32 AND NOT UNIX) # This is how to check for cygwin, har!
- set(gp_tool "dumpbin")
- endif(WIN32 AND NOT UNIX)
- endif("${gp_tool}" STREQUAL "")
+ find_program(gp_dumpbin "dumpbin" PATHS ${gp_cmd_paths})
+ if(gp_dumpbin)
+ set(gp_tool "dumpbin")
+ else() # Try harder. Maybe we're on MinGW
+ set(gp_tool "objdump")
+ endif()
+ endif()
+ endif()
+
+ find_program(gp_cmd ${gp_tool} PATHS ${gp_cmd_paths})
+
+ if(NOT gp_cmd)
+ message(STATUS "warning: could not find '${gp_tool}' - cannot analyze prerequisites...")
+ return()
+ endif()
set(gp_tool_known 0)
set(gp_regex_fallback "^[\t ]*([^\t ]+) => ([^\t ]+).*${eol_char}$")
set(gp_regex_cmp_count 1)
set(gp_tool_known 1)
- endif("${gp_tool}" STREQUAL "ldd")
+ endif()
if("${gp_tool}" STREQUAL "otool")
set(gp_cmd_args "-L")
set(gp_regex_fallback "")
set(gp_regex_cmp_count 3)
set(gp_tool_known 1)
- endif("${gp_tool}" STREQUAL "otool")
+ endif()
if("${gp_tool}" STREQUAL "dumpbin")
set(gp_cmd_args "/dependents")
set(gp_regex_fallback "")
set(gp_regex_cmp_count 1)
set(gp_tool_known 1)
- set(ENV{VS_UNICODE_OUTPUT} "") # Block extra output from inside VS IDE.
- endif("${gp_tool}" STREQUAL "dumpbin")
+ endif()
+
+ if("${gp_tool}" STREQUAL "objdump")
+ set(gp_cmd_args "-p")
+ set(gp_regex "^\t*DLL Name: (.*\\.[Dd][Ll][Ll])${eol_char}$")
+ set(gp_regex_error "")
+ set(gp_regex_fallback "")
+ set(gp_regex_cmp_count 1)
+ set(gp_tool_known 1)
+ endif()
if(NOT gp_tool_known)
message(STATUS "warning: gp_tool='${gp_tool}' is an unknown tool...")
message(STATUS "CMake function get_prerequisites needs more code to handle '${gp_tool}'")
- message(STATUS "Valid gp_tool values are dumpbin, ldd and otool.")
+ message(STATUS "Valid gp_tool values are dumpbin, ldd, objdump and otool.")
return()
- endif(NOT gp_tool_known)
-
- set(gp_cmd_paths ${gp_cmd_paths}
- "C:/Program Files/Microsoft Visual Studio 9.0/VC/bin"
- "C:/Program Files (x86)/Microsoft Visual Studio 9.0/VC/bin"
- "C:/Program Files/Microsoft Visual Studio 8/VC/BIN"
- "C:/Program Files (x86)/Microsoft Visual Studio 8/VC/BIN"
- "C:/Program Files/Microsoft Visual Studio .NET 2003/VC7/BIN"
- "C:/Program Files (x86)/Microsoft Visual Studio .NET 2003/VC7/BIN"
- "/usr/local/bin"
- "/usr/bin"
- )
-
- find_program(gp_cmd ${gp_tool} PATHS ${gp_cmd_paths})
+ endif()
- if(NOT gp_cmd)
- message(STATUS "warning: could not find '${gp_tool}' - cannot analyze prerequisites...")
- return()
- endif(NOT gp_cmd)
if("${gp_tool}" STREQUAL "dumpbin")
# When running dumpbin, it also needs the "Common7/IDE" directory in the
if("${gp_env_path_element}" STREQUAL "${gp_cmd_dlls_dir}")
set(gp_found_cmd_dlls_dir 1)
endif()
- endforeach(gp_env_path_element)
+ endforeach()
if(NOT gp_found_cmd_dlls_dir)
file(TO_NATIVE_PATH "${gp_cmd_dlls_dir}" gp_cmd_dlls_dir)
set(ENV{PATH} "$ENV{PATH};${gp_cmd_dlls_dir}")
endif()
- endif(EXISTS "${gp_cmd_dlls_dir}")
- endif("${gp_tool}" STREQUAL "dumpbin")
+ endif()
+ endif()
#
# </setup-gp_tool-vars>
set(old_ld_env "$ENV{LD_LIBRARY_PATH}")
foreach(dir ${exepath} ${dirs})
set(ENV{LD_LIBRARY_PATH} "${dir}:$ENV{LD_LIBRARY_PATH}")
- endforeach(dir)
- endif("${gp_tool}" STREQUAL "ldd")
+ endforeach()
+ endif()
# Track new prerequisites at each new level of recursion. Start with an
if("${gp_tool}" STREQUAL "ldd")
set(ENV{LD_LIBRARY_PATH} "${old_ld_env}")
- endif("${gp_tool}" STREQUAL "ldd")
+ endif()
if(verbose)
message(STATUS "<RawOutput cmd='${gp_cmd} ${gp_cmd_args} ${target}'>")
message(STATUS "gp_cmd_ov='${gp_cmd_ov}'")
message(STATUS "</RawOutput>")
- endif(verbose)
+ endif()
get_filename_component(target_dir "${target}" PATH)
# trim
string(REGEX MATCH "[^\n ].*[^\n ]" gp_install_id "${gp_install_id}")
#message("INSTALL ID is \"${gp_install_id}\"")
- endif(gp_install_id)
- endif("${gp_tool}" STREQUAL "otool")
+ endif()
+ endif()
# Analyze each line for file names that match the regular expression:
#
# Extract information from each candidate:
if(gp_regex_error AND "${candidate}" MATCHES "${gp_regex_error}")
string(REGEX REPLACE "${gp_regex_fallback}" "\\1" raw_item "${candidate}")
- else(gp_regex_error AND "${candidate}" MATCHES "${gp_regex_error}")
+ else()
string(REGEX REPLACE "${gp_regex}" "\\1" raw_item "${candidate}")
- endif(gp_regex_error AND "${candidate}" MATCHES "${gp_regex_error}")
+ endif()
if(gp_regex_cmp_count GREATER 1)
string(REGEX REPLACE "${gp_regex}" "\\2" raw_compat_version "${candidate}")
string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" compat_major_version "${raw_compat_version}")
string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" compat_minor_version "${raw_compat_version}")
string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" compat_patch_version "${raw_compat_version}")
- endif(gp_regex_cmp_count GREATER 1)
+ endif()
if(gp_regex_cmp_count GREATER 2)
string(REGEX REPLACE "${gp_regex}" "\\3" raw_current_version "${candidate}")
string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" current_major_version "${raw_current_version}")
string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" current_minor_version "${raw_current_version}")
string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" current_patch_version "${raw_current_version}")
- endif(gp_regex_cmp_count GREATER 2)
+ endif()
# Use the raw_item as the list entries returned by this function. Use the
# gp_resolve_item function to resolve it to an actual full path file if
if("${item}" STREQUAL "${gp_install_id}")
set(add_item 0)
- endif("${item}" STREQUAL "${gp_install_id}")
+ endif()
if(add_item AND ${exclude_system})
set(type "")
if("${type}" STREQUAL "system")
set(add_item 0)
- endif("${type}" STREQUAL "system")
- endif(add_item AND ${exclude_system})
+ endif()
+ endif()
if(add_item)
list(LENGTH ${prerequisites_var} list_length_before_append)
if(NOT list_length_before_append EQUAL list_length_after_append)
gp_resolve_item("${target}" "${item}" "${exepath}" "${dirs}" resolved_item)
set(unseen_prereqs ${unseen_prereqs} "${resolved_item}")
- endif(NOT list_length_before_append EQUAL list_length_after_append)
- endif(${recurse})
- endif(add_item)
- else("${candidate}" MATCHES "${gp_regex}")
+ endif()
+ endif()
+ endif()
+ else()
if(verbose)
message(STATUS "ignoring non-matching line: '${candidate}'")
- endif(verbose)
- endif("${candidate}" MATCHES "${gp_regex}")
- endforeach(candidate)
+ endif()
+ endif()
+ endforeach()
list(LENGTH ${prerequisites_var} prerequisites_var_length)
if(prerequisites_var_length GREATER 0)
list(SORT ${prerequisites_var})
- endif(prerequisites_var_length GREATER 0)
+ endif()
if(${recurse})
set(more_inputs ${unseen_prereqs})
foreach(input ${more_inputs})
get_prerequisites("${input}" ${prerequisites_var} ${exclude_system} ${recurse} "${exepath}" "${dirs}")
- endforeach(input)
- endif(${recurse})
+ endforeach()
+ endif()
set(${prerequisites_var} ${${prerequisites_var}} PARENT_SCOPE)
-endfunction(get_prerequisites)
+endfunction()
function(list_prerequisites target)
if("${ARGV1}" STREQUAL "")
set(all 1)
- else("${ARGV1}" STREQUAL "")
+ else()
set(all "${ARGV1}")
- endif("${ARGV1}" STREQUAL "")
+ endif()
if("${ARGV2}" STREQUAL "")
set(exclude_system 0)
- else("${ARGV2}" STREQUAL "")
+ else()
set(exclude_system "${ARGV2}")
- endif("${ARGV2}" STREQUAL "")
+ endif()
if("${ARGV3}" STREQUAL "")
set(verbose 0)
- else("${ARGV3}" STREQUAL "")
+ else()
set(verbose "${ARGV3}")
- endif("${ARGV3}" STREQUAL "")
+ endif()
set(count 0)
set(count_str "")
if(print_target)
message(STATUS "File '${target}' depends on:")
- endif(print_target)
+ endif()
foreach(d ${prereqs})
math(EXPR count "${count} + 1")
if(print_count)
set(count_str "${count}. ")
- endif(print_count)
+ endif()
if(print_prerequisite_type)
gp_file_type("${target}" "${d}" type)
set(type_str " (${type})")
- endif(print_prerequisite_type)
+ endif()
message(STATUS "${count_str}${d}${type_str}")
- endforeach(d)
-endfunction(list_prerequisites)
+ endforeach()
+endfunction()
function(list_prerequisites_by_glob glob_arg glob_exp)
message(STATUS "=============================================================================")
list_prerequisites("${f}" ${ARGN})
message(STATUS "")
- endif(is_f_executable)
- endforeach(f)
-endfunction(list_prerequisites_by_glob)
+ endif()
+ endforeach()
+endfunction()
projects / platform / upstream / cmake.git / blobdiff