Kitware/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2025-10-15 03:48:02 +08:00
Code Issues Projects Releases Wiki Activity

file(GET_RUNTIME_DEPENDENCIES): Add POST_{IN,EX}CLUDE_FILES arguments

Browse Source
This commit is contained in:
Kyle Edwards
2021-05-28 09:23:30 -04:00
parent 34a5163fec
commit a12639e658
12 changed files with 257 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
Help/command/file.rst
View File

@@ -179,6 +179,8 @@ the ``<format>`` and ``UTC`` options.
[PRE_EXCLUDE_REGEXES [<regexes>...]]
[POST_INCLUDE_REGEXES [<regexes>...]]
[POST_EXCLUDE_REGEXES [<regexes>...]]
[POST_INCLUDE_FILES [<files>...]]
[POST_EXCLUDE_FILES [<files>...]]
)
.. versionadded:: 3.16
@@ -276,6 +278,18 @@ be resolved. See below for a full description of how they work.
List of post-exclude regexes through which to filter the names of resolved
dependencies.
``POST_INCLUDE_FILES <files>``
.. versionadded:: 3.21
List of post-include filenames through which to filter the names of resolved
dependencies. Symlinks are resolved when attempting to match these filenames.
``POST_EXCLUDE_FILES <files>``
.. versionadded:: 3.21
List of post-exclude filenames through which to filter the names of resolved
dependencies. Symlinks are resolved when attempting to match these filenames.
These arguments can be used to exclude unwanted system libraries when
resolving the dependencies, or to include libraries from a specific
directory. The filtering works as follows:
@@ -289,16 +303,18 @@ directory. The filtering works as follows:
4. ``file(GET_RUNTIME_DEPENDENCIES)`` searches for the dependency according to
the linking rules of the platform (see below).
5. If the dependency is found, and its full path matches one of the
``POST_INCLUDE_REGEXES``, the full path is added to the resolved
dependencies, and ``file(GET_RUNTIME_DEPENDENCIES)`` recursively resolves
that library's own dependencies. Otherwise, resolution proceeds to step 6.
6. If the dependency is found, but its full path matches one of the
``POST_EXCLUDE_REGEXES``, it is not added to the resolved dependencies, and
dependency resolution stops for that dependency.
7. If the dependency is found, and its full path does not match either
``POST_INCLUDE_REGEXES`` or ``POST_EXCLUDE_REGEXES``, the full path is added
``POST_INCLUDE_REGEXES`` or ``POST_INCLUDE_FILES``, the full path is added
to the resolved dependencies, and ``file(GET_RUNTIME_DEPENDENCIES)``
recursively resolves that library's own dependencies.
recursively resolves that library's own dependencies. Otherwise, resolution
proceeds to step 6.
6. If the dependency is found, but its full path matches one of the
``POST_EXCLUDE_REGEXES`` or ``POST_EXCLUDE_FILES``, it is not added to the
resolved dependencies, and dependency resolution stops for that dependency.
7. If the dependency is found, and its full path does not match either
``POST_INCLUDE_REGEXES``, ``POST_INCLUDE_FILES``, ``POST_EXCLUDE_REGEXES``,
or ``POST_EXCLUDE_FILES``, the full path is added to the resolved
dependencies, and ``file(GET_RUNTIME_DEPENDENCIES)`` recursively resolves
that library's own dependencies.
Different platforms have different rules for how dependencies are resolved.
These specifics are described here.

5
Help/release/dev/get-runtime-dependencies-file-filter.rst Normal file
View File

@@ -0,0 +1,5 @@
get-runtime-dependencies-file-filter
------------------------------------
* The :command:`file(GET_RUNTIME_DEPENDENCIES)` command gained new
``POST_INCLUDE_FILES`` and ``POST_EXCLUDE_FILES`` arguments.

22
Source/cmFileCommand.cxx
View File

