[Cmake-commits] CMake branch, next, updated. v3.0.1-5190-gdc72b62
Brad King
brad.king at kitware.com
Mon Sep 8 09:03:07 EDT 2014
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, next has been updated
via dc72b62916a48c726847e8664e1dcb53c611200c (commit)
via c106311f52ed4d8b1b6f7b262b4dffff923620f0 (commit)
via bd67c3eae4129cd92ec8f8849678e15dbf2fa2c1 (commit)
via ea9e35be8bd3aa3011b9cde58817a2f86dc65568 (commit)
via 7747b13e60a3ada1621762e4b49f6089f255f094 (commit)
via 195ec6b3fee0b58aad049ef29b1f7ef4ec5b43bd (commit)
via 02dfaa312c22d77bcba24bba7768bb00b956a735 (commit)
from 8cd8f3cf2ae8541b3d49e4c8b5f83d8d215de0d9 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=dc72b62916a48c726847e8664e1dcb53c611200c
commit dc72b62916a48c726847e8664e1dcb53c611200c
Merge: 8cd8f3c c106311
Author: Brad King <brad.king at kitware.com>
AuthorDate: Mon Sep 8 09:03:05 2014 -0400
Commit: CMake Topic Stage <kwrobot at kitware.com>
CommitDate: Mon Sep 8 09:03:05 2014 -0400
Merge topic 'bundle-updates' into next
c106311f cmake-gui: Make sure we bundle Qt5 Cocoa platform plugin
bd67c3ea BundleUtilities: Codesign needs framework's Contents/Info.plist
ea9e35be BundleUtilities: Process executables first when scanning bundle
7747b13e BundleUtilities: Resolve & replace @rpath placeholders
195ec6b3 GetPrerequisites: Make sure dyld placeholders are prefixes
02dfaa31 BundleUtilities: Use 'find' on UNIX for fast executable lookup
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=c106311f52ed4d8b1b6f7b262b4dffff923620f0
commit c106311f52ed4d8b1b6f7b262b4dffff923620f0
Author: Adam Strzelecki <ono at java.pl>
AuthorDate: Thu Sep 4 15:11:46 2014 +0200
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Sep 5 08:31:26 2014 -0400
cmake-gui: Make sure we bundle Qt5 Cocoa platform plugin
Otherwise CMake.app bundle will not run when using Qt5.
diff --git a/Source/QtDialog/CMakeLists.txt b/Source/QtDialog/CMakeLists.txt
index 8da88c1..03c2fb4 100644
--- a/Source/QtDialog/CMakeLists.txt
+++ b/Source/QtDialog/CMakeLists.txt
@@ -35,6 +35,32 @@ if (Qt5Widgets_FOUND)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
+ # We need to install Cocoa platform plugin and add qt.conf for Qt5 on Mac.
+ # FIXME: This should be part of Qt5 CMake scripts, but unfortunatelly
+ # Qt5 Mac support is missing there.
+ if(APPLE)
+ macro(install_qt5_plugin _qt_plugin_name _qt_plugins_var)
+ get_target_property(_qt_plugin_path "${_qt_plugin_name}" LOCATION)
+ if(EXISTS "${_qt_plugin_path}")
+ get_filename_component(_qt_plugin_file "${_qt_plugin_path}" NAME)
+ get_filename_component(_qt_plugin_type "${_qt_plugin_path}" PATH)
+ get_filename_component(_qt_plugin_type "${_qt_plugin_type}" NAME)
+ set(_qt_plugin_dest "${CMAKE_INSTALL_PREFIX}/PlugIns/${_qt_plugin_type}")
+ install(FILES "${_qt_plugin_path}"
+ DESTINATION "${_qt_plugin_dest}")
+ set(${_qt_plugins_var}
+ "${${_qt_plugins_var}};${_qt_plugin_dest}/${_qt_plugin_file}")
+ else()
+ message(FATAL_ERROR "QT plugin ${_qt_plugin_name} not found")
+ endif()
+ endmacro()
+ install_qt5_plugin("Qt5::QCocoaIntegrationPlugin" QT_PLUGINS)
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/qt.conf"
+ "[Paths]\nPlugins = PlugIns\n")
+ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/qt.conf"
+ DESTINATION "${CMAKE_INSTALL_PREFIX}/Resources")
+ endif()
+
if(WIN32 AND TARGET Qt5::Core)
get_property(_Qt5_Core_LOCATION TARGET Qt5::Core PROPERTY LOCATION)
get_filename_component(Qt_BIN_DIR "${_Qt5_Core_LOCATION}" PATH)
@@ -168,7 +194,7 @@ if(APPLE OR WIN32)
install(CODE "
include(\"${CMake_SOURCE_DIR}/Modules/BundleUtilities.cmake\")
set(BU_CHMOD_BUNDLE_ITEMS ON)
- fixup_bundle(\"${fixup_exe}\" \"\" \"${QT_LIBRARY_DIR};${QT_BINARY_DIR}\")
+ fixup_bundle(\"${fixup_exe}\" \"${QT_PLUGINS}\" \"${QT_LIBRARY_DIR};${QT_BINARY_DIR}\")
")
endif()
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=bd67c3eae4129cd92ec8f8849678e15dbf2fa2c1
commit bd67c3eae4129cd92ec8f8849678e15dbf2fa2c1
Author: Adam Strzelecki <ono at java.pl>
AuthorDate: Thu Sep 4 15:11:45 2014 +0200
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Sep 5 08:31:26 2014 -0400
BundleUtilities: Codesign needs framework's Contents/Info.plist
Therefore we need to bundle it (if present) too when fixing Mac OS X app bundle.
diff --git a/Modules/BundleUtilities.cmake b/Modules/BundleUtilities.cmake
index e99da9b..5c7b0ff 100644
--- a/Modules/BundleUtilities.cmake
+++ b/Modules/BundleUtilities.cmake
@@ -632,6 +632,14 @@ function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_ite
#message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_resources}' '${resolved_embedded_resources}'")
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${resolved_resources}" "${resolved_embedded_resources}")
endif()
+
+ # And Info.plist, if it exists:
+ string(REGEX REPLACE "^(.*)/[^/]+/[^/]+/[^/]+$" "\\1/Contents/Info.plist" resolved_info_plist "${resolved_item}")
+ string(REGEX REPLACE "^(.*)/[^/]+/[^/]+/[^/]+$" "\\1/Contents/Info.plist" resolved_embedded_info_plist "${resolved_embedded_item}")
+ if(EXISTS "${resolved_info_plist}")
+ #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_info_plist}' '${resolved_embedded_info_plist}'")
+ execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_info_plist}" "${resolved_embedded_info_plist}")
+ endif()
endif()
if(UNIX AND NOT APPLE)
file(RPATH_REMOVE FILE "${resolved_embedded_item}")
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=ea9e35be8bd3aa3011b9cde58817a2f86dc65568
commit ea9e35be8bd3aa3011b9cde58817a2f86dc65568
Author: Adam Strzelecki <ono at java.pl>
AuthorDate: Fri Sep 5 13:50:42 2014 +0200
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Sep 5 08:31:22 2014 -0400
BundleUtilities: Process executables first when scanning bundle
This makes rpaths populated (if any), so libraries containing @rpath will be
resolved properly.
diff --git a/Modules/BundleUtilities.cmake b/Modules/BundleUtilities.cmake
index 9733bc9..e99da9b 100644
--- a/Modules/BundleUtilities.cmake
+++ b/Modules/BundleUtilities.cmake
@@ -527,21 +527,6 @@ function(get_bundle_keys app libs dirs keys_var)
#
get_bundle_all_executables("${bundle}" file_list)
- # For each extra lib, accumulate a key as well and then also accumulate
- # any of its prerequisites. (Extra libs are typically dynamically loaded
- # plugins: libraries that are prerequisites for full runtime functionality
- # but that do not show up in otool -L output...)
- #
- foreach(lib ${libs})
- set_bundle_key_values(${keys_var} "${lib}" "${lib}" "${executable}" "${dirs}" 0)
-
- set(prereqs "")
- get_prerequisites("${lib}" prereqs 1 1 "${executable}" "${dirs}")
- foreach(pr ${prereqs})
- set_bundle_key_values(${keys_var} "${lib}" "${pr}" "${executable}" "${dirs}" 1)
- endforeach()
- endforeach()
-
# For each executable found in the bundle, accumulate keys as we go.
# The list of keys should be complete when all prerequisites of all
# binaries in the bundle have been analyzed.
@@ -560,6 +545,21 @@ function(get_bundle_keys app libs dirs keys_var)
endforeach()
endforeach()
+ # For each extra lib, accumulate a key as well and then also accumulate
+ # any of its prerequisites. (Extra libs are typically dynamically loaded
+ # plugins: libraries that are prerequisites for full runtime functionality
+ # but that do not show up in otool -L output...)
+ #
+ foreach(lib ${libs})
+ set_bundle_key_values(${keys_var} "${lib}" "${lib}" "${executable}" "${dirs}" 0)
+
+ set(prereqs "")
+ get_prerequisites("${lib}" prereqs 1 1 "${executable}" "${dirs}")
+ foreach(pr ${prereqs})
+ set_bundle_key_values(${keys_var} "${lib}" "${pr}" "${executable}" "${dirs}" 1)
+ endforeach()
+ endforeach()
+
# Propagate values to caller's scope:
#
set(${keys_var} ${${keys_var}} PARENT_SCOPE)
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=7747b13e60a3ada1621762e4b49f6089f255f094
commit 7747b13e60a3ada1621762e4b49f6089f255f094
Author: Adam Strzelecki <ono at java.pl>
AuthorDate: Fri Sep 5 13:50:41 2014 +0200
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Sep 5 08:31:19 2014 -0400
BundleUtilities: Resolve & replace @rpath placeholders
This is done by gathering LC_RPATH commands for main bundle executable and
using it for @rpath lookup in dependent frameworks.
To achieve this all utility functions now take path to executable rather than
path to its directory.
This enabled apps using @rpath to be bundled correctly, which will be necessary
for upcoming Qt 5.4 that will use @rpath for all frameworks.
diff --git a/Modules/BundleUtilities.cmake b/Modules/BundleUtilities.cmake
index 7e2b173..9733bc9 100644
--- a/Modules/BundleUtilities.cmake
+++ b/Modules/BundleUtilities.cmake
@@ -19,6 +19,7 @@
# get_bundle_and_executable
# get_bundle_all_executables
# get_item_key
+# get_item_rpaths
# clear_bundle_keys
# set_bundle_key_values
# get_bundle_keys
@@ -75,7 +76,7 @@
#
# ::
#
-# GET_DOTAPP_DIR(<exe> <dotapp_dir_var>)
+# GET_DOTAPP_DIR(<executable> <dotapp_dir_var>)
#
# Returns the nearest parent dir whose name ends with ".app" given the
# full path to an executable. If there is no such parent dir, then
@@ -123,7 +124,7 @@
#
# ::
#
-# SET_BUNDLE_KEY_VALUES(<keys_var> <context> <item> <exepath> <dirs>
+# SET_BUNDLE_KEY_VALUES(<keys_var> <context> <item> <executable> <dirs>
# <copyflag>)
#
# Add a key to the list (if necessary) for the given item. If added,
@@ -163,7 +164,7 @@
#
# ::
#
-# FIXUP_BUNDLE_ITEM(<resolved_embedded_item> <exepath> <dirs>)
+# FIXUP_BUNDLE_ITEM(<resolved_embedded_item> <executable> <dirs>)
#
# Get the direct/non-system prerequisites of the resolved embedded item.
# For each prerequisite, change the way it is referenced to the value of
@@ -189,11 +190,11 @@
#
# ::
#
-# VERIFY_BUNDLE_PREREQUISITES(<bundle> <result_var> <info_var>)
+# VERIFY_BUNDLE_PREREQUISITES(<bundle> <executable> <result_var> <info_var>)
#
# Verifies that the sum of all prerequisites of all files inside the
-# bundle are contained within the bundle or are "system" libraries,
-# presumed to exist everywhere.
+# bundle with given main executable are contained within the bundle or are
+# "system" libraries, presumed to exist everywhere.
#
# ::
#
@@ -285,8 +286,8 @@ function(get_bundle_main_executable bundle result_var)
endfunction()
-function(get_dotapp_dir exe dotapp_dir_var)
- set(s "${exe}")
+function(get_dotapp_dir executable dotapp_dir_var)
+ set(s "${executable}")
if(s MATCHES "/.*\\.app/")
# If there is a ".app" parent directory,
@@ -407,6 +408,29 @@ function(get_bundle_all_executables bundle exes_var)
endfunction()
+function(get_item_rpaths item rpaths_var)
+ if(APPLE)
+ find_program(otool_cmd "otool")
+ mark_as_advanced(otool_cmd)
+ endif()
+
+ if(otool_cmd)
+ execute_process(
+ COMMAND "${otool_cmd}" -l "${item}"
+ OUTPUT_VARIABLE load_cmds_ov
+ )
+ string(REGEX REPLACE "[^\n]+cmd LC_RPATH\n[^\n]+\n[^\n]+path ([^\n]+) \\(offset[^\n]+\n" "rpath \\1\n" load_cmds_ov "${load_cmds_ov}")
+ string(REGEX MATCHALL "rpath [^\n]+" load_cmds_ov "${load_cmds_ov}")
+ string(REGEX REPLACE "rpath " "" load_cmds_ov "${load_cmds_ov}")
+ if(load_cmds_ov)
+ gp_append_unique(${rpaths_var} "${load_cmds_ov}")
+ endif()
+ endif()
+
+ set(${rpaths_var} ${${rpaths_var}} PARENT_SCOPE)
+endfunction()
+
+
function(get_item_key item key_var)
get_filename_component(item_name "${item}" NAME)
if(WIN32)
@@ -425,12 +449,13 @@ function(clear_bundle_keys keys_var)
set(${key}_EMBEDDED_ITEM PARENT_SCOPE)
set(${key}_RESOLVED_EMBEDDED_ITEM PARENT_SCOPE)
set(${key}_COPYFLAG PARENT_SCOPE)
+ set(${key}_RPATHS PARENT_SCOPE)
endforeach()
set(${keys_var} PARENT_SCOPE)
endfunction()
-function(set_bundle_key_values keys_var context item exepath dirs copyflag)
+function(set_bundle_key_values keys_var context item executable dirs copyflag)
get_filename_component(item_name "${item}" NAME)
get_item_key("${item}" key)
@@ -440,10 +465,17 @@ function(set_bundle_key_values keys_var context item exepath dirs copyflag)
list(LENGTH ${keys_var} length_after)
if(NOT length_before EQUAL length_after)
- gp_resolve_item("${context}" "${item}" "${exepath}" "${dirs}" resolved_item)
+ # Always use the exepath of the main bundle executable for @executable_path
+ # replacements:
+ #
+ get_filename_component(exepath "${executable}" PATH)
+
+ gp_resolve_item("${context}" "${item}" "${executable}" "${dirs}" resolved_item)
gp_item_default_embedded_path("${item}" default_embedded_path)
+ get_item_rpaths("${resolved_item}" rpaths)
+
if(item MATCHES "[^/]+\\.framework/")
# For frameworks, construct the name under the embedded path from the
# opening "${item_name}.framework/" to the closing "/${item_name}":
@@ -479,6 +511,7 @@ function(set_bundle_key_values keys_var context item exepath dirs copyflag)
set(${key}_EMBEDDED_ITEM "${embedded_item}" PARENT_SCOPE)
set(${key}_RESOLVED_EMBEDDED_ITEM "${resolved_embedded_item}" PARENT_SCOPE)
set(${key}_COPYFLAG "${copyflag}" PARENT_SCOPE)
+ set(${key}_RPATHS "${rpaths}" PARENT_SCOPE)
else()
#message("warning: item key '${key}' already in the list, subsequent references assumed identical to first")
endif()
@@ -490,14 +523,9 @@ function(get_bundle_keys app libs dirs keys_var)
get_bundle_and_executable("${app}" bundle executable valid)
if(valid)
- # Always use the exepath of the main bundle executable for @executable_path
- # replacements:
- #
- get_filename_component(exepath "${executable}" PATH)
-
# But do fixups on all executables in the bundle:
#
- get_bundle_all_executables("${bundle}" exes)
+ get_bundle_all_executables("${bundle}" file_list)
# For each extra lib, accumulate a key as well and then also accumulate
# any of its prerequisites. (Extra libs are typically dynamically loaded
@@ -505,12 +533,12 @@ function(get_bundle_keys app libs dirs keys_var)
# but that do not show up in otool -L output...)
#
foreach(lib ${libs})
- set_bundle_key_values(${keys_var} "${lib}" "${lib}" "${exepath}" "${dirs}" 0)
+ set_bundle_key_values(${keys_var} "${lib}" "${lib}" "${executable}" "${dirs}" 0)
set(prereqs "")
- get_prerequisites("${lib}" prereqs 1 1 "${exepath}" "${dirs}")
+ get_prerequisites("${lib}" prereqs 1 1 "${executable}" "${dirs}")
foreach(pr ${prereqs})
- set_bundle_key_values(${keys_var} "${lib}" "${pr}" "${exepath}" "${dirs}" 1)
+ set_bundle_key_values(${keys_var} "${lib}" "${pr}" "${executable}" "${dirs}" 1)
endforeach()
endforeach()
@@ -518,17 +546,17 @@ function(get_bundle_keys app libs dirs keys_var)
# The list of keys should be complete when all prerequisites of all
# binaries in the bundle have been analyzed.
#
- foreach(exe ${exes})
+ foreach(f ${file_list})
# Add the exe itself to the keys:
#
- set_bundle_key_values(${keys_var} "${exe}" "${exe}" "${exepath}" "${dirs}" 0)
+ set_bundle_key_values(${keys_var} "${f}" "${f}" "${executable}" "${dirs}" 0)
# Add each prerequisite to the keys:
#
set(prereqs "")
- get_prerequisites("${exe}" prereqs 1 1 "${exepath}" "${dirs}")
+ get_prerequisites("${f}" prereqs 1 1 "${executable}" "${dirs}")
foreach(pr ${prereqs})
- set_bundle_key_values(${keys_var} "${exe}" "${pr}" "${exepath}" "${dirs}" 1)
+ set_bundle_key_values(${keys_var} "${f}" "${pr}" "${executable}" "${dirs}" 1)
endforeach()
endforeach()
@@ -542,6 +570,7 @@ function(get_bundle_keys app libs dirs keys_var)
set(${key}_EMBEDDED_ITEM "${${key}_EMBEDDED_ITEM}" PARENT_SCOPE)
set(${key}_RESOLVED_EMBEDDED_ITEM "${${key}_RESOLVED_EMBEDDED_ITEM}" PARENT_SCOPE)
set(${key}_COPYFLAG "${${key}_COPYFLAG}" PARENT_SCOPE)
+ set(${key}_RPATHS "${${key}_RPATHS}" PARENT_SCOPE)
endforeach()
endif()
endfunction()
@@ -612,7 +641,7 @@ function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_ite
endfunction()
-function(fixup_bundle_item resolved_embedded_item exepath dirs)
+function(fixup_bundle_item resolved_embedded_item executable dirs)
# This item's key is "ikey":
#
get_item_key("${resolved_embedded_item}" ikey)
@@ -622,7 +651,7 @@ function(fixup_bundle_item resolved_embedded_item exepath dirs)
# tree, or in other varied locations around the file system, with our call to
# install_name_tool. Make sure that doesn't happen here:
#
- get_dotapp_dir("${exepath}" exe_dotapp_dir)
+ get_dotapp_dir("${executable}" exe_dotapp_dir)
string(LENGTH "${exe_dotapp_dir}/" exe_dotapp_dir_length)
string(LENGTH "${resolved_embedded_item}" resolved_embedded_item_length)
set(path_too_short 0)
@@ -648,7 +677,7 @@ function(fixup_bundle_item resolved_embedded_item exepath dirs)
endif()
set(prereqs "")
- get_prerequisites("${resolved_embedded_item}" prereqs 1 0 "${exepath}" "${dirs}")
+ get_prerequisites("${resolved_embedded_item}" prereqs 1 0 "${executable}" "${dirs}")
set(changes "")
@@ -668,12 +697,20 @@ function(fixup_bundle_item resolved_embedded_item exepath dirs)
execute_process(COMMAND chmod u+w "${resolved_embedded_item}")
endif()
+ foreach(rpath ${${ikey}_RPATHS})
+ set(changes ${changes} -delete_rpath "${rpath}")
+ endforeach()
+
+ if(${ikey}_EMBEDDED_ITEM)
+ set(changes ${changes} -id "${${ikey}_EMBEDDED_ITEM}")
+ endif()
+
# Change this item's id and all of its references in one call
# to install_name_tool:
#
- execute_process(COMMAND install_name_tool
- ${changes} -id "${${ikey}_EMBEDDED_ITEM}" "${resolved_embedded_item}"
- )
+ if(changes)
+ execute_process(COMMAND install_name_tool ${changes} "${resolved_embedded_item}")
+ endif()
endfunction()
@@ -685,8 +722,6 @@ function(fixup_bundle app libs dirs)
get_bundle_and_executable("${app}" bundle executable valid)
if(valid)
- get_filename_component(exepath "${executable}" PATH)
-
message(STATUS "fixup_bundle: preparing...")
get_bundle_keys("${app}" "${libs}" "${dirs}" keys)
@@ -732,7 +767,7 @@ function(fixup_bundle app libs dirs)
math(EXPR i ${i}+1)
if(APPLE)
message(STATUS "${i}/${n}: fixing up '${${key}_RESOLVED_EMBEDDED_ITEM}'")
- fixup_bundle_item("${${key}_RESOLVED_EMBEDDED_ITEM}" "${exepath}" "${dirs}")
+ fixup_bundle_item("${${key}_RESOLVED_EMBEDDED_ITEM}" "${executable}" "${dirs}")
else()
message(STATUS "${i}/${n}: fix-up not required on this platform '${${key}_RESOLVED_EMBEDDED_ITEM}'")
endif()
@@ -757,55 +792,49 @@ function(copy_and_fixup_bundle src dst libs dirs)
endfunction()
-function(verify_bundle_prerequisites bundle result_var info_var)
+function(verify_bundle_prerequisites bundle executable result_var info_var)
set(result 1)
set(info "")
set(count 0)
- get_bundle_main_executable("${bundle}" main_bundle_exe)
-
- file(GLOB_RECURSE file_list "${bundle}/*")
+ get_bundle_all_executables("${bundle}" file_list)
foreach(f ${file_list})
- is_file_executable("${f}" is_executable)
- if(is_executable)
- get_filename_component(exepath "${f}" PATH)
- math(EXPR count "${count} + 1")
+ math(EXPR count "${count} + 1")
- message(STATUS "executable file ${count}: ${f}")
+ message(STATUS "executable file ${count}: ${f}")
- set(prereqs "")
- get_prerequisites("${f}" prereqs 1 1 "${exepath}" "")
+ set(prereqs "")
+ get_prerequisites("${f}" prereqs 1 1 "${executable}" "")
- # On the Mac,
- # "embedded" and "system" prerequisites are fine... anything else means
- # the bundle's prerequisites are not verified (i.e., the bundle is not
- # really "standalone")
- #
- # On Windows (and others? Linux/Unix/...?)
- # "local" and "system" prereqs are fine...
- #
- set(external_prereqs "")
+ # On the Mac,
+ # "embedded" and "system" prerequisites are fine... anything else means
+ # the bundle's prerequisites are not verified (i.e., the bundle is not
+ # really "standalone")
+ #
+ # On Windows (and others? Linux/Unix/...?)
+ # "local" and "system" prereqs are fine...
+ #
+ set(external_prereqs "")
- foreach(p ${prereqs})
- set(p_type "")
- gp_file_type("${f}" "${p}" p_type)
+ foreach(p ${prereqs})
+ set(p_type "")
+ gp_file_type("${f}" "${p}" "${executable}" p_type)
- if(APPLE)
- if(NOT "${p_type}" STREQUAL "embedded" AND NOT "${p_type}" STREQUAL "system")
- set(external_prereqs ${external_prereqs} "${p}")
- endif()
- else()
- if(NOT "${p_type}" STREQUAL "local" AND NOT "${p_type}" STREQUAL "system")
- set(external_prereqs ${external_prereqs} "${p}")
- endif()
+ if(APPLE)
+ if(NOT "${p_type}" STREQUAL "embedded" AND NOT "${p_type}" STREQUAL "system")
+ set(external_prereqs ${external_prereqs} "${p}")
+ endif()
+ else()
+ if(NOT "${p_type}" STREQUAL "local" AND NOT "${p_type}" STREQUAL "system")
+ set(external_prereqs ${external_prereqs} "${p}")
endif()
- endforeach()
-
- if(external_prereqs)
- # Found non-system/somehow-unacceptable prerequisites:
- set(result 0)
- set(info ${info} "external prerequisites found:\nf='${f}'\nexternal_prereqs='${external_prereqs}'\n")
endif()
+ endforeach()
+
+ if(external_prereqs)
+ # Found non-system/somehow-unacceptable prerequisites:
+ set(result 0)
+ set(info ${info} "external prerequisites found:\nf='${f}'\nexternal_prereqs='${external_prereqs}'\n")
endif()
endforeach()
@@ -845,7 +874,7 @@ function(verify_app app)
# Verify that the bundle does not have any "external" prerequisites:
#
- verify_bundle_prerequisites("${bundle}" verified info)
+ verify_bundle_prerequisites("${bundle}" "${executable}" verified info)
message(STATUS "verified='${verified}'")
message(STATUS "info='${info}'")
message(STATUS "")
diff --git a/Modules/GetPrerequisites.cmake b/Modules/GetPrerequisites.cmake
index 49443e3..29a8470 100644
--- a/Modules/GetPrerequisites.cmake
+++ b/Modules/GetPrerequisites.cmake
@@ -41,7 +41,7 @@
# ::
#
# GET_PREREQUISITES(<target> <prerequisites_var> <exclude_system> <recurse>
-# <exepath> <dirs>)
+# <executable> <dirs>)
#
# Get the list of shared library files required by <target>. The list
# in the variable named <prerequisites_var> should be empty on first
@@ -53,7 +53,7 @@
# <exclude_system> must be 0 or 1 indicating whether to include or
# exclude "system" prerequisites. If <recurse> is set to 1 all
# prerequisites will be found recursively, if set to 0 only direct
-# prerequisites are listed. <exepath> is the path to the top level
+# prerequisites are listed. <executable> is the path to the top level
# executable used for @executable_path replacment on the Mac. <dirs> is
# a list of paths where libraries might be found: these paths are
# searched first when a target without any path info is given. Then
@@ -113,7 +113,7 @@
#
# ::
#
-# GP_RESOLVE_ITEM(<context> <item> <exepath> <dirs> <resolved_item_var>)
+# GP_RESOLVE_ITEM(<context> <item> <executable> <dirs> <resolved_item_var>)
#
# Resolve an item into an existing full path file.
#
@@ -122,13 +122,13 @@
#
# ::
#
-# GP_RESOLVED_FILE_TYPE(<original_file> <file> <exepath> <dirs> <type_var>)
+# GP_RESOLVED_FILE_TYPE(<original_file> <file> <executable> <dirs> <type_var>)
#
# Return the type of <file> with respect to <original_file>. String
# describing type of prerequisite is returned in variable named
# <type_var>.
#
-# Use <exepath> and <dirs> if necessary to resolve non-absolute <file>
+# Use <executable> and <dirs> if necessary to resolve non-absolute <file>
# values -- but only for non-embedded items.
#
# Possible types are:
@@ -318,10 +318,12 @@ function(gp_item_default_embedded_path item default_embedded_path_var)
endfunction()
-function(gp_resolve_item context item exepath dirs resolved_item_var)
+function(gp_resolve_item context item executable dirs resolved_item_var)
set(resolved 0)
set(resolved_item "${item}")
+ get_filename_component(exepath "${executable}" PATH)
+
# Is it already resolved?
#
if(IS_ABSOLUTE "${resolved_item}" AND EXISTS "${resolved_item}")
@@ -331,7 +333,7 @@ function(gp_resolve_item context item exepath dirs resolved_item_var)
if(NOT resolved)
if(item MATCHES "^@executable_path")
#
- # @executable_path references are assumed relative to exepath
+ # @executable_path references are assumed relative to executable
#
string(REPLACE "@executable_path" "${exepath}" ri "${item}")
get_filename_component(ri "${ri}" ABSOLUTE)
@@ -374,10 +376,11 @@ function(gp_resolve_item context item exepath dirs resolved_item_var)
#
string(REPLACE "@rpath/" "" norpath_item "${item}")
+ get_item_key("${executable}" key)
set(ri "ri-NOTFOUND")
- find_file(ri "${norpath_item}" ${exepath} ${dirs} NO_DEFAULT_PATH)
+ find_file(ri "${norpath_item}" ${dirs} ${${key}_RPATHS} NO_DEFAULT_PATH)
if(ri)
- #message(STATUS "info: 'find_file' in exepath/dirs (${ri})")
+ #message(STATUS "info: 'find_file' in exepath/rpaths/dirs (${ri})")
set(resolved 1)
set(resolved_item "${ri}")
set(ri "ri-NOTFOUND")
@@ -436,7 +439,7 @@ function(gp_resolve_item context item exepath dirs resolved_item_var)
# by whatever logic they choose:
#
if(COMMAND gp_resolve_item_override)
- gp_resolve_item_override("${context}" "${item}" "${exepath}" "${dirs}" resolved_item resolved)
+ gp_resolve_item_override("${context}" "${item}" "${executable}" "${dirs}" resolved_item resolved)
endif()
if(NOT resolved)
@@ -459,7 +462,7 @@ warning: cannot resolve item '${item}'
#
# context='${context}'
# item='${item}'
-# exepath='${exepath}'
+# executable='${executable}'
# dirs='${dirs}'
# resolved_item_var='${resolved_item_var}'
#******************************************************************************
@@ -470,7 +473,7 @@ warning: cannot resolve item '${item}'
endfunction()
-function(gp_resolved_file_type original_file file exepath dirs type_var)
+function(gp_resolved_file_type original_file file executable dirs type_var)
#message(STATUS "**")
if(NOT IS_ABSOLUTE "${original_file}")
@@ -489,7 +492,7 @@ function(gp_resolved_file_type original_file file exepath dirs type_var)
if(NOT is_embedded)
if(NOT IS_ABSOLUTE "${file}")
- gp_resolve_item("${original_file}" "${file}" "${exepath}" "${dirs}" resolved_file)
+ gp_resolve_item("${original_file}" "${file}" "${executable}" "${dirs}" resolved_file)
endif()
string(TOLOWER "${original_file}" original_lower)
@@ -595,21 +598,19 @@ function(gp_resolved_file_type original_file file exepath dirs type_var)
endfunction()
-function(gp_file_type original_file file type_var)
+function(gp_file_type original_file file executable type_var)
if(NOT IS_ABSOLUTE "${original_file}")
message(STATUS "warning: gp_file_type expects absolute full path for first arg original_file")
endif()
- get_filename_component(exepath "${original_file}" PATH)
-
set(type "")
- gp_resolved_file_type("${original_file}" "${file}" "${exepath}" "" type)
+ gp_resolved_file_type("${original_file}" "${file}" "${executable}" "" type)
set(${type_var} "${type}" PARENT_SCOPE)
endfunction()
-function(get_prerequisites target prerequisites_var exclude_system recurse exepath dirs)
+function(get_prerequisites target prerequisites_var exclude_system recurse executable dirs)
set(verbose 0)
set(eol_char "E")
@@ -738,6 +739,7 @@ function(get_prerequisites target prerequisites_var exclude_system recurse exepa
if("${gp_tool}" STREQUAL "ldd")
set(old_ld_env "$ENV{LD_LIBRARY_PATH}")
+ get_filename_component(exepath "${executable}" PATH)
set(new_ld_env "${exepath}")
foreach(dir ${dirs})
set(new_ld_env "${new_ld_env}:${dir}")
@@ -834,7 +836,7 @@ function(get_prerequisites target prerequisites_var exclude_system recurse exepa
if(add_item AND ${exclude_system})
set(type "")
- gp_resolved_file_type("${target}" "${item}" "${exepath}" "${dirs}" type)
+ gp_resolved_file_type("${target}" "${item}" "${executable}" "${dirs}" type)
if("${type}" STREQUAL "system")
set(add_item 0)
@@ -855,7 +857,7 @@ function(get_prerequisites target prerequisites_var exclude_system recurse exepa
# that the analysis tools can simply accept it as input.
#
if(NOT list_length_before_append EQUAL list_length_after_append)
- gp_resolve_item("${target}" "${item}" "${exepath}" "${dirs}" resolved_item)
+ gp_resolve_item("${target}" "${item}" "${executable}" "${dirs}" resolved_item)
set(unseen_prereqs ${unseen_prereqs} "${resolved_item}")
endif()
endif()
@@ -874,7 +876,7 @@ function(get_prerequisites target prerequisites_var exclude_system recurse exepa
if(${recurse})
set(more_inputs ${unseen_prereqs})
foreach(input ${more_inputs})
- get_prerequisites("${input}" ${prerequisites_var} ${exclude_system} ${recurse} "${exepath}" "${dirs}")
+ get_prerequisites("${input}" ${prerequisites_var} ${exclude_system} ${recurse} "${executable}" "${dirs}")
endforeach()
endif()
@@ -911,7 +913,7 @@ function(list_prerequisites target)
get_filename_component(exepath "${target}" PATH)
set(prereqs "")
- get_prerequisites("${target}" prereqs ${exclude_system} ${all} "${exepath}" "")
+ get_prerequisites("${target}" prereqs ${exclude_system} ${all} "${target}" "")
if(print_target)
message(STATUS "File '${target}' depends on:")
@@ -925,7 +927,7 @@ function(list_prerequisites target)
endif()
if(print_prerequisite_type)
- gp_file_type("${target}" "${d}" type)
+ gp_file_type("${target}" "${d}" "" type)
set(type_str " (${type})")
endif()
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=195ec6b3fee0b58aad049ef29b1f7ef4ec5b43bd
commit 195ec6b3fee0b58aad049ef29b1f7ef4ec5b43bd
Author: Adam Strzelecki <ono at java.pl>
AuthorDate: Thu Sep 4 15:11:42 2014 +0200
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Sep 5 08:28:58 2014 -0400
GetPrerequisites: Make sure dyld placeholders are prefixes
Mac OS X dyld placeholders should be always prefixes, otherwise this can lead
to some undefined behavior.
diff --git a/Modules/GetPrerequisites.cmake b/Modules/GetPrerequisites.cmake
index 05c2edb..49443e3 100644
--- a/Modules/GetPrerequisites.cmake
+++ b/Modules/GetPrerequisites.cmake
@@ -329,7 +329,7 @@ function(gp_resolve_item context item exepath dirs resolved_item_var)
endif()
if(NOT resolved)
- if(item MATCHES "@executable_path")
+ if(item MATCHES "^@executable_path")
#
# @executable_path references are assumed relative to exepath
#
@@ -347,7 +347,7 @@ function(gp_resolve_item context item exepath dirs resolved_item_var)
endif()
if(NOT resolved)
- if(item MATCHES "@loader_path")
+ if(item MATCHES "^@loader_path")
#
# @loader_path references are assumed relative to the
# PATH of the given "context" (presumably another library)
@@ -367,7 +367,7 @@ function(gp_resolve_item context item exepath dirs resolved_item_var)
endif()
if(NOT resolved)
- if(item MATCHES "@rpath")
+ if(item MATCHES "^@rpath")
#
# @rpath references are relative to the paths built into the binaries with -rpath
# We handle this case like we do for other Unixes
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=02dfaa312c22d77bcba24bba7768bb00b956a735
commit 02dfaa312c22d77bcba24bba7768bb00b956a735
Author: Adam Strzelecki <ono at java.pl>
AuthorDate: Thu Sep 4 15:11:41 2014 +0200
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Sep 5 08:28:58 2014 -0400
BundleUtilities: Use 'find' on UNIX for fast executable lookup
It makes whole executable process quicker on UNIX, especially for large bundles
containing many files, since using find narrows results to only files having
executable flags then all further tests follow.
diff --git a/Modules/BundleUtilities.cmake b/Modules/BundleUtilities.cmake
index 0046c97..7e2b173 100644
--- a/Modules/BundleUtilities.cmake
+++ b/Modules/BundleUtilities.cmake
@@ -378,7 +378,24 @@ endfunction()
function(get_bundle_all_executables bundle exes_var)
set(exes "")
- file(GLOB_RECURSE file_list "${bundle}/*")
+ if(UNIX)
+ find_program(find_cmd "find")
+ mark_as_advanced(find_cmd)
+ endif()
+
+ # find command is much quicker than checking every file one by one on Unix
+ # which can take long time for large bundles, and since anyway we expect
+ # executable to have execute flag set we can narrow the list much quicker.
+ if(find_cmd)
+ execute_process(COMMAND "${find_cmd}" "${bundle}" -type f -perm +0111
+ OUTPUT_VARIABLE file_list
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ )
+ string(REPLACE "\n" ";" file_list ${file_list})
+ else()
+ file(GLOB_RECURSE file_list "${bundle}/*")
+ endif()
+
foreach(f ${file_list})
is_file_executable("${f}" is_executable)
if(is_executable)
-----------------------------------------------------------------------
Summary of changes:
Modules/BundleUtilities.cmake | 220 +++++++++++++++++++++++++---------------
Modules/GetPrerequisites.cmake | 54 +++++-----
Source/QtDialog/CMakeLists.txt | 28 ++++-
3 files changed, 192 insertions(+), 110 deletions(-)
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list