[Cmake-commits] [cmake-commits] hoffman committed BundleUtilities.cmake NONE 1.1.2.2 CPackRPM.cmake 1.7 1.7.2.1 FindBoost.cmake 1.4.2.6 1.4.2.7 FindCurses.cmake 1.10.2.4 1.10.2.5 FindQt4.cmake 1.96.2.14 1.96.2.15 GetPrerequisites.cmake 1.1.2.1 1.1.2.2
cmake-commits at cmake.org
cmake-commits at cmake.org
Mon Sep 22 10:05:19 EDT 2008
Update of /cvsroot/CMake/CMake/Modules
In directory public:/mounts/ram/cvs-serv24355/Modules
Modified Files:
Tag: CMake-2-6
CPackRPM.cmake FindBoost.cmake FindCurses.cmake FindQt4.cmake
GetPrerequisites.cmake
Added Files:
Tag: CMake-2-6
BundleUtilities.cmake
Log Message:
ENH: merge in changes for RC 5
Index: FindCurses.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/FindCurses.cmake,v
retrieving revision 1.10.2.4
retrieving revision 1.10.2.5
diff -C 2 -d -r1.10.2.4 -r1.10.2.5
*** FindCurses.cmake 13 Jun 2008 12:55:15 -0000 1.10.2.4
--- FindCurses.cmake 22 Sep 2008 14:05:16 -0000 1.10.2.5
***************
*** 37,44 ****
IF(CURSES_CURSES_LIBRARY AND CURSES_NEED_NCURSES)
INCLUDE(CheckLibraryExists)
! CHECK_LIBRARY_EXISTS("${CURSES_CURSES_LIBRARY}" wsyncup "" CURSES_CURSES_HAS_WSYNCUP)
IF(CURSES_NCURSES_LIBRARY AND NOT CURSES_CURSES_HAS_WSYNCUP)
! CHECK_LIBRARY_EXISTS("${CURSES_NCURSES_LIBRARY}" wsyncup "" CURSES_NCURSES_HAS_WSYNCUP)
IF( CURSES_NCURSES_HAS_WSYNCUP)
SET(CURSES_USE_NCURSES TRUE)
--- 37,46 ----
IF(CURSES_CURSES_LIBRARY AND CURSES_NEED_NCURSES)
INCLUDE(CheckLibraryExists)
! CHECK_LIBRARY_EXISTS("${CURSES_CURSES_LIBRARY}"
! wsyncup "" CURSES_CURSES_HAS_WSYNCUP)
IF(CURSES_NCURSES_LIBRARY AND NOT CURSES_CURSES_HAS_WSYNCUP)
! CHECK_LIBRARY_EXISTS("${CURSES_NCURSES_LIBRARY}"
! wsyncup "" CURSES_NCURSES_HAS_WSYNCUP)
IF( CURSES_NCURSES_HAS_WSYNCUP)
SET(CURSES_USE_NCURSES TRUE)
***************
*** 57,62 ****
# for compatibility with older FindCurses.cmake this has to be in the cache
# FORCE must not be used since this would break builds which preload a cache wqith these variables set
! SET(CURSES_INCLUDE_PATH "${CURSES_CURSES_H_PATH}" CACHE FILEPATH "The curses include path")
! SET(CURSES_LIBRARY "${CURSES_CURSES_LIBRARY}" CACHE FILEPATH "The curses library")
ELSE(NOT CURSES_USE_NCURSES)
# we need to find ncurses
--- 59,66 ----
# for compatibility with older FindCurses.cmake this has to be in the cache
# FORCE must not be used since this would break builds which preload a cache wqith these variables set
! SET(CURSES_INCLUDE_PATH "${CURSES_CURSES_H_PATH}"
! CACHE FILEPATH "The curses include path")
! SET(CURSES_LIBRARY "${CURSES_CURSES_LIBRARY}"
! CACHE FILEPATH "The curses library")
ELSE(NOT CURSES_USE_NCURSES)
# we need to find ncurses
***************
*** 67,79 ****
FIND_FILE(CURSES_HAVE_NCURSES_NCURSES_H ncurses/ncurses.h)
FIND_FILE(CURSES_HAVE_NCURSES_CURSES_H ncurses/curses.h)
! FIND_FILE(CURSES_HAVE_CURSES_H curses.h HINTS "${_cursesParentDir}/include")
! FIND_PATH(CURSES_NCURSES_INCLUDE_PATH ncurses.h ncurses/ncurses.h ncurses/curses.h)
! FIND_PATH(CURSES_NCURSES_INCLUDE_PATH curses.h HINTS "${_cursesParentDir}/include")
# for compatibility with older FindCurses.cmake this has to be in the cache
! # FORCE must not be used since this would break builds which preload a cache wqith these variables set
! SET(CURSES_INCLUDE_PATH "${CURSES_NCURSES_INCLUDE_PATH}" CACHE FILEPATH "The curses include path")
! SET(CURSES_LIBRARY "${CURSES_NCURSES_LIBRARY}" CACHE FILEPATH "The curses library")
ENDIF(NOT CURSES_USE_NCURSES)
--- 71,95 ----
FIND_FILE(CURSES_HAVE_NCURSES_NCURSES_H ncurses/ncurses.h)
FIND_FILE(CURSES_HAVE_NCURSES_CURSES_H ncurses/curses.h)
! FIND_FILE(CURSES_HAVE_CURSES_H curses.h
! HINTS "${_cursesParentDir}/include")
! FIND_PATH(CURSES_NCURSES_INCLUDE_PATH ncurses.h ncurses/ncurses.h
! ncurses/curses.h)
! FIND_PATH(CURSES_NCURSES_INCLUDE_PATH curses.h
! HINTS "${_cursesParentDir}/include")
# for compatibility with older FindCurses.cmake this has to be in the cache
! # FORCE must not be used since this would break builds which preload
! # a cache wqith these variables set
! # only put ncurses include and library into
! # variables if they are found
! IF(CURSES_NCURSES_INCLUDE_PATH AND CURSES_NCURSES_LIBRARY)
!
! SET(CURSES_INCLUDE_PATH "${CURSES_NCURSES_INCLUDE_PATH}"
! CACHE FILEPATH "The curses include path")
! SET(CURSES_LIBRARY "${CURSES_NCURSES_LIBRARY}"
! CACHE FILEPATH "The curses library")
! ENDIF(CURSES_NCURSES_INCLUDE_PATH AND CURSES_NCURSES_LIBRARY)
!
ENDIF(NOT CURSES_USE_NCURSES)
***************
*** 87,93 ****
# for compatibility with older FindCurses.cmake this has to be in the cache
! # FORCE must not be used since this would break builds which preload a cache wqith these variables set
! SET(FORM_LIBRARY "${CURSES_FORM_LIBRARY}" CACHE FILEPATH "The curses form library")
!
# Need to provide the *_LIBRARIES
--- 103,110 ----
# for compatibility with older FindCurses.cmake this has to be in the cache
! # FORCE must not be used since this would break builds which preload a cache
! # qith these variables set
! SET(FORM_LIBRARY "${CURSES_FORM_LIBRARY}"
! CACHE FILEPATH "The curses form library")
# Need to provide the *_LIBRARIES
***************
*** 108,112 ****
# all listed variables are TRUE
INCLUDE(FindPackageHandleStandardArgs)
! FIND_PACKAGE_HANDLE_STANDARD_ARGS(Curses DEFAULT_MSG CURSES_LIBRARY CURSES_INCLUDE_PATH)
MARK_AS_ADVANCED(
--- 125,130 ----
# all listed variables are TRUE
INCLUDE(FindPackageHandleStandardArgs)
! FIND_PACKAGE_HANDLE_STANDARD_ARGS(Curses DEFAULT_MSG
! CURSES_LIBRARY CURSES_INCLUDE_PATH)
MARK_AS_ADVANCED(
Index: FindQt4.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/FindQt4.cmake,v
retrieving revision 1.96.2.14
retrieving revision 1.96.2.15
diff -C 2 -d -r1.96.2.14 -r1.96.2.15
*** FindQt4.cmake 3 Sep 2008 13:43:16 -0000 1.96.2.14
--- FindQt4.cmake 22 Sep 2008 14:05:16 -0000 1.96.2.15
***************
*** 104,110 ****
# the suffix .xml appended.
#
! # macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ... ts_files ... )
# out: qm_files
# in: directories sources ts_files
# generates commands to create .ts (vie lupdate) and .qm
# (via lrelease) - files from directories and/or sources. The ts files are
--- 104,113 ----
# the suffix .xml appended.
#
! # macro QT4_CREATE_TRANSLATION( qm_files directories ... sources ...
! # ts_files ... OPTIONS ...)
# out: qm_files
# in: directories sources ts_files
+ # options: flags to pass to lupdate, such as -extensions to specify
+ # extensions for a directory scan.
# generates commands to create .ts (vie lupdate) and .qm
# (via lrelease) - files from directories and/or sources. The ts files are
***************
*** 1291,1297 ****
MACRO(QT4_CREATE_TRANSLATION _qm_files)
SET(_my_sources)
SET(_my_tsfiles)
! FOREACH (_file ${ARGN})
GET_FILENAME_COMPONENT(_ext ${_file} EXT)
GET_FILENAME_COMPONENT(_abs_FILE ${_file} ABSOLUTE)
--- 1294,1303 ----
MACRO(QT4_CREATE_TRANSLATION _qm_files)
+ QT4_EXTRACT_OPTIONS(_lupdate_files _lupdate_options ${ARGN})
+ MESSAGE("lupdate_files ${_lupdate_files}")
+ MESSAGE("lupdate_options ${_lupdate_options}")
SET(_my_sources)
SET(_my_tsfiles)
! FOREACH (_file ${_lupdate_files})
GET_FILENAME_COMPONENT(_ext ${_file} EXT)
GET_FILENAME_COMPONENT(_abs_FILE ${_file} ABSOLUTE)
***************
*** 1305,1309 ****
ADD_CUSTOM_COMMAND(OUTPUT ${_ts_file}
COMMAND ${QT_LUPDATE_EXECUTABLE}
! ARGS ${_my_sources} -ts ${_ts_file}
DEPENDS ${_my_sources})
ENDFOREACH(_ts_file)
--- 1311,1315 ----
ADD_CUSTOM_COMMAND(OUTPUT ${_ts_file}
COMMAND ${QT_LUPDATE_EXECUTABLE}
! ARGS ${_lupdate_options} ${_my_sources} -ts ${_ts_file}
DEPENDS ${_my_sources})
ENDFOREACH(_ts_file)
Index: CPackRPM.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/CPackRPM.cmake,v
retrieving revision 1.7
retrieving revision 1.7.2.1
diff -C 2 -d -r1.7 -r1.7.2.1
*** CPackRPM.cmake 25 Feb 2008 19:23:24 -0000 1.7
--- CPackRPM.cmake 22 Sep 2008 14:05:16 -0000 1.7.2.1
***************
*** 69,77 ****
# CPACK_RPM_PACKAGE_ARCHITECTURE (optional)
! IF(NOT CPACK_RPM_PACKAGE_ARCHITECTURE)
! # FIXME This should be obtained through 'arch' command
! # but is it --really necessary-- ?
! SET(CPACK_RPM_PACKAGE_ARCHITECTURE i386)
! ENDIF(NOT CPACK_RPM_PACKAGE_ARCHITECTURE)
# CPACK_RPM_PACKAGE_RELEASE
--- 69,80 ----
# CPACK_RPM_PACKAGE_ARCHITECTURE (optional)
! IF(CPACK_RPM_PACKAGE_ARCHITECTURE)
! SET(TMP_RPM_BUILDARCH "Buildarch: ${CPACK_RPM_PACKAGE_ARCHITECTURE}")
! IF(CPACK_RPM_PACKAGE_DEBUG)
! MESSAGE("CPackRPM:Debug: using user-specified build arch = ${CPACK_RPM_PACKAGE_ARCHITECTURE}")
! ENDIF(CPACK_RPM_PACKAGE_DEBUG)
! ELSE(CPACK_RPM_PACKAGE_ARCHITECTURE)
! SET(TMP_RPM_BUILDARCH "")
! ENDIF(CPACK_RPM_PACKAGE_ARCHITECTURE)
# CPACK_RPM_PACKAGE_RELEASE
***************
*** 107,112 ****
# CPACK_RPM_PACKAGE_SOURCE
! # The name of the source tarball in case we generate
! # a source RPM
# CPACK_RPM_PACKAGE_DESCRIPTION
--- 110,114 ----
# CPACK_RPM_PACKAGE_SOURCE
! # The name of the source tarball in case we generate a source RPM
# CPACK_RPM_PACKAGE_DESCRIPTION
***************
*** 125,128 ****
--- 127,146 ----
ENDIF (NOT CPACK_RPM_PACKAGE_DESCRIPTION)
+ # CPACK_RPM_SPEC_INSTALL_POST
+ # May be used to define a RPM post intallation script
+ # for example setting it to "/bin/true" may prevent
+ # rpmbuild from stripping binaries.
+ IF(CPACK_RPM_SPEC_INSTALL_POST)
+ SET(TMP_RPM_SPEC_INSTALL_POST "%define __spec_install_post ${CPACK_RPM_SPEC_INSTALL_POST}")
+ ENDIF(CPACK_RPM_SPEC_INSTALL_POST)
+
+ # CPACK_RPM_SPEC_MORE_DEFINE
+ # This is a generated spec rpm file spaceholder
+ IF(CPACK_RPM_SPEC_MORE_DEFINE)
+ IF(CPACK_RPM_PACKAGE_DEBUG)
+ MESSAGE("CPackRPM:Debug: User defined more define spec line specified:\n ${CPACK_RPM_SPEC_MORE_DEFINE}")
+ ENDIF(CPACK_RPM_PACKAGE_DEBUG)
+ ENDIF(CPACK_RPM_SPEC_MORE_DEFINE)
+
# CPACK_RPM_USER_BINARY_SPECFILE
# FIXME when this is set then CPack should us the
***************
*** 131,135 ****
# Now we may create the RPM build tree structure
SET(CPACK_RPM_ROOTDIR "${CPACK_TOPLEVEL_DIRECTORY}")
! MESSAGE(STATUS "CPackRPM:: Using CPACK_RPM_ROOTDIR=${CPACK_RPM_ROOTDIR}")
# Prepare RPM build tree
FILE(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR})
--- 149,153 ----
# Now we may create the RPM build tree structure
SET(CPACK_RPM_ROOTDIR "${CPACK_TOPLEVEL_DIRECTORY}")
! MESSAGE(STATUS "CPackRPM:Debug: Using CPACK_RPM_ROOTDIR=${CPACK_RPM_ROOTDIR}")
# Prepare RPM build tree
FILE(MAKE_DIRECTORY ${CPACK_RPM_ROOTDIR})
***************
*** 158,170 ****
# No User specified spec file generate a valid one using var values
IF(CPACK_RPM_PACKAGE_DEBUG)
! MESSAGE("CPackRPM:: CPACK_TOPLEVEL_DIRECTORY = ${CPACK_TOPLEVEL_DIRECTORY}")
! MESSAGE("CPackRPM:: CPACK_TOPLEVEL_TAG = ${CPACK_TOPLEVEL_TAG}")
! MESSAGE("CPackRPM:: CPACK_TEMPORARY_DIRECTORY= ${PACK_TEMPORARY_DIRECTORY}")
! MESSAGE("CPackRPM:: CPACK_OUTPUT_FILE_NAME = ${CPACK_OUTPUT_FILE_NAME}")
! MESSAGE("CPackRPM:: CPACK_OUTPUT_FILE_PATH = ${CPACK_OUTPUT_FILE_PATH}")
! MESSAGE("CPackRPM:: CPACK_PACKAGE_FILE_NAME = ${CPACK_PACKAGE_FILE_NAME}")
! MESSAGE("CPackRPM:: CPACK_RPM_BINARY_SPECFILE = ${CPACK_RPM_BINARY_SPECFILE}")
! MESSAGE("CPackRPM:: CPACK_PACKAGE_INSTALL_DIRECTORY = ${PACK_PACKAGE_INSTALL_DIRECTORY}")
! MESSAGE("CPackRPM ::CPACK_TEMPORARY_PACKAGE_FILE_NAME = ${CPACK_TEMPORARY_PACKAGE_FILE_NAME}")
ENDIF(CPACK_RPM_PACKAGE_DEBUG)
FILE(WRITE ${CPACK_RPM_BINARY_SPECFILE}
--- 176,189 ----
# No User specified spec file generate a valid one using var values
IF(CPACK_RPM_PACKAGE_DEBUG)
! MESSAGE("CPackRPM:Debug: CPACK_TOPLEVEL_DIRECTORY = ${CPACK_TOPLEVEL_DIRECTORY}")
! MESSAGE("CPackRPM:Debug: CPACK_TOPLEVEL_TAG = ${CPACK_TOPLEVEL_TAG}")
! MESSAGE("CPackRPM:Debug: CPACK_TEMPORARY_DIRECTORY = ${PACK_TEMPORARY_DIRECTORY}")
! MESSAGE("CPackRPM:Debug: CPACK_OUTPUT_FILE_NAME = ${CPACK_OUTPUT_FILE_NAME}")
! MESSAGE("CPackRPM:Debug: CPACK_OUTPUT_FILE_PATH = ${CPACK_OUTPUT_FILE_PATH}")
! MESSAGE("CPackRPM:Debug: CPACK_PACKAGE_FILE_NAME = ${CPACK_PACKAGE_FILE_NAME}")
! MESSAGE("CPackRPM:Debug: CPACK_RPM_BINARY_SPECFILE = ${CPACK_RPM_BINARY_SPECFILE}")
! MESSAGE("CPackRPM:Debug: CPACK_PACKAGE_INSTALL_DIRECTORY = ${PACK_PACKAGE_INSTALL_DIRECTORY}")
! MESSAGE("CPackRPM:Debug: CPACK_TEMPORARY_PACKAGE_FILE_NAME = ${CPACK_TEMPORARY_PACKAGE_FILE_NAME}")
! MESSAGE("CPackRPM:Debug: CPACK_RPM_SPEC_INSTALL_POST = ${CPACK_RPM_SPEC_INSTALL_POST}")
ENDIF(CPACK_RPM_PACKAGE_DEBUG)
FILE(WRITE ${CPACK_RPM_BINARY_SPECFILE}
***************
*** 178,181 ****
--- 197,201 ----
Group: ${CPACK_RPM_PACKAGE_GROUP}
Vendor: ${CPACK_RPM_PACKAGE_VENDOR}
+ ${TMP_RPM_BUILDARCH}
#%define prefix ${CMAKE_INSTALL_PREFIX}
***************
*** 184,187 ****
--- 204,209 ----
%define _unpackaged_files_terminate_build 0
%define _topdir ${CPACK_RPM_DIRECTORY}
+ ${TMP_RPM_SPEC_INSTALL_POST}
+ ${CPACK_RPM_SPEC_MORE_DEFINE}
%description
***************
*** 207,214 ****
%changelog
* Tue Aug 16 2007 Erk <eric.noulard at gmail.com>
Generated by CPack RPM Generator and associated macros
")
-
ENDIF(CPACK_RPM_USER_BINARY_SPECFILE)
--- 229,237 ----
%changelog
+ * Mon Aug 25 2008 Erk <eric.noulard at gmail.com>
+ Update generator to handle optional post-install
* Tue Aug 16 2007 Erk <eric.noulard at gmail.com>
Generated by CPack RPM Generator and associated macros
")
ENDIF(CPACK_RPM_USER_BINARY_SPECFILE)
***************
*** 221,224 ****
--- 244,252 ----
ERROR_FILE "${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild.err"
OUTPUT_FILE "${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild.out")
+ IF(CPACK_RPM_PACKAGE_DEBUG)
+ MESSAGE("CPackRPM:Debug: You may consult rpmbuild logs in: ")
+ MESSAGE("CPackRPM:Debug: - ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild.err")
+ MESSAGE("CPackRPM:Debug: - ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild.out")
+ ENDIF(CPACK_RPM_PACKAGE_DEBUG)
ELSE(RPMBUILD_EXECUTABLE)
IF(ALIEN_EXECUTABLE)
--- NEW FILE: BundleUtilities.cmake ---
# BundleUtilities.cmake
#
# A collection of CMake utility functions useful for dealing with .app bundles
# on the Mac and bundle-like directories on any OS.
#
# The following functions are provided by this script:
# get_bundle_main_executable
# get_dotapp_dir
# get_bundle_and_executable
# get_bundle_all_executables
# get_item_key
# clear_bundle_keys
# set_bundle_key_values
# get_bundle_keys
# copy_resolved_item_into_bundle
# fixup_bundle_item
# fixup_bundle
# copy_and_fixup_bundle
# verify_bundle_prerequisites
# verify_bundle_symlinks
# verify_app
#
# Requires CMake 2.6 or greater because it uses function, break and
# PARENT_SCOPE. Also depends on GetPrerequisites.cmake.
# The functions defined in this file depend on the get_prerequisites function
# (and possibly others) found in:
#
get_filename_component(BundleUtilities_cmake_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
include("${BundleUtilities_cmake_dir}/GetPrerequisites.cmake")
# get_bundle_main_executable
#
# The result will be the full path name of the bundle's main executable file
# or an "error:" prefixed string if it could not be determined.
#
function(get_bundle_main_executable bundle result_var)
set(result "error: '${bundle}/Contents/Info.plist' file does not exist")
if(EXISTS "${bundle}/Contents/Info.plist")
set(result "error: no CFBundleExecutable in '${bundle}/Contents/Info.plist' file")
set(line_is_main_executable 0)
set(bundle_executable "")
# Read Info.plist as a list of lines:
#
set(eol_char "E")
file(READ "${bundle}/Contents/Info.plist" info_plist)
string(REGEX REPLACE ";" "\\\\;" info_plist "${info_plist}")
string(REGEX REPLACE "\n" "${eol_char};" info_plist "${info_plist}")
# Scan the lines for "<key>CFBundleExecutable</key>" - the line after that
# is the name of the main executable.
#
foreach(line ${info_plist})
if(line_is_main_executable)
string(REGEX REPLACE "^.*<string>(.*)</string>.*$" "\\1" bundle_executable "${line}")
break()
endif(line_is_main_executable)
if(line MATCHES "^.*<key>CFBundleExecutable</key>.*$")
set(line_is_main_executable 1)
endif(line MATCHES "^.*<key>CFBundleExecutable</key>.*$")
endforeach(line)
if(NOT "${bundle_executable}" STREQUAL "")
if(EXISTS "${bundle}/Contents/MacOS/${bundle_executable}")
set(result "${bundle}/Contents/MacOS/${bundle_executable}")
else(EXISTS "${bundle}/Contents/MacOS/${bundle_executable}")
# Ultimate goal:
# If not in "Contents/MacOS" then scan the bundle for matching files. If
# there is only one executable file that matches, then use it, otherwise
# it's an error...
#
#file(GLOB_RECURSE file_list "${bundle}/${bundle_executable}")
# But for now, pragmatically, it's an error. Expect the main executable
# for the bundle to be in Contents/MacOS, it's an error if it's not:
#
set(result "error: '${bundle}/Contents/MacOS/${bundle_executable}' does not exist")
endif(EXISTS "${bundle}/Contents/MacOS/${bundle_executable}")
endif(NOT "${bundle_executable}" STREQUAL "")
else(EXISTS "${bundle}/Contents/Info.plist")
#
# More inclusive technique... (This one would work on Windows and Linux
# too, if a developer followed the typical Mac bundle naming convention...)
#
# If there is no Info.plist file, try to find an executable with the same
# base name as the .app directory:
#
endif(EXISTS "${bundle}/Contents/Info.plist")
set(${result_var} "${result}" PARENT_SCOPE)
endfunction(get_bundle_main_executable)
# get_dotapp_dir
#
# 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 return a dir at the same
# level as the executable, named with the executable's base name and ending with
# ".app"
#
# The returned directory may or may not exist.
#
function(get_dotapp_dir exe dotapp_dir_var)
set(s "${exe}")
set(has_dotapp_parent 0)
if(s MATCHES "^.*/.*\\.app/.*$")
set(has_dotapp_parent 1)
endif(s MATCHES "^.*/.*\\.app/.*$")
set(done 0)
while(NOT ${done})
get_filename_component(snamewe "${s}" NAME_WE)
get_filename_component(sname "${s}" NAME)
get_filename_component(sdir "${s}" PATH)
if(has_dotapp_parent)
# If there is a ".app" parent directory,
# ascend until we hit it:
# (typical of a Mac bundle executable)
#
set(s "${sdir}")
if(sname MATCHES "\\.app$")
set(done 1)
set(dotapp_dir "${sdir}/${sname}")
endif(sname MATCHES "\\.app$")
else(has_dotapp_parent)
# Otherwise use a directory named the same
# as the exe, but with a ".app" extension:
# (typical of a non-bundle executable on Mac, Windows or Linux)
#
set(done 1)
set(dotapp_dir "${sdir}/${snamewe}.app")
endif(has_dotapp_parent)
endwhile(NOT ${done})
set(${dotapp_dir_var} "${dotapp_dir}" PARENT_SCOPE)
endfunction(get_dotapp_dir)
# get_bundle_and_executable
#
# Takes either a ".app" directory name or the name of an executable
# nested inside a ".app" directory and returns the path to the ".app"
# directory in ${bundle_var} and the path to its main executable in
# ${executable_var}
#
function(get_bundle_and_executable app bundle_var executable_var valid_var)
set(valid 0)
if(EXISTS "${app}")
# Is it a directory ending in .app?
if(IS_DIRECTORY "${app}")
if(app MATCHES "\\.app$")
get_bundle_main_executable("${app}" executable)
if(EXISTS "${app}" AND EXISTS "${executable}")
set(${bundle_var} "${app}" PARENT_SCOPE)
set(${executable_var} "${executable}" PARENT_SCOPE)
set(valid 1)
#message(STATUS "info: handled .app directory case...")
else(EXISTS "${app}" AND EXISTS "${executable}")
message(STATUS "warning: *NOT* handled - .app directory case...")
endif(EXISTS "${app}" AND EXISTS "${executable}")
else(app MATCHES "\\.app$")
message(STATUS "warning: *NOT* handled - directory but not .app case...")
endif(app MATCHES "\\.app$")
else(IS_DIRECTORY "${app}")
# Is it an executable file?
is_file_executable("${app}" is_executable)
if(is_executable)
get_dotapp_dir("${app}" dotapp_dir)
if(EXISTS "${dotapp_dir}" AND EXISTS "${app}")
set(${bundle_var} "${dotapp_dir}" PARENT_SCOPE)
set(${executable_var} "${app}" PARENT_SCOPE)
set(valid 1)
#message(STATUS "info: handled executable file case...")
else(EXISTS "${dotapp_dir}" AND EXISTS "${app}")
message(STATUS "warning: *NOT* handled - executable file case...")
endif(EXISTS "${dotapp_dir}" AND EXISTS "${app}")
else(is_executable)
message(STATUS "warning: *NOT* handled - not .app dir, not executable file...")
endif(is_executable)
endif(IS_DIRECTORY "${app}")
else(EXISTS "${app}")
message(STATUS "warning: *NOT* handled - directory/file does not exist...")
endif(EXISTS "${app}")
if(NOT valid)
set(${bundle_var} "error: not a bundle" PARENT_SCOPE)
set(${executable_var} "error: not a bundle" PARENT_SCOPE)
endif(NOT valid)
set(${valid_var} ${valid} PARENT_SCOPE)
endfunction(get_bundle_and_executable)
# get_bundle_all_executables
#
# Scans the given bundle recursively for all executable files and accumulates
# them into a variable.
#
function(get_bundle_all_executables bundle exes_var)
set(exes "")
file(GLOB_RECURSE file_list "${bundle}/*")
foreach(f ${file_list})
is_file_executable("${f}" is_executable)
if(is_executable)
set(exes ${exes} "${f}")
endif(is_executable)
endforeach(f)
set(${exes_var} "${exes}" PARENT_SCOPE)
endfunction(get_bundle_all_executables)
# get_item_key
#
# Given a file (item) name, generate a key that should be unique considering the set of
# libraries that need copying or fixing up to make a bundle standalone. This is
# essentially the file name including extension with "." replaced by "_"
#
# This key is used as a prefix for CMake variables so that we can associate a set
# of variables with a given item based on its key.
#
function(get_item_key item key_var)
get_filename_component(item_name "${item}" NAME)
string(REGEX REPLACE "\\." "_" ${key_var} "${item_name}")
set(${key_var} ${${key_var}} PARENT_SCOPE)
endfunction(get_item_key)
# clear_bundle_keys
#
# Loop over the list of keys, clearing all the variables associated with each
# key. After the loop, clear the list of keys itself.
#
# Caller of get_bundle_keys should call clear_bundle_keys when done with list
# of keys.
#
function(clear_bundle_keys keys_var)
foreach(key ${${keys_var}})
set(${key}_ITEM PARENT_SCOPE)
set(${key}_RESOLVED_ITEM PARENT_SCOPE)
set(${key}_DEFAULT_EMBEDDED_PATH PARENT_SCOPE)
set(${key}_EMBEDDED_ITEM PARENT_SCOPE)
set(${key}_RESOLVED_EMBEDDED_ITEM PARENT_SCOPE)
set(${key}_COPYFLAG PARENT_SCOPE)
endforeach(key)
set(${keys_var} PARENT_SCOPE)
endfunction(clear_bundle_keys)
# set_bundle_key_values
#
# Add a key to the list (if necessary) for the given item. If added,
# also set all the variables associated with that key.
#
function(set_bundle_key_values keys_var context item exepath dirs copyflag)
get_filename_component(item_name "${item}" NAME)
get_item_key("${item}" key)
list(LENGTH ${keys_var} length_before)
gp_append_unique(${keys_var} "${key}")
list(LENGTH ${keys_var} length_after)
if(NOT length_before EQUAL length_after)
gp_resolve_item("${context}" "${item}" "${exepath}" "${dirs}" resolved_item)
gp_item_default_embedded_path("${item}" default_embedded_path)
if(item MATCHES "[^/]+\\.framework/")
# For frameworks, construct the name under the embedded path from the
# opening "${item_name}.framework/" to the closing "/${item_name}":
#
string(REGEX REPLACE "^.*(${item_name}.framework/.*/${item_name}).*$" "${default_embedded_path}/\\1" embedded_item "${item}")
else(item MATCHES "[^/]+\\.framework/")
# For other items, just use the same name as the original, but in the
# embedded path:
#
set(embedded_item "${default_embedded_path}/${item_name}")
endif(item MATCHES "[^/]+\\.framework/")
# Replace @executable_path and resolve ".." references:
#
string(REPLACE "@executable_path" "${exepath}" resolved_embedded_item "${embedded_item}")
get_filename_component(resolved_embedded_item "${resolved_embedded_item}" ABSOLUTE)
# *But* -- if we are not copying, then force resolved_embedded_item to be
# the same as resolved_item. In the case of multiple executables in the
# original bundle, using the default_embedded_path results in looking for
# the resolved executable next to the main bundle executable. This is here
# so that exes in the other sibling directories (like "bin") get fixed up
# properly...
#
if(NOT copyflag)
set(resolved_embedded_item "${resolved_item}")
endif(NOT copyflag)
set(${keys_var} ${${keys_var}} PARENT_SCOPE)
set(${key}_ITEM "${item}" PARENT_SCOPE)
set(${key}_RESOLVED_ITEM "${resolved_item}" PARENT_SCOPE)
set(${key}_DEFAULT_EMBEDDED_PATH "${default_embedded_path}" PARENT_SCOPE)
set(${key}_EMBEDDED_ITEM "${embedded_item}" PARENT_SCOPE)
set(${key}_RESOLVED_EMBEDDED_ITEM "${resolved_embedded_item}" PARENT_SCOPE)
set(${key}_COPYFLAG "${copyflag}" PARENT_SCOPE)
else(NOT length_before EQUAL length_after)
#message("warning: item key '${key}' already in the list, subsequent references assumed identical to first")
endif(NOT length_before EQUAL length_after)
endfunction(set_bundle_key_values)
# get_bundle_keys
#
# Loop over all the executable and library files within the bundle (and given as
# extra "${libs}") and accumulate a list of keys representing them. Set values
# associated with each key such that we can loop over all of them and copy
# prerequisite libs into the bundle and then do appropriate install_name_tool
# fixups.
#
function(get_bundle_keys app libs dirs keys_var)
set(${keys_var} PARENT_SCOPE)
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)
# 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}" "${exepath}" "${dirs}" 1)
set(prereqs "")
get_prerequisites("${lib}" prereqs 1 1 "${exepath}" "${dirs}")
foreach(pr ${prereqs})
set_bundle_key_values(${keys_var} "${lib}" "${pr}" "${exepath}" "${dirs}" 1)
endforeach(pr)
endforeach(lib)
# 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.
#
foreach(exe ${exes})
# Add the exe itself to the keys:
#
set_bundle_key_values(${keys_var} "${exe}" "${exe}" "${exepath}" "${dirs}" 0)
# Add each prerequisite to the keys:
#
set(prereqs "")
get_prerequisites("${exe}" prereqs 1 1 "${exepath}" "${dirs}")
foreach(pr ${prereqs})
set_bundle_key_values(${keys_var} "${exe}" "${pr}" "${exepath}" "${dirs}" 1)
endforeach(pr)
endforeach(exe)
# Propagate values to caller's scope:
#
set(${keys_var} ${${keys_var}} PARENT_SCOPE)
foreach(key ${${keys_var}})
set(${key}_ITEM "${${key}_ITEM}" PARENT_SCOPE)
set(${key}_RESOLVED_ITEM "${${key}_RESOLVED_ITEM}" PARENT_SCOPE)
set(${key}_DEFAULT_EMBEDDED_PATH "${${key}_DEFAULT_EMBEDDED_PATH}" PARENT_SCOPE)
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)
endforeach(key)
endif(valid)
endfunction(get_bundle_keys)
# copy_resolved_item_into_bundle
#
# Copy a resolved item into the bundle if necessary. Copy is not necessary if the resolved_item
# is the same as the resolved_embedded_item.
#
function(copy_resolved_item_into_bundle resolved_item resolved_embedded_item)
if("${resolved_item}" STREQUAL "${resolved_embedded_item}")
message(STATUS "warning: resolved_item == resolved_embedded_item - not copying...")
else("${resolved_item}" STREQUAL "${resolved_embedded_item}")
execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}")
endif("${resolved_item}" STREQUAL "${resolved_embedded_item}")
endfunction(copy_resolved_item_into_bundle)
# fixup_bundle_item
#
# Get the direct/non-system prerequisites of the resolved embedded item. For each
# prerequisite, change the way it is referenced to the value of the _EMBEDDED_ITEM
# keyed variable for that prerequisite. (Most likely changing to an "@executable_path"
# style reference.)
#
# Also, change the id of the item being fixed up to its own _EMBEDDED_ITEM value.
#
# Accumulate changes in a local variable and make *one* call to install_name_tool
# at the end of the function with all the changes at once.
#
function(fixup_bundle_item resolved_embedded_item exepath dirs)
# This item's key is "ikey":
#
get_item_key("${resolved_embedded_item}" ikey)
set(prereqs "")
get_prerequisites("${resolved_embedded_item}" prereqs 1 0 "${exepath}" "${dirs}")
set(changes "")
foreach(pr ${prereqs})
# Each referenced item's key is "rkey" in the loop:
#
get_item_key("${pr}" rkey)
if(NOT "${${rkey}_EMBEDDED_ITEM}" STREQUAL "")
set(changes ${changes} "-change" "${pr}" "${${rkey}_EMBEDDED_ITEM}")
else(NOT "${${rkey}_EMBEDDED_ITEM}" STREQUAL "")
message("warning: unexpected reference to '${pr}'")
endif(NOT "${${rkey}_EMBEDDED_ITEM}" STREQUAL "")
endforeach(pr)
# 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}"
)
endfunction(fixup_bundle_item)
# fixup_bundle
#
# Fix up a bundle in-place and make it standalone, such that it can be drag-n-drop
# copied to another machine and run on that machine as long as all of the system
# libraries are compatible.
#
# Gather all the keys for all the executables and libraries in a bundle, and then,
# for each key, copy each prerequisite into the bundle. Then fix each one up according
# to its own list of prerequisites.
#
# Then clear all the keys and call verify_app on the final bundle to ensure that
# it is truly standalone.
#
function(fixup_bundle app libs dirs)
message(STATUS "fixup_bundle")
message(STATUS " app='${app}'")
message(STATUS " libs='${libs}'")
message(STATUS " dirs='${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)
message(STATUS "fixup_bundle: copying...")
list(LENGTH keys n)
math(EXPR n ${n}*2)
set(i 0)
foreach(key ${keys})
math(EXPR i ${i}+1)
if(${${key}_COPYFLAG})
message(STATUS "${i}/${n}: copying '${${key}_RESOLVED_ITEM}'")
else(${${key}_COPYFLAG})
message(STATUS "${i}/${n}: *NOT* copying '${${key}_RESOLVED_ITEM}'")
endif(${${key}_COPYFLAG})
set(show_status 0)
if(show_status)
message(STATUS "key='${key}'")
message(STATUS "item='${${key}_ITEM}'")
message(STATUS "resolved_item='${${key}_RESOLVED_ITEM}'")
message(STATUS "default_embedded_path='${${key}_DEFAULT_EMBEDDED_PATH}'")
message(STATUS "embedded_item='${${key}_EMBEDDED_ITEM}'")
message(STATUS "resolved_embedded_item='${${key}_RESOLVED_EMBEDDED_ITEM}'")
message(STATUS "copyflag='${${key}_COPYFLAG}'")
message(STATUS "")
endif(show_status)
if(${${key}_COPYFLAG})
copy_resolved_item_into_bundle("${${key}_RESOLVED_ITEM}"
"${${key}_RESOLVED_EMBEDDED_ITEM}")
endif(${${key}_COPYFLAG})
endforeach(key)
message(STATUS "fixup_bundle: fixing...")
foreach(key ${keys})
math(EXPR i ${i}+1)
message(STATUS "${i}/${n}: fixing up '${${key}_RESOLVED_EMBEDDED_ITEM}'")
#message(STATUS " exepath='${exepath}'")
fixup_bundle_item("${${key}_RESOLVED_EMBEDDED_ITEM}" "${exepath}" "${dirs}")
endforeach(key)
message(STATUS "fixup_bundle: cleaning up...")
clear_bundle_keys(keys)
message(STATUS "fixup_bundle: verifying...")
verify_app("${app}")
else(valid)
message(STATUS "error: fixup_bundle: not a valid bundle")
endif(valid)
message(STATUS "fixup_bundle: done")
endfunction(fixup_bundle)
# copy_and_fixup_bundle
#
# Makes a copy of the bundle "src" at location "dst" and then fixes up the
# new copied bundle in-place at "dst"...
#
function(copy_and_fixup_bundle src dst libs dirs)
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${src}" "${dst}")
fixup_bundle("${dst}" "${libs}" "${dirs}")
endfunction(copy_and_fixup_bundle)
# verify_bundle_prerequisites
#
# 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.
#
function(verify_bundle_prerequisites bundle 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}/*")
foreach(f ${file_list})
is_file_executable("${f}" is_executable)
if(is_executable)
get_filename_component(exepath "${f}" PATH)
message(STATUS "executable file: ${f}")
math(EXPR count "${count} + 1")
set(prereqs "")
get_prerequisites("${f}" prereqs 1 1 "${exepath}" "")
# "embedded" and "system" prerequisites are fine... anything else means
# the bundle's prerequisites are not verified (i.e., the bundle is not
# really "standalone")
#
set(external_prereqs "")
foreach(p ${prereqs})
set(p_type "")
gp_file_type("${f}" "${p}" p_type)
if (NOT "${p_type}" STREQUAL "embedded" AND NOT "${p_type}" STREQUAL "system")
set(external_prereqs ${external_prereqs} "${p}")
endif (NOT "${p_type}" STREQUAL "embedded" AND NOT "${p_type}" STREQUAL "system")
endforeach(p)
if(external_prereqs)
# Found non-system/non-embedded prerequisites:
set(result 0)
set(info ${info} "non-system/non-embedded prerequisites found:\nf='${f}'\nexternal_prereqs='${external_prereqs}'\n")
endif(external_prereqs)
endif(is_executable)
endforeach(f)
if(result)
set(info "Verified ${count} executable files in '${bundle}'")
endif(result)
set(${result_var} "${result}" PARENT_SCOPE)
set(${info_var} "${info}" PARENT_SCOPE)
endfunction(verify_bundle_prerequisites)
# verify_bundle_symlinks
#
# Verifies that any symlinks found in the bundle point to other files that are
# already also in the bundle... Anything that points to an external file causes
# this function to fail the verification.
#
function(verify_bundle_symlinks bundle result_var info_var)
set(result 1)
set(info "")
set(count 0)
# TODO: implement this function for real...
# Right now, it is just a stub that verifies unconditionally...
set(${result_var} "${result}" PARENT_SCOPE)
set(${info_var} "${info}" PARENT_SCOPE)
endfunction(verify_bundle_symlinks)
# verify_app
#
# Verifies that an application appears valid based on running analysis tools on it.
# Calls message/FATAL_ERROR if the application is not verified.
#
function(verify_app app)
set(verified 0)
set(info "")
get_bundle_and_executable("${app}" bundle executable valid)
message(STATUS "===========================================================================")
message(STATUS "Analyzing app='${app}'")
message(STATUS "bundle='${bundle}'")
message(STATUS "executable='${executable}'")
message(STATUS "valid='${valid}'")
# Verify that the bundle does not have any "external" prerequisites:
#
verify_bundle_prerequisites("${bundle}" verified info)
message(STATUS "verified='${verified}'")
message(STATUS "info='${info}'")
message(STATUS "")
if(verified)
# Verify that the bundle does not have any symlinks to external files:
#
verify_bundle_symlinks("${bundle}" verified info)
message(STATUS "verified='${verified}'")
message(STATUS "info='${info}'")
message(STATUS "")
endif(verified)
if(NOT verified)
message(FATAL_ERROR "error: verify_app failed")
endif(NOT verified)
endfunction(verify_app)
Index: GetPrerequisites.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/GetPrerequisites.cmake,v
retrieving revision 1.1.2.1
retrieving revision 1.1.2.2
diff -C 2 -d -r1.1.2.1 -r1.1.2.2
*** GetPrerequisites.cmake 4 May 2008 22:07:27 -0000 1.1.2.1
--- GetPrerequisites.cmake 22 Sep 2008 14:05:17 -0000 1.1.2.2
***************
*** 13,23 ****
# gp_file_type
# is_file_executable
# get_prerequisites
# list_prerequisites
#
! # Requires CMake 2.5 or greater because it uses function, break, return and
# PARENT_SCOPE.
- #
- cmake_minimum_required(VERSION 2.5 FATAL_ERROR)
--- 13,26 ----
# gp_file_type
# is_file_executable
+ # gp_item_default_embedded_path
+ # (projects can override with gp_item_default_embedded_path_override)
+ # gp_resolve_item
+ # (projects can override with gp_resolve_item_override)
# get_prerequisites
# list_prerequisites
+ # list_prerequisites_by_glob
#
! # Requires CMake 2.6 or greater because it uses function, break, return and
# PARENT_SCOPE.
***************
*** 136,140 ****
# A clause could be added here that uses output or return value of dumpbin
! # to determine ${result_var}. In 95%+ practical cases, the exe|dll name
# match will be sufficient...
#
--- 139,143 ----
# A clause could be added here that uses output or return value of dumpbin
! # to determine ${result_var}. In 99%+? practical cases, the exe|dll name
# match will be sufficient...
#
***************
*** 185,189 ****
! # get_prerequisites target prerequisites_var exclude_system recurse
#
# Get the list of shared library files required by ${target}. The list in
--- 188,356 ----
! # gp_item_default_embedded_path item default_embedded_path_var
! #
! # Return the path that others should refer to the item by when the item
! # is embedded inside a bundle.
! #
! # Override on a per-project basis by providing a project-specific
! # gp_item_default_embedded_path_override function.
! #
! function(gp_item_default_embedded_path item default_embedded_path_var)
! #
! # The assumption here is that all executables in the bundle will be
! # in same-level-directories inside the bundle. The parent directory
! # of an executable inside the bundle should be MacOS or a sibling of
! # MacOS and all embedded paths returned from here will begin with
! # "@executable_path/../" and will work from all executables in all
! # such same-level-directories inside the bundle.
! #
!
! # By default, embed things right next to the main bundle executable:
! #
! set(path "@executable_path/../../Contents/MacOS")
!
! set(overridden 0)
!
! # Embed .dylibs right next to the main bundle executable:
! #
! if(item MATCHES "\\.dylib$")
! set(path "@executable_path/../MacOS")
! set(overridden 1)
! endif(item MATCHES "\\.dylib$")
!
! # Embed frameworks in the embedded "Frameworks" directory (sibling of MacOS):
! #
! if(NOT overridden)
! if(item MATCHES "[^/]+\\.framework/")
! set(path "@executable_path/../Frameworks")
! set(overridden 1)
! endif(item MATCHES "[^/]+\\.framework/")
! endif(NOT overridden)
!
! # Provide a hook so that projects can override the default embedded location of
! # any given library by whatever logic they choose:
! #
! if(COMMAND gp_item_default_embedded_path_override)
! gp_item_default_embedded_path_override("${item}" path)
! endif(COMMAND gp_item_default_embedded_path_override)
!
! set(${default_embedded_path_var} "${path}" PARENT_SCOPE)
! endfunction(gp_item_default_embedded_path)
!
!
! # gp_resolve_item context item exepath dirs resolved_item_var
! #
! # Resolve an item into an existing full path file.
! #
! # Override on a per-project basis by providing a project-specific
! # gp_resolve_item_override function.
! #
! function(gp_resolve_item context item exepath dirs resolved_item_var)
! set(resolved 0)
! set(resolved_item "${item}")
!
! # Is it already resolved?
! #
! if(EXISTS "${resolved_item}")
! set(resolved 1)
! endif(EXISTS "${resolved_item}")
!
! if(NOT resolved)
! if(item MATCHES "@executable_path")
! #
! # @executable_path references are assumed relative to exepath
! #
! string(REPLACE "@executable_path" "${exepath}" ri "${item}")
! get_filename_component(ri "${ri}" ABSOLUTE)
!
! if(EXISTS "${ri}")
! #message(STATUS "info: embedded item exists (${ri})")
! set(resolved 1)
! set(resolved_item "${ri}")
! else(EXISTS "${ri}")
! message(STATUS "info: embedded item does not exist '${ri}'")
! endif(EXISTS "${ri}")
! endif(item MATCHES "@executable_path")
! endif(NOT resolved)
!
! if(NOT resolved)
! if(item MATCHES "@loader_path")
! #
! # @loader_path references are assumed relative to the
! # PATH of the given "context" (presumably another library)
! #
! get_filename_component(contextpath "${context}" PATH)
! string(REPLACE "@loader_path" "${contextpath}" ri "${item}")
! get_filename_component(ri "${ri}" ABSOLUTE)
!
! if(EXISTS "${ri}")
! #message(STATUS "info: embedded item exists (${ri})")
! set(resolved 1)
! set(resolved_item "${ri}")
! else(EXISTS "${ri}")
! message(STATUS "info: embedded item does not exist '${ri}'")
! endif(EXISTS "${ri}")
! endif(item MATCHES "@loader_path")
! endif(NOT resolved)
!
! if(NOT resolved)
! set(ri "ri-NOTFOUND")
! find_file(ri "${item}" ${dirs})
! if(ri)
! #message(STATUS "info: found item in dirs (${ri})")
! set(resolved 1)
! set(resolved_item "${ri}")
! set(ri "ri-NOTFOUND")
! endif(ri)
! endif(NOT resolved)
!
! if(NOT resolved)
! if(item MATCHES "[^/]+\\.framework/")
! set(fw "fw-NOTFOUND")
! find_file(fw "${item}"
! "~/Library/Frameworks"
! "/Library/Frameworks"
! "/System/Library/Frameworks"
! )
! if(fw)
! #message(STATUS "info: found framework (${fw})")
! set(resolved 1)
! set(resolved_item "${fw}")
! set(fw "fw-NOTFOUND")
! endif(fw)
! endif(item MATCHES "[^/]+\\.framework/")
! endif(NOT resolved)
!
! # Using find_program on Windows will find dll files that are in the PATH.
! # (Converting simple file names into full path names if found.)
! #
! if(WIN32)
! if(NOT resolved)
! set(ri "ri-NOTFOUND")
! find_program(ri "${item}" PATHS "${dirs}")
! if(ri)
! set(resolved 1)
! set(resolved_item "${ri}")
! set(ri "ri-NOTFOUND")
! endif(ri)
! endif(NOT resolved)
! endif(WIN32)
!
! # 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)
!
! if(NOT resolved)
! message(STATUS "warning: cannot resolve item '${item}'")
! endif(NOT resolved)
!
! set(${resolved_item_var} "${resolved_item}" PARENT_SCOPE)
! endfunction(gp_resolve_item)
!
!
! # get_prerequisites target prerequisites_var exclude_system recurse dirs
#
# Get the list of shared library files required by ${target}. The list in
***************
*** 202,219 ****
# recursively
#
! # optional ARGV4 (verbose) is 0 or 1: 0 to skip informational message output,
! # 1 to print it
#
! function(get_prerequisites target prerequisites_var exclude_system recurse)
! # set(verbose 0)
! # if(NOT "${ARGV4}" STREQUAL "")
! # message(STATUS "ARGV4='${ARGV4}'")
! # set(verbose "${ARGV4}")
! # endif(NOT "${ARGV4}" STREQUAL "")
! # message(STATUS "verbose='${verbose}'")
set(verbose 0)
-
set(eol_char "E")
# <setup-gp_tool-vars>
#
--- 369,391 ----
# recursively
#
! # exepath 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 standard
! # system locations are also searched: PATH, Framework locations, /usr/lib...
! #
! function(get_prerequisites target prerequisites_var exclude_system recurse exepath dirs)
set(verbose 0)
set(eol_char "E")
+ if(NOT IS_ABSOLUTE "${target}")
+ message("warning: target '${target}' is not absolute...")
+ endif(NOT IS_ABSOLUTE "${target}")
+
+ if(NOT EXISTS "${target}")
+ message("warning: target '${target}' does not exist...")
+ endif(NOT EXISTS "${target}")
+
# <setup-gp_tool-vars>
#
***************
*** 289,293 ****
get_filename_component(gp_cmd_dlls_dir "${gp_cmd_dir}/../../Common7/IDE" ABSOLUTE)
if(EXISTS "${gp_cmd_dlls_dir}")
! set(ENV{PATH} "$ENV{PATH};${gp_cmd_dlls_dir}")
endif(EXISTS "${gp_cmd_dlls_dir}")
endif("${gp_tool}" STREQUAL "dumpbin")
--- 461,468 ----
get_filename_component(gp_cmd_dlls_dir "${gp_cmd_dir}/../../Common7/IDE" ABSOLUTE)
if(EXISTS "${gp_cmd_dlls_dir}")
! # only add to the path if it is not already in the path
! if(NOT "$ENV{PATH}" MATCHES "${gp_cmd_dlls_dir}")
! set(ENV{PATH} "$ENV{PATH};${gp_cmd_dlls_dir}")
! endif(NOT "$ENV{PATH}" MATCHES "${gp_cmd_dlls_dir}")
endif(EXISTS "${gp_cmd_dlls_dir}")
endif("${gp_tool}" STREQUAL "dumpbin")
***************
*** 341,357 ****
endif(gp_regex_cmp_count GREATER 2)
! # 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(item "item-NOTFOUND")
! find_program(item "${raw_item}" PATHS "${target_dir}")
! if(NOT item)
! set(item "${raw_item}")
! endif(NOT item)
!
! if(verbose)
! message(STATUS "raw_item='${raw_item}'")
! message(STATUS "item='${item}'")
! endif(verbose)
# Add each item unless it is excluded:
--- 516,524 ----
endif(gp_regex_cmp_count GREATER 2)
! # 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
! # necessary.
#
! set(item "${raw_item}")
# Add each item unless it is excluded:
***************
*** 378,383 ****
# prerequisites...
#
if(NOT list_length_before_append EQUAL list_length_after_append)
! set(unseen_prereqs ${unseen_prereqs} "${item}")
endif(NOT list_length_before_append EQUAL list_length_after_append)
endif(${recurse})
--- 545,554 ----
# prerequisites...
#
+ # But first: resolve its name to an absolute full path name such
+ # 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)
! set(unseen_prereqs ${unseen_prereqs} "${resolved_item}")
endif(NOT list_length_before_append EQUAL list_length_after_append)
endif(${recurse})
***************
*** 395,399 ****
set(more_inputs ${unseen_prereqs})
foreach(input ${more_inputs})
! get_prerequisites("${input}" ${prerequisites_var} ${exclude_system} ${recurse})
endforeach(input)
endif(${recurse})
--- 566,570 ----
set(more_inputs ${unseen_prereqs})
foreach(input ${more_inputs})
! get_prerequisites("${input}" ${prerequisites_var} ${exclude_system} ${recurse} "${exepath}" "${dirs}")
endforeach(input)
endif(${recurse})
***************
*** 442,447 ****
set(type_str "")
set(prereqs "")
! get_prerequisites("${target}" prereqs ${exclude_system} ${all})
if(print_target)
--- 613,620 ----
set(type_str "")
+ get_filename_component(exepath "${target}" PATH)
+
set(prereqs "")
! get_prerequisites("${target}" prereqs ${exclude_system} ${all} "${exepath}" "")
if(print_target)
Index: FindBoost.cmake
===================================================================
RCS file: /cvsroot/CMake/CMake/Modules/FindBoost.cmake,v
retrieving revision 1.4.2.6
retrieving revision 1.4.2.7
diff -C 2 -d -r1.4.2.6 -r1.4.2.7
*** FindBoost.cmake 30 Jul 2008 18:54:49 -0000 1.4.2.6
--- FindBoost.cmake 22 Sep 2008 14:05:16 -0000 1.4.2.7
***************
*** 287,292 ****
# Try to find Boost by stepping backwards through the Boost versions
# we know about.
! FOREACH(_boost_VER ${_boost_TEST_VERSIONS})
! IF( NOT Boost_INCLUDE_DIR )
# Add in a path suffix, based on the required version, ideally
# we could read this from version.hpp, but for that to work we'd
--- 287,294 ----
# Try to find Boost by stepping backwards through the Boost versions
# we know about.
! IF( NOT Boost_INCLUDE_DIR )
! # Build a list of path suffixes for each version.
! SET(_boost_PATH_SUFFIXES)
! FOREACH(_boost_VER ${_boost_TEST_VERSIONS})
# Add in a path suffix, based on the required version, ideally
# we could read this from version.hpp, but for that to work we'd
***************
*** 305,317 ****
_boost_PATH_SUFFIX ${_boost_PATH_SUFFIX})
ENDIF(_boost_PATH_SUFFIX MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+")
! FIND_PATH(Boost_INCLUDE_DIR
! NAMES boost/config.hpp
! HINTS ${_boost_INCLUDE_SEARCH_DIRS}
! PATH_SUFFIXES ${_boost_PATH_SUFFIX}
)
!
! ENDIF( NOT Boost_INCLUDE_DIR )
! ENDFOREACH(_boost_VER)
IF(Boost_INCLUDE_DIR)
--- 307,320 ----
_boost_PATH_SUFFIX ${_boost_PATH_SUFFIX})
ENDIF(_boost_PATH_SUFFIX MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+")
+ LIST(APPEND _boost_PATH_SUFFIXES "${_boost_PATH_SUFFIX}")
+ ENDFOREACH(_boost_VER)
! # Look for a standard boost header file.
! FIND_PATH(Boost_INCLUDE_DIR
! NAMES boost/config.hpp
! HINTS ${_boost_INCLUDE_SEARCH_DIRS}
! PATH_SUFFIXES ${_boost_PATH_SUFFIXES}
)
! ENDIF( NOT Boost_INCLUDE_DIR )
IF(Boost_INCLUDE_DIR)
More information about the Cmake-commits
mailing list