@@ -3041,6 +3041,9 @@ bool HandleGetRuntimeDependenciesCommand(std::vector<std::string> const& args,
std::vector<std::string> PreExcludeRegexes;
std::vector<std::string> PostIncludeRegexes;
std::vector<std::string> PostExcludeRegexes;
std::vector<std::string> PostIncludeFiles;
std::vector<std::string> PostExcludeFiles;
std::vector<std::string> PostExcludeFilesStrict;
};
static auto const parser =
@@ -3058,7 +3061,10 @@ bool HandleGetRuntimeDependenciesCommand(std::vector<std::string> const& args,
.Bind("PRE_INCLUDE_REGEXES"_s, &Arguments::PreIncludeRegexes)
.Bind("PRE_EXCLUDE_REGEXES"_s, &Arguments::PreExcludeRegexes)
.Bind("POST_INCLUDE_REGEXES"_s, &Arguments::PostIncludeRegexes)
.Bind("POST_EXCLUDE_REGEXES"_s, &Arguments::PostExcludeRegexes);
.Bind("POST_EXCLUDE_REGEXES"_s, &Arguments::PostExcludeRegexes)
.Bind("POST_INCLUDE_FILES"_s, &Arguments::PostIncludeFiles)
.Bind("POST_EXCLUDE_FILES"_s, &Arguments::PostExcludeFiles)
.Bind("POST_EXCLUDE_FILES_STRICT"_s, &Arguments::PostExcludeFilesStrict);
std::vector<std::string> unrecognizedArguments;
std::vector<std::string> keywordsMissingValues;
@@ -3072,14 +3078,19 @@ bool HandleGetRuntimeDependenciesCommand(std::vector<std::string> const& args,
return false;
}
const std::vector<std::string> LIST_ARGS = { "DIRECTORIES",
const std::vector<std::string> LIST_ARGS = {
"DIRECTORIES",
"EXECUTABLES",
"LIBRARIES",
"MODULES",
"POST_EXCLUDE_FILES",
"POST_EXCLUDE_FILES_STRICT",
"POST_EXCLUDE_REGEXES",
"POST_INCLUDE_FILES",
"POST_INCLUDE_REGEXES",
"PRE_EXCLUDE_REGEXES",
"PRE_INCLUDE_REGEXES" };
"PRE_INCLUDE_REGEXES",
};
auto kwbegin = keywordsMissingValues.cbegin();
auto kwend = cmRemoveMatching(keywordsMissingValues, LIST_ARGS);
if (kwend != kwbegin) {
@@ -3092,7 +3103,10 @@ bool HandleGetRuntimeDependenciesCommand(std::vector<std::string> const& args,
cmRuntimeDependencyArchive archive(
status, parsedArgs.Directories, parsedArgs.BundleExecutable,
parsedArgs.PreIncludeRegexes, parsedArgs.PreExcludeRegexes,
parsedArgs.PostIncludeRegexes, parsedArgs.PostExcludeRegexes);
parsedArgs.PostIncludeRegexes, parsedArgs.PostExcludeRegexes,
std::move(parsedArgs.PostIncludeFiles),
std::move(parsedArgs.PostExcludeFiles),
std::move(parsedArgs.PostExcludeFilesStrict));
if (!archive.Prepare()) {
cmSystemTools::SetFatalErrorOccured();
return false;

66
Source/cmRuntimeDependencyArchive.cxx
View File

@@ -115,7 +115,10 @@ cmRuntimeDependencyArchive::cmRuntimeDependencyArchive(
const std::vector<std::string>& preIncludeRegexes,
const std::vector<std::string>& preExcludeRegexes,
const std::vector<std::string>& postIncludeRegexes,
const std::vector<std::string>& postExcludeRegexes)
const std::vector<std::string>& postExcludeRegexes,
std::vector<std::string> postIncludeFiles,
std::vector<std::string> postExcludeFiles,
std::vector<std::string> postExcludeFilesStrict)
: Status(status)
, SearchDirectories(std::move(searchDirectories))
, BundleExecutable(std::move(bundleExecutable))
@@ -123,6 +126,9 @@ cmRuntimeDependencyArchive::cmRuntimeDependencyArchive(
, PreExcludeRegexes(preExcludeRegexes.size())
, PostIncludeRegexes(postIncludeRegexes.size())
, PostExcludeRegexes(postExcludeRegexes.size())
, PostIncludeFiles(std::move(postIncludeFiles))
, PostExcludeFiles(std::move(postExcludeFiles))
, PostExcludeFilesStrict(std::move(postExcludeFilesStrict))
{
std::transform(preIncludeRegexes.begin(), preIncludeRegexes.end(),
this->PreIncludeRegexes.begin(), TransformCompile);
@@ -306,39 +312,45 @@ bool cmRuntimeDependencyArchive::GetGetRuntimeDependenciesCommand(
bool cmRuntimeDependencyArchive::IsPreExcluded(const std::string& name)
{
cmsys::RegularExpressionMatch match;
auto const regexMatch =
[&match, name](const cmsys::RegularExpression& regex) -> bool {
return regex.find(name.c_str(), match);
};
auto const regexSearch =
[&regexMatch](
const std::vector<cmsys::RegularExpression>& regexes) -> bool {
return std::any_of(regexes.begin(), regexes.end(), regexMatch);
};
for (auto const& regex : this->PreIncludeRegexes) {
if (regex.find(name.c_str(), match)) {
return false;
}
}
for (auto const& regex : this->PreExcludeRegexes) {
if (regex.find(name.c_str(), match)) {
return true;
}
}
return false;
return !regexSearch(this->PreIncludeRegexes) &&
regexSearch(this->PreExcludeRegexes);
}
bool cmRuntimeDependencyArchive::IsPostExcluded(const std::string& name)
{
cmsys::RegularExpressionMatch match;
auto const regexMatch =
[&match, name](const cmsys::RegularExpression& regex) -> bool {
return regex.find(name.c_str(), match);
};
auto const regexSearch =
[&regexMatch](
const std::vector<cmsys::RegularExpression>& regexes) -> bool {
return std::any_of(regexes.begin(), regexes.end(), regexMatch);
};
auto const fileMatch = [name](const std::string& file) -> bool {
return cmSystemTools::SameFile(file, name);
};
auto const fileSearch =
[&fileMatch](const std::vector<std::string>& files) -> bool {
return std::any_of(files.begin(), files.end(), fileMatch);
};
for (auto const& regex : this->PostIncludeRegexes) {
if (regex.find(name.c_str(), match)) {
return false;
}
}
for (auto const& regex : this->PostExcludeRegexes) {
if (regex.find(name.c_str(), match)) {
return true;
}
}
return false;
return fileSearch(this->PostExcludeFilesStrict) ||
(!(regexSearch(this->PostIncludeRegexes) ||
fileSearch(this->PostIncludeFiles)) &&
(regexSearch(this->PostExcludeRegexes) ||
fileSearch(this->PostExcludeFiles)));
}
void cmRuntimeDependencyArchive::AddResolvedPath(const std::string& name,

8
Source/cmRuntimeDependencyArchive.h
View File

@@ -25,7 +25,10 @@ public:
const std::vector<std::string>& preIncludeRegexes,
const std::vector<std::string>& preExcludeRegexes,
const std::vector<std::string>& postIncludeRegexes,
const std::vector<std::string>& postExcludeRegexes);
const std::vector<std::string>& postExcludeRegexes,
std::vector<std::string> postIncludeFiles,
std::vector<std::string> postExcludeFiles,
std::vector<std::string> postExcludeFilesStrict);
bool Prepare();
bool GetRuntimeDependencies(const std::vector<std::string>& executables,
const std::vector<std::string>& libraries,
@@ -62,6 +65,9 @@ private:
std::vector<cmsys::RegularExpression> PreExcludeRegexes;
std::vector<cmsys::RegularExpression> PostIncludeRegexes;
std::vector<cmsys::RegularExpression> PostExcludeRegexes;
std::vector<std::string> PostIncludeFiles;
std::vector<std::string> PostExcludeFiles;
std::vector<std::string> PostExcludeFilesStrict;
std::map<std::string, std::set<std::string>> ResolvedPaths;
std::set<std::string> UnresolvedPaths;
};

24
Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/RunCMakeTest.cmake
View File

@@ -11,7 +11,26 @@ function(run_install_test case)
run_cmake_command(${case}-build ${CMAKE_COMMAND} --build . --config Debug)
# Check "all" components.
set(CMAKE_INSTALL_PREFIX ${RunCMake_TEST_BINARY_DIR}/root-all)
run_cmake_command(${case}-all ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX} -DBUILD_TYPE=Debug -P cmake_install.cmake)
run_cmake_command(${case}-all ${CMAKE_COMMAND} --install . --prefix ${CMAKE_INSTALL_PREFIX} --config Debug)
endfunction()
# Function to check the contents of the output files.
function(check_contents filename contents_regex)
if(EXISTS "${CMAKE_INSTALL_PREFIX}/${filename}")
file(READ "${CMAKE_INSTALL_PREFIX}/${filename}" contents)
if(NOT contents MATCHES "${contents_regex}")
string(APPEND RunCMake_TEST_FAILED "File contents:
${contents}
do not match what we expected:
${contents_regex}
in file:
${CMAKE_INSTALL_PREFIX}/${filename}\n")
set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
endif()
else()
string(APPEND RunCMake_TEST_FAILED "File ${CMAKE_INSTALL_PREFIX}/${filename} does not exist")
set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
endif()
endfunction()
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
@@ -20,6 +39,7 @@ if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
run_install_test(macos-unresolved)
run_install_test(macos-conflict)
run_install_test(macos-notfile)
run_install_test(file-filter)
endif()
run_cmake(project)
run_cmake(badargs1)
@@ -29,6 +49,7 @@ elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
run_install_test(windows-unresolved)
run_install_test(windows-conflict)
run_install_test(windows-notfile)
run_install_test(file-filter)
run_cmake(project)
run_cmake(badargs1)
run_cmake(badargs2)
@@ -41,6 +62,7 @@ elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
if(NOT CMAKE_C_COMPILER_ID MATCHES "^XL")
run_install_test(linux)
run_install_test(file-filter)
endif()
run_install_test(linux-unresolved)
run_install_test(linux-conflict)

2
Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/badargs2.cmake
View File

@@ -11,5 +11,7 @@ file(GET_RUNTIME_DEPENDENCIES
PRE_EXCLUDE_REGEXES
POST_INCLUDE_REGEXES
POST_EXCLUDE_REGEXES
POST_INCLUDE_FILES
POST_EXCLUDE_FILES
)
message(FATAL_ERROR "This message should not be displayed")

28
Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-all-check.cmake Normal file
View File

@@ -0,0 +1,28 @@
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
set(_check
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/\.\./lib/libdep1\.so]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/\.\./lib/libdep2\.so]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/\.\./lib/libdep3\.so]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/\.\./lib/libdep4\.so]]
)
check_contents(deps/deps.txt "^${_check}$")
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
set(_check
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/\.\./lib/libdep1\.dylib]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/\.\./lib/libdep2\.dylib]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/\.\./lib/libdep3\.dylib]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/\.\./lib/libdep4\.dylib]]
)
check_contents(deps/deps.txt "^${_check}$")
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
set(_check
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/(lib)?dep1\.dll]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/(lib)?dep2\.dll]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/(lib)?dep3\.dll]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter-build/root-all/bin/(lib)?dep4\.dll]]
)
check_contents(deps/deps.txt "^${_check}$")
endif()
check_contents(deps/udeps.txt "^$")
check_contents(deps/cdeps.txt "^$")

104
Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/file-filter.cmake Normal file
View File

@@ -0,0 +1,104 @@
enable_language(C)
set(dep_list)
set(import_list)
set(call_list)
foreach(i 1 2 3 4 5 6 7 8 9)
file(WRITE "${CMAKE_BINARY_DIR}/dep${i}.c"
"#ifdef _WIN32
__declspec(dllexport)
#endif
void dep${i}(void)
{
}
")
add_library(dep${i} SHARED "${CMAKE_BINARY_DIR}/dep${i}.c")
list(APPEND dep_list dep${i})
string(APPEND import_list "EXE_IMPORT extern void dep${i}(void);\n")
string(APPEND call_list " dep${i}();\n")
endforeach()
set_target_properties(dep5 PROPERTIES
VERSION 1.2.3
SOVERSION 1
)
file(WRITE "${CMAKE_BINARY_DIR}/main.c"
"#ifdef _WIN32
# define EXE_IMPORT __declspec(dllimport)
#else
# define EXE_IMPORT
#endif
${import_list}
int main(void)
{
${call_list}
return 0;
}
")
add_executable(exe "${CMAKE_BINARY_DIR}/main.c")
target_link_libraries(exe PRIVATE ${dep_list})
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
set_property(TARGET exe PROPERTY INSTALL_RPATH "\${ORIGIN}/../lib")
elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
set_property(TARGET exe PROPERTY INSTALL_RPATH "@loader_path/../lib")
endif()
install(TARGETS exe ${dep_list})
install(CODE
[[
function(exec_get_runtime_dependencies depsfile udepsfile cdepsfile)
file(GET_RUNTIME_DEPENDENCIES
RESOLVED_DEPENDENCIES_VAR deps
UNRESOLVED_DEPENDENCIES_VAR udeps
CONFLICTING_DEPENDENCIES_PREFIX cdeps
PRE_INCLUDE_REGEXES "dep[123456789]"
PRE_EXCLUDE_REGEXES ".*"
POST_INCLUDE_REGEXES "dep9"
POST_INCLUDE_FILES
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:dep1>"
"${CMAKE_INSTALL_PREFIX}/lib/$<TARGET_FILE_NAME:dep1>"
"${CMAKE_INSTALL_PREFIX}/bin/../bin/$<TARGET_FILE_NAME:dep2>"
"${CMAKE_INSTALL_PREFIX}/bin/../lib/$<TARGET_FILE_NAME:dep2>"
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:dep3>"
"${CMAKE_INSTALL_PREFIX}/lib/$<TARGET_FILE_NAME:dep3>"
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:dep8>"
"${CMAKE_INSTALL_PREFIX}/lib/$<TARGET_FILE_NAME:dep8>"
POST_EXCLUDE_FILES
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:dep3>"
"${CMAKE_INSTALL_PREFIX}/lib/$<TARGET_FILE_NAME:dep3>"
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:dep5>"
"${CMAKE_INSTALL_PREFIX}/lib/$<TARGET_FILE_NAME:dep5>"
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:dep6>"
"${CMAKE_INSTALL_PREFIX}/lib/$<TARGET_FILE_NAME:dep6>"
"${CMAKE_INSTALL_PREFIX}/bin/../bin/$<TARGET_FILE_NAME:dep7>"
"${CMAKE_INSTALL_PREFIX}/bin/../lib/$<TARGET_FILE_NAME:dep7>"
POST_EXCLUDE_FILES_STRICT
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:dep8>"
"${CMAKE_INSTALL_PREFIX}/lib/$<TARGET_FILE_NAME:dep8>"
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:dep9>"
"${CMAKE_INSTALL_PREFIX}/lib/$<TARGET_FILE_NAME:dep9>"
${ARGN}
)
list(SORT deps)
list(SORT udeps)
list(SORT cdeps_FILENAMES)
file(WRITE "${CMAKE_INSTALL_PREFIX}/deps/${depsfile}" "${deps}")
file(WRITE "${CMAKE_INSTALL_PREFIX}/deps/${udepsfile}" "${udeps}")
file(WRITE "${CMAKE_INSTALL_PREFIX}/deps/${cdepsfile}" "")
foreach(cdep IN LISTS cdeps_FILENAMES)
set(cdep_values ${cdeps_${cdep}})
list(SORT cdep_values)
file(APPEND "${CMAKE_INSTALL_PREFIX}/deps/${cdepsfile}" "${cdep}:${cdep_values}\n")
endforeach()
endfunction()
exec_get_runtime_dependencies(
deps.txt udeps.txt cdeps.txt
EXECUTABLES
"${CMAKE_INSTALL_PREFIX}/bin/$<TARGET_FILE_NAME:exe>"
)
]])

18
Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/linux-all-check.cmake
View File

@@ -1,21 +1,3 @@
function(check_contents filename contents_regex)
if(EXISTS "${CMAKE_INSTALL_PREFIX}/${filename}")
file(READ "${CMAKE_INSTALL_PREFIX}/${filename}" contents)
if(NOT contents MATCHES "${contents_regex}")
string(APPEND RunCMake_TEST_FAILED "File contents:
${contents}
do not match what we expected:
${contents_regex}
in file:
${CMAKE_INSTALL_PREFIX}/${filename}\n")
set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
endif()
else()
string(APPEND RunCMake_TEST_FAILED "File ${CMAKE_INSTALL_PREFIX}/${filename} does not exist")
set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
endif()
endfunction()
set(_check
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/linux-build/root-all/lib/libtest_rpath\.so]]
[[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/linux-build/root-all/lib/libtest_runpath\.so]]

18
Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/macos-all-check.cmake
View File

@@ -1,21 +1,3 @@
function(check_contents filename contents_regex)
if(EXISTS "${CMAKE_INSTALL_PREFIX}/${filename}")
file(READ "${CMAKE_INSTALL_PREFIX}/${filename}" contents)
if(NOT contents MATCHES "${contents_regex}")
string(APPEND RunCMake_TEST_FAILED "File contents:
${contents}
do not match what we expected:
${contents_regex}
in file:
${CMAKE_INSTALL_PREFIX}/${filename}\n")
set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
endif()
else()
string(APPEND RunCMake_TEST_FAILED "File ${CMAKE_INSTALL_PREFIX}/${filename} does not exist")
set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
endif()
endfunction()
function(set_with_libsystem var)
set(_tmp "${ARGN}")
if(EXISTS "/usr/lib/libSystem.B.dylib")

18
Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/windows-all-check.cmake
View File

@@ -1,21 +1,3 @@
function(check_contents filename contents_regex)
if(EXISTS "${CMAKE_INSTALL_PREFIX}/${filename}")
file(READ "${CMAKE_INSTALL_PREFIX}/${filename}" contents)
if(NOT contents MATCHES "${contents_regex}")
string(APPEND RunCMake_TEST_FAILED "File contents:
${contents}
do not match what we expected:
${contents_regex}
in file:
${CMAKE_INSTALL_PREFIX}/${filename}\n")
set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
endif()
else()
string(APPEND RunCMake_TEST_FAILED "File ${CMAKE_INSTALL_PREFIX}/${filename} does not exist")
set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE)
endif()
endfunction()
set(_check
[=[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/windows-build/root-all/bin/\.conflict/\.\./(lib)?libdir\.dll]=]
[=[[^;]*/Tests/RunCMake/file-GET_RUNTIME_DEPENDENCIES/windows-build/root-all/bin/\.search/(lib)?search\.dll]=]