mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-04-29 10:39:28 -05:00
Code Issues Packages Projects Releases Wiki Activity

KWSys 2023-02-07 (db9470d4)

Browse Source 
Code extracted from:

    https://gitlab.kitware.com/utils/kwsys.git

at commit db9470d4271ef65864a374a7a2f58f9789573903 (master).

Upstream Shortlog
-----------------

Ben Boeckel (1):
      46f47034 SharedForward: Drop this component of KWSys

Brad King (2):
      bfa688b5 SystemTools: Drop optional FindProgramPath arguments
      093d6e45 DynamicLoader: Update test to avoid using CMAKE_INTDIR
This commit is contained in:
KWSys Upstream
2023-02-07 08:49:53 -05:00
committed by Brad King
parent 187389d9e1
commit 48fd1b3887
6 changed files with 9 additions and 949 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+5 -11
View File
@@ -630,7 +630,7 @@ endif()
# Build a list of classes and headers we need to implement the
# selected components. Initialize with required components.
set(KWSYS_CLASSES)
set(KWSYS_H_FILES Configure SharedForward)
set(KWSYS_H_FILES Configure)
set(KWSYS_HXX_FILES Configure String)
# Add selected C++ classes.
@@ -1038,6 +1038,10 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
target_link_libraries(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_TARGET_LINK})
get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(_isMultiConfig)
set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx APPEND PROPERTY COMPILE_DEFINITIONS BUILD_CONFIG="$<CONFIG>")
endif()
set(TEST_SYSTEMTOOLS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
set(TEST_SYSTEMTOOLS_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
@@ -1118,16 +1122,6 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
endif()
set_property(SOURCE testProcess.c PROPERTY COMPILE_FLAGS "${testProcess_COMPILE_FLAGS}")
# Test SharedForward
configure_file(${PROJECT_SOURCE_DIR}/testSharedForward.c.in
${PROJECT_BINARY_DIR}/testSharedForward.c @ONLY IMMEDIATE)
add_executable(${KWSYS_NAMESPACE}TestSharedForward
${PROJECT_BINARY_DIR}/testSharedForward.c)
set_property(TARGET ${KWSYS_NAMESPACE}TestSharedForward PROPERTY LABELS ${KWSYS_LABELS_EXE})
add_dependencies(${KWSYS_NAMESPACE}TestSharedForward ${KWSYS_TARGET_C_LINK})
add_test(kwsys.testSharedForward ${EXEC_DIR}/${KWSYS_NAMESPACE}TestSharedForward 1)
set_property(TEST kwsys.testSharedForward PROPERTY LABELS ${KWSYS_LABELS_TEST})
# Configure some test properties.
if(KWSYS_STANDALONE)
# We expect test to fail
SharedForward.h.in
-873
View File
@@ -1,873 +0,0 @@
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing#kwsys for details. */
#ifndef @KWSYS_NAMESPACE@_SharedForward_h
# define @KWSYS_NAMESPACE@_SharedForward_h
/*
This header is used to create a forwarding executable sets up the
shared library search path and replaces itself with a real
executable. This is useful when creating installations on UNIX with
shared libraries that will run from any install directory. Typical
usage:
#if defined(CMAKE_INTDIR)
# define CONFIG_DIR_PRE CMAKE_INTDIR "/"
# define CONFIG_DIR_POST "/" CMAKE_INTDIR
#else
# define CONFIG_DIR_PRE ""
# define CONFIG_DIR_POST ""
#endif
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD "/path/to/foo-build/bin"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD "." CONFIG_DIR_POST
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL "../lib/foo-1.2"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD CONFIG_DIR_PRE "foo-real"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL
"../lib/foo-1.2/foo-real"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_COMMAND "--command"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT "--print"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD "--ldd"
#if defined(CMAKE_INTDIR)
# define @KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME CMAKE_INTDIR
#endif
#include <@KWSYS_NAMESPACE@/SharedForward.h>
int main(int argc, char** argv)
{
return @KWSYS_NAMESPACE@_shared_forward_to_real(argc, argv);
}
Specify search and executable paths relative to the forwarding
executable location or as full paths. Include no trailing slash.
In the case of a multi-configuration build, when CMAKE_INTDIR is
defined, the DIR_BUILD setting should point at the directory above
the executable (the one containing the per-configuration
subdirectory specified by CMAKE_INTDIR). Then PATH_BUILD entries
and EXE_BUILD should be specified relative to this location and use
CMAKE_INTDIR as necessary. In the above example imagine appending
the PATH_BUILD or EXE_BUILD setting to the DIR_BUILD setting. The
result should form a valid path with per-configuration subdirectory.
Additional paths may be specified in the PATH_BUILD and PATH_INSTALL
variables by using comma-separated strings. For example:
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD \
"." CONFIG_DIR_POST, "/path/to/bar-build" CONFIG_DIR_POST
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL \
"../lib/foo-1.2", "../lib/bar-4.5"
See the comments below for specific explanations of each macro.
*/
/* Disable -Wcast-qual warnings since they are too hard to fix in a
cross-platform way. */
# if defined(__clang__) && defined(__has_warning)
# if __has_warning("-Wcast-qual")
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wcast-qual"
# endif
# endif
/* Full path to the directory in which this executable is built. Do
not include a trailing slash. */
# if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD)
# error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD"
# endif
# if !defined(KWSYS_SHARED_FORWARD_DIR_BUILD)
# define KWSYS_SHARED_FORWARD_DIR_BUILD \
@KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD
# endif
/* Library search path for build tree. */
# if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD)
# error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD"
# endif
# if !defined(KWSYS_SHARED_FORWARD_PATH_BUILD)
# define KWSYS_SHARED_FORWARD_PATH_BUILD \
@KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD
# endif
/* Library search path for install tree. */
# if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL)
# error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL"
# endif
# if !defined(KWSYS_SHARED_FORWARD_PATH_INSTALL)
# define KWSYS_SHARED_FORWARD_PATH_INSTALL \
@KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL
# endif
/* The real executable to which to forward in the build tree. */
# if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD)
# error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD"
# endif
# if !defined(KWSYS_SHARED_FORWARD_EXE_BUILD)
# define KWSYS_SHARED_FORWARD_EXE_BUILD \
@KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD
# endif
/* The real executable to which to forward in the install tree. */
# if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL)
# error "Must define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL"
# endif
# if !defined(KWSYS_SHARED_FORWARD_EXE_INSTALL)
# define KWSYS_SHARED_FORWARD_EXE_INSTALL \
@KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL
# endif
/* The configuration name with which this executable was built (Debug/Release).
*/
# if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME)
# define KWSYS_SHARED_FORWARD_CONFIG_NAME \
@KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME
# else
# undef KWSYS_SHARED_FORWARD_CONFIG_NAME
# endif
/* Create command line option to replace executable. */
# if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_COMMAND)
# if !defined(KWSYS_SHARED_FORWARD_OPTION_COMMAND)
# define KWSYS_SHARED_FORWARD_OPTION_COMMAND \
@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_COMMAND
# endif
# else
# undef KWSYS_SHARED_FORWARD_OPTION_COMMAND
# endif
/* Create command line option to print environment setting and exit. */
# if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT)
# if !defined(KWSYS_SHARED_FORWARD_OPTION_PRINT)
# define KWSYS_SHARED_FORWARD_OPTION_PRINT \
@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT
# endif
# else
# undef KWSYS_SHARED_FORWARD_OPTION_PRINT
# endif
/* Create command line option to run ldd or equivalent. */
# if defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD)
# if !defined(KWSYS_SHARED_FORWARD_OPTION_LDD)
# define KWSYS_SHARED_FORWARD_OPTION_LDD \
@KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD
# endif
# else
# undef KWSYS_SHARED_FORWARD_OPTION_LDD
# endif
/* Include needed system headers. */
# include <errno.h>
# include <limits.h>
# include <stddef.h> /* size_t */
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# if defined(_WIN32) && !defined(__CYGWIN__)
# include <windows.h>
# include <io.h>
# include <process.h>
# define KWSYS_SHARED_FORWARD_ESCAPE_ARGV /* re-escape argv for execvp */
# else
# include <sys/stat.h>
# include <unistd.h>
# endif
/* Configuration for this platform. */
/* The path separator for this platform. */
# if defined(_WIN32) && !defined(__CYGWIN__)
# define KWSYS_SHARED_FORWARD_PATH_SEP ';'
# define KWSYS_SHARED_FORWARD_PATH_SLASH '\\'
# else
# define KWSYS_SHARED_FORWARD_PATH_SEP ':'
# define KWSYS_SHARED_FORWARD_PATH_SLASH '/'
# endif
static const char kwsys_shared_forward_path_sep[2] = {
KWSYS_SHARED_FORWARD_PATH_SEP, 0
};
static const char kwsys_shared_forward_path_slash[2] = {
KWSYS_SHARED_FORWARD_PATH_SLASH, 0
};
/* The maximum length of a file name. */
# if defined(PATH_MAX)
# define KWSYS_SHARED_FORWARD_MAXPATH PATH_MAX
# elif defined(MAXPATHLEN)
# define KWSYS_SHARED_FORWARD_MAXPATH MAXPATHLEN
# else
# define KWSYS_SHARED_FORWARD_MAXPATH 16384
# endif
/* Select the environment variable holding the shared library runtime
search path for this platform and build configuration. Also select
ldd command equivalent. */
/* Linux */
# if defined(__linux)
# define KWSYS_SHARED_FORWARD_LDD "ldd"
# define KWSYS_SHARED_FORWARD_LDD_N 1
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
/* FreeBSD */
# elif defined(__FreeBSD__)
# define KWSYS_SHARED_FORWARD_LDD "ldd"
# define KWSYS_SHARED_FORWARD_LDD_N 1
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
/* OpenBSD */
# elif defined(__OpenBSD__)
# define KWSYS_SHARED_FORWARD_LDD "ldd"
# define KWSYS_SHARED_FORWARD_LDD_N 1
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
/* OS X */
# elif defined(__APPLE__)
# define KWSYS_SHARED_FORWARD_LDD "otool", "-L"
# define KWSYS_SHARED_FORWARD_LDD_N 2
# define KWSYS_SHARED_FORWARD_LDPATH "DYLD_LIBRARY_PATH"
/* AIX */
# elif defined(_AIX)
# define KWSYS_SHARED_FORWARD_LDD "dump", "-H"
# define KWSYS_SHARED_FORWARD_LDD_N 2
# define KWSYS_SHARED_FORWARD_LDPATH "LIBPATH"
/* SUN */
# elif defined(__sun)
# define KWSYS_SHARED_FORWARD_LDD "ldd"
# define KWSYS_SHARED_FORWARD_LDD_N 1
# include <sys/isa_defs.h>
# if defined(_ILP32)
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
# elif defined(_LP64)
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH_64"
# endif
/* HP-UX */
# elif defined(__hpux)
# define KWSYS_SHARED_FORWARD_LDD "chatr"
# define KWSYS_SHARED_FORWARD_LDD_N 1
# if defined(__LP64__)
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
# else
# define KWSYS_SHARED_FORWARD_LDPATH "SHLIB_PATH"
# endif
/* SGI MIPS */
# elif defined(__sgi) && defined(_MIPS_SIM)
# define KWSYS_SHARED_FORWARD_LDD "ldd"
# define KWSYS_SHARED_FORWARD_LDD_N 1
# if _MIPS_SIM == _ABIO32
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
# elif _MIPS_SIM == _ABIN32
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARYN32_PATH"
# elif _MIPS_SIM == _ABI64
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY64_PATH"
# endif
/* Cygwin */
# elif defined(__CYGWIN__)
# define KWSYS_SHARED_FORWARD_LDD \
"cygcheck" /* TODO: cygwin 1.7 has ldd \
*/
# define KWSYS_SHARED_FORWARD_LDD_N 1
# define KWSYS_SHARED_FORWARD_LDPATH "PATH"
/* Windows */
# elif defined(_WIN32)
# define KWSYS_SHARED_FORWARD_LDPATH "PATH"
/* Guess on this unknown system. */
# else
# define KWSYS_SHARED_FORWARD_LDD "ldd"
# define KWSYS_SHARED_FORWARD_LDD_N 1
# define KWSYS_SHARED_FORWARD_LDPATH "LD_LIBRARY_PATH"
# endif
# ifdef KWSYS_SHARED_FORWARD_ESCAPE_ARGV
typedef struct kwsys_sf_arg_info_s
{
const char* arg;
int size;
int quote;
} kwsys_sf_arg_info;
static kwsys_sf_arg_info kwsys_sf_get_arg_info(const char* in)
{
/* Initialize information. */
kwsys_sf_arg_info info;
/* String iterator. */
const char* c;
/* Keep track of how many backslashes have been encountered in a row. */
int windows_backslashes = 0;
/* Start with the length of the original argument, plus one for
either a terminating null or a separating space. */
info.arg = in;
info.size = (int)strlen(in) + 1;
info.quote = 0;
/* Scan the string for characters that require escaping or quoting. */
for (c = in; *c; ++c) {
/* Check whether this character needs quotes. */
if (strchr(" \t?'#&<>|^", *c)) {
info.quote = 1;
}
/* On Windows only backslashes and double-quotes need escaping. */
if (*c == '\\') {
/* Found a backslash. It may need to be escaped later. */
++windows_backslashes;
} else if (*c == '"') {
/* Found a double-quote. We need to escape it and all
immediately preceding backslashes. */
info.size += windows_backslashes + 1;
windows_backslashes = 0;
} else {
/* Found another character. This eliminates the possibility
that any immediately preceding backslashes will be
escaped. */
windows_backslashes = 0;
}
}
/* Check whether the argument needs surrounding quotes. */
if (info.quote) {
/* Surrounding quotes are needed. Allocate space for them. */
info.size += 2;
/* We must escape all ending backslashes when quoting on windows. */
info.size += windows_backslashes;
}
return info;
}
static char* kwsys_sf_get_arg(kwsys_sf_arg_info info, char* out)
{
/* String iterator. */
const char* c;
/* Keep track of how many backslashes have been encountered in a row. */
int windows_backslashes = 0;
/* Whether the argument must be quoted. */
if (info.quote) {
/* Add the opening quote for this argument. */
*out++ = '"';
}
/* Scan the string for characters that require escaping or quoting. */
for (c = info.arg; *c; ++c) {
/* On Windows only backslashes and double-quotes need escaping. */
if (*c == '\\') {
/* Found a backslash. It may need to be escaped later. */
++windows_backslashes;
} else if (*c == '"') {
/* Found a double-quote. Escape all immediately preceding
backslashes. */
while (windows_backslashes > 0) {
--windows_backslashes;
*out++ = '\\';
}
/* Add the backslash to escape the double-quote. */
*out++ = '\\';
} else {
/* We encountered a normal character. This eliminates any
escaping needed for preceding backslashes. */
windows_backslashes = 0;
}
/* Store this character. */
*out++ = *c;
}
if (info.quote) {
/* Add enough backslashes to escape any trailing ones. */
while (windows_backslashes > 0) {
--windows_backslashes;
*out++ = '\\';
}
/* Add the closing quote for this argument. */
*out++ = '"';
}
/* Store a terminating null without incrementing. */
*out = 0;
return out;
}
# endif
/* Function to convert a logical or relative path to a physical full path. */
static int kwsys_shared_forward_realpath(const char* in_path, char* out_path)
{
# if defined(_WIN32) && !defined(__CYGWIN__)
/* Implementation for Windows. */
DWORD n =
GetFullPathNameA(in_path, KWSYS_SHARED_FORWARD_MAXPATH, out_path, 0);
return n > 0 && n <= KWSYS_SHARED_FORWARD_MAXPATH;
# else
/* Implementation for UNIX. */
return realpath(in_path, out_path) != 0;
# endif
}
static int kwsys_shared_forward_samepath(const char* file1, const char* file2)
{
# if defined(_WIN32)
int result = 0;
HANDLE h1 = CreateFileA(file1, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
HANDLE h2 = CreateFileA(file2, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (h1 != INVALID_HANDLE_VALUE && h2 != INVALID_HANDLE_VALUE) {
BY_HANDLE_FILE_INFORMATION fi1;
BY_HANDLE_FILE_INFORMATION fi2;
GetFileInformationByHandle(h1, &fi1);
GetFileInformationByHandle(h2, &fi2);
result = (fi1.dwVolumeSerialNumber == fi2.dwVolumeSerialNumber &&
fi1.nFileIndexHigh == fi2.nFileIndexHigh &&
fi1.nFileIndexLow == fi2.nFileIndexLow);
}
CloseHandle(h1);
CloseHandle(h2);
return result;
# else
struct stat fs1, fs2;
return (stat(file1, &fs1) == 0 && stat(file2, &fs2) == 0 &&
memcmp(&fs2.st_dev, &fs1.st_dev, sizeof(fs1.st_dev)) == 0 &&
memcmp(&fs2.st_ino, &fs1.st_ino, sizeof(fs1.st_ino)) == 0 &&
fs2.st_size == fs1.st_size);
# endif
}
/* Function to report a system error message. */
static void kwsys_shared_forward_strerror(char* message)
{
# if defined(_WIN32) && !defined(__CYGWIN__)
/* Implementation for Windows. */
DWORD original = GetLastError();
DWORD length =
FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
0, original, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
message, KWSYS_SHARED_FORWARD_MAXPATH, 0);
if (length < 1 || length > KWSYS_SHARED_FORWARD_MAXPATH) {
/* FormatMessage failed. Use a default message. */
snprintf(message, KWSYS_SHARED_FORWARD_MAXPATH,
"Error 0x%lX (FormatMessage failed with error 0x%lX)", original,
GetLastError());
}
# else
/* Implementation for UNIX. */
strcpy(message, strerror(errno));
# endif
}
/* Functions to execute a child process. */
static void kwsys_shared_forward_execvp(const char* cmd,
char const* const* argv)
{
# ifdef KWSYS_SHARED_FORWARD_ESCAPE_ARGV
/* Count the number of arguments. */
int argc = 0;
{
char const* const* argvc;
for (argvc = argv; *argvc; ++argvc, ++argc) {
}
}
/* Create the escaped arguments. */
{
char** nargv = (char**)malloc((argc + 1) * sizeof(char*));
int i;
for (i = 0; i < argc; ++i) {
kwsys_sf_arg_info info = kwsys_sf_get_arg_info(argv[i]);
nargv[i] = (char*)malloc(info.size);
kwsys_sf_get_arg(info, nargv[i]);
}
nargv[argc] = 0;
/* Replace the command line to be used. */
argv = (char const* const*)nargv;
}
# endif
/* Invoke the child process. */
# if defined(_MSC_VER)
_execvp(cmd, argv);
# elif defined(__MINGW32__) && !defined(__MINGW64__)
execvp(cmd, argv);
# else
execvp(cmd, (char* const*)argv);
# endif
}
/* Function to get the directory containing the given file or directory. */
static void kwsys_shared_forward_dirname(const char* begin, char* result)
{
/* Find the location of the last slash. */
int last_slash_index = -1;
const char* end = begin + strlen(begin);
for (; begin <= end && last_slash_index < 0; --end) {
if (*end == '/' || *end == '\\') {
last_slash_index = (int)(end - begin);
}
}
/* Handle each case of the index of the last slash. */
if (last_slash_index < 0) {
/* No slashes. */
strcpy(result, ".");
} else if (last_slash_index == 0) {
/* Only one leading slash. */
strcpy(result, kwsys_shared_forward_path_slash);
}
# if defined(_WIN32)
else if (last_slash_index == 2 && begin[1] == ':') {
/* Only one leading drive letter and slash. */
strncpy(result, begin, (size_t)last_slash_index);
result[last_slash_index] = KWSYS_SHARED_FORWARD_PATH_SLASH;
result[last_slash_index + 1] = 0;
}
# endif
else {
/* A non-leading slash. */
strncpy(result, begin, (size_t)last_slash_index);
result[last_slash_index] = 0;
}
}
/* Function to check if a file exists and is executable. */
static int kwsys_shared_forward_is_executable(const char* f)
{
# if defined(_MSC_VER)
# define KWSYS_SHARED_FORWARD_ACCESS _access
# else
# define KWSYS_SHARED_FORWARD_ACCESS access
# endif
# if defined(X_OK)
# define KWSYS_SHARED_FORWARD_ACCESS_OK X_OK
# else
# define KWSYS_SHARED_FORWARD_ACCESS_OK 04
# endif
if (KWSYS_SHARED_FORWARD_ACCESS(f, KWSYS_SHARED_FORWARD_ACCESS_OK) == 0) {
return 1;
} else {
return 0;
}
}
/* Function to locate the executable currently running. */
static int kwsys_shared_forward_self_path(const char* argv0, char* result)
{
/* Check whether argv0 has a slash. */
int has_slash = 0;
const char* p = argv0;
for (; *p && !has_slash; ++p) {
if (*p == '/' || *p == '\\') {
has_slash = 1;
}
}
if (has_slash) {
/* There is a slash. Use the dirname of the given location. */
kwsys_shared_forward_dirname(argv0, result);
return 1;
} else {
/* There is no slash. Search the PATH for the executable. */
const char* path = getenv("PATH");
const char* begin = path;
const char* end = begin + (begin ? strlen(begin) : 0);
const char* first = begin;
while (first != end) {
/* Store the end of this path entry. */
const char* last;
/* Skip all path separators. */
for (; *first && *first == KWSYS_SHARED_FORWARD_PATH_SEP; ++first)
;
/* Find the next separator. */
for (last = first; *last && *last != KWSYS_SHARED_FORWARD_PATH_SEP;
++last)
;
/* If we got a non-empty directory, look for the executable there. */
if (first < last) {
/* Determine the length without trailing slash. */
size_t length = (size_t)(last - first);
if (*(last - 1) == '/' || *(last - 1) == '\\') {
--length;
}
/* Construct the name of the executable in this location. */
strncpy(result, first, length);
result[length] = KWSYS_SHARED_FORWARD_PATH_SLASH;
strcpy(result + (length) + 1, argv0);
/* Check if it exists and is executable. */
if (kwsys_shared_forward_is_executable(result)) {
/* Found it. */
result[length] = 0;
return 1;
}
}
/* Move to the next directory in the path. */
first = last;
}
}
/* We could not find the executable. */
return 0;
}
/* Function to convert a specified path to a full path. If it is not
already full, it is taken relative to the self path. */
static int kwsys_shared_forward_fullpath(const char* self_path,
const char* in_path, char* result,
const char* desc)
{
/* Check the specified path type. */
if (in_path[0] == '/') {
/* Already a full path. */
strcpy(result, in_path);
}
# if defined(_WIN32)
else if (in_path[0] && in_path[1] == ':') {
/* Already a full path. */
strcpy(result, in_path);
}
# endif
else {
/* Relative to self path. */
char temp_path[KWSYS_SHARED_FORWARD_MAXPATH];
strcpy(temp_path, self_path);
strcat(temp_path, kwsys_shared_forward_path_slash);
strcat(temp_path, in_path);
if (!kwsys_shared_forward_realpath(temp_path, result)) {
if (desc) {
char msgbuf[KWSYS_SHARED_FORWARD_MAXPATH];
kwsys_shared_forward_strerror(msgbuf);
fprintf(stderr, "Error converting %s \"%s\" to real path: %s\n", desc,
temp_path, msgbuf);
}
return 0;
}
}
return 1;
}
/* Function to compute the library search path and executable name
based on the self path. */
static int kwsys_shared_forward_get_settings(const char* self_path,
char* ldpath, char* exe)
{
/* Possible search paths. */
static const char* search_path_build[] = { KWSYS_SHARED_FORWARD_PATH_BUILD,
0 };
static const char* search_path_install[] = {
KWSYS_SHARED_FORWARD_PATH_INSTALL, 0
};
/* Chosen paths. */
const char** search_path;
const char* exe_path;
/* Get the real name of the build and self paths. */
# if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
char build_path[] =
KWSYS_SHARED_FORWARD_DIR_BUILD "/" KWSYS_SHARED_FORWARD_CONFIG_NAME;
char self_path_logical[KWSYS_SHARED_FORWARD_MAXPATH];
# else
char build_path[] = KWSYS_SHARED_FORWARD_DIR_BUILD;
const char* self_path_logical = self_path;
# endif
char build_path_real[KWSYS_SHARED_FORWARD_MAXPATH];
char self_path_real[KWSYS_SHARED_FORWARD_MAXPATH];
if (!kwsys_shared_forward_realpath(self_path, self_path_real)) {
char msgbuf[KWSYS_SHARED_FORWARD_MAXPATH];
kwsys_shared_forward_strerror(msgbuf);
fprintf(stderr, "Error converting self path \"%s\" to real path: %s\n",
self_path, msgbuf);
return 0;
}
/* Check whether we are running in the build tree or an install tree. */
if (kwsys_shared_forward_realpath(build_path, build_path_real) &&
kwsys_shared_forward_samepath(self_path_real, build_path_real)) {
/* Running in build tree. Use the build path and exe. */
search_path = search_path_build;
# if defined(_WIN32)
exe_path = KWSYS_SHARED_FORWARD_EXE_BUILD ".exe";
# else
exe_path = KWSYS_SHARED_FORWARD_EXE_BUILD;
# endif
# if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
/* Remove the configuration directory from self_path. */
kwsys_shared_forward_dirname(self_path, self_path_logical);
# endif
} else {
/* Running in install tree. Use the install path and exe. */
search_path = search_path_install;
# if defined(_WIN32)
exe_path = KWSYS_SHARED_FORWARD_EXE_INSTALL ".exe";
# else
exe_path = KWSYS_SHARED_FORWARD_EXE_INSTALL;
# endif
# if defined(KWSYS_SHARED_FORWARD_CONFIG_NAME)
/* Use the original self path directory. */
strcpy(self_path_logical, self_path);
# endif
}
/* Construct the runtime search path. */
{
const char** dir;
for (dir = search_path; *dir; ++dir) {
/* Add separator between path components. */
if (dir != search_path) {
strcat(ldpath, kwsys_shared_forward_path_sep);
}
/* Add this path component. */
if (!kwsys_shared_forward_fullpath(self_path_logical, *dir,
ldpath + strlen(ldpath),
"runtime path entry")) {
return 0;
}
}
}
/* Construct the executable location. */
if (!kwsys_shared_forward_fullpath(self_path_logical, exe_path, exe,
"executable file")) {
return 0;
}
return 1;
}
/* Function to print why execution of a command line failed. */
static void kwsys_shared_forward_print_failure(char const* const* argv)
{
char msg[KWSYS_SHARED_FORWARD_MAXPATH];
char const* const* arg = argv;
kwsys_shared_forward_strerror(msg);
fprintf(stderr, "Error running");
for (; *arg; ++arg) {
fprintf(stderr, " \"%s\"", *arg);
}
fprintf(stderr, ": %s\n", msg);
}
/* Static storage space to store the updated environment variable. */
static char kwsys_shared_forward_ldpath[65535] =
KWSYS_SHARED_FORWARD_LDPATH "=";
/* Main driver function to be called from main. */
static int @KWSYS_NAMESPACE@_shared_forward_to_real(int argc, char** argv_in)
{
char const** argv = (char const**)argv_in;
/* Get the directory containing this executable. */
char self_path[KWSYS_SHARED_FORWARD_MAXPATH];
if (kwsys_shared_forward_self_path(argv[0], self_path)) {
/* Found this executable. Use it to get the library directory. */
char exe[KWSYS_SHARED_FORWARD_MAXPATH];
if (kwsys_shared_forward_get_settings(self_path,
kwsys_shared_forward_ldpath, exe)) {
/* Append the old runtime search path. */
const char* old_ldpath = getenv(KWSYS_SHARED_FORWARD_LDPATH);
if (old_ldpath) {
strcat(kwsys_shared_forward_ldpath, kwsys_shared_forward_path_sep);
strcat(kwsys_shared_forward_ldpath, old_ldpath);
}
/* Store the environment variable. */
putenv(kwsys_shared_forward_ldpath);
# if defined(KWSYS_SHARED_FORWARD_OPTION_COMMAND)
/* Look for the command line replacement option. */
if (argc > 1 &&
strcmp(argv[1], KWSYS_SHARED_FORWARD_OPTION_COMMAND) == 0) {
if (argc > 2) {
/* Use the command line given. */
strcpy(exe, argv[2]);
argv += 2;
argc -= 2;
} else {
/* The option was not given an executable. */
fprintf(stderr,
"Option " KWSYS_SHARED_FORWARD_OPTION_COMMAND
" must be followed by a command line.\n");
return 1;
}
}
# endif
# if defined(KWSYS_SHARED_FORWARD_OPTION_PRINT)
/* Look for the print command line option. */
if (argc > 1 &&
strcmp(argv[1], KWSYS_SHARED_FORWARD_OPTION_PRINT) == 0) {
fprintf(stdout, "%s\n", kwsys_shared_forward_ldpath);
fprintf(stdout, "%s\n", exe);
return 0;
}
# endif
# if defined(KWSYS_SHARED_FORWARD_OPTION_LDD)
/* Look for the ldd command line option. */
if (argc > 1 && strcmp(argv[1], KWSYS_SHARED_FORWARD_OPTION_LDD) == 0) {
# if defined(KWSYS_SHARED_FORWARD_LDD)
/* Use the named ldd-like executable and arguments. */
char const* ldd_argv[] = { KWSYS_SHARED_FORWARD_LDD, 0, 0 };
ldd_argv[KWSYS_SHARED_FORWARD_LDD_N] = exe;
kwsys_shared_forward_execvp(ldd_argv[0], ldd_argv);
/* Report why execution failed. */
kwsys_shared_forward_print_failure(ldd_argv);
return 1;
# else
/* We have no ldd-like executable available on this platform. */
fprintf(stderr, "No ldd-like tool is known to this executable.\n");
return 1;
# endif
}
# endif
/* Replace this process with the real executable. */
argv[0] = exe;
kwsys_shared_forward_execvp(argv[0], argv);
/* Report why execution failed. */
kwsys_shared_forward_print_failure(argv);
} else {
/* Could not convert self path to the library directory. */
}
} else {
/* Could not find this executable. */
fprintf(stderr, "Error locating executable \"%s\".\n", argv[0]);
}
/* Avoid unused argument warning. */
(void)argc;
/* Exit with failure. */
return 1;
}
/* Restore warning stack. */
# if defined(__clang__) && defined(__has_warning)
# if __has_warning("-Wcast-qual")
# pragma clang diagnostic pop
# endif
# endif
#else
# error "@KWSYS_NAMESPACE@/SharedForward.h should be included only once."
#endif
SystemTools.cxx
+1 -28
View File
@@ -3418,44 +3418,17 @@ bool SystemTools::SplitProgramPath(const std::string& in_name,
}
bool SystemTools::FindProgramPath(const char* argv0, std::string& pathOut,
std::string& errorMsg, const char* exeName,
const char* buildDir,
const char* installPrefix)
std::string& errorMsg)
{
std::vector<std::string> failures;
std::string self = argv0 ? argv0 : "";
failures.push_back(self);
SystemTools::ConvertToUnixSlashes(self);
self = SystemTools::FindProgram(self);
if (!SystemTools::FileIsExecutable(self)) {
if (buildDir) {
std::string intdir = ".";
#ifdef CMAKE_INTDIR
intdir = CMAKE_INTDIR;
#endif
self = buildDir;
self += "/bin/";
self += intdir;
self += "/";
self += exeName;
self += SystemTools::GetExecutableExtension();
}
}
if (installPrefix) {
if (!SystemTools::FileIsExecutable(self)) {
failures.push_back(self);
self = installPrefix;
self += "/bin/";
self += exeName;
}
}
if (!SystemTools::FileIsExecutable(self)) {
failures.push_back(self);
std::ostringstream msg;
msg << "Can not find the command line program ";
if (exeName) {
msg << exeName;
}
msg << "\n";
if (argv0) {
msg << " argv[0] = \"" << argv0 << "\"\n";
SystemTools.hxx.in
+1 -4
View File
@@ -395,10 +395,7 @@ public:
* installPrefix is a possibly null pointer to the install directory.
*/
static bool FindProgramPath(const char* argv0, std::string& pathOut,
std::string& errorMsg,
const char* exeName = nullptr,
const char* buildDir = nullptr,
const char* installPrefix = nullptr);
std::string& errorMsg);
/**
* Given a path to a file or directory, convert it to a full path.
testDynamicLoader.cxx
+2 -2
View File
@@ -53,9 +53,9 @@ static std::string GetLibName(const char* lname, const char* subdir = nullptr)
slname += "/";
slname += subdir;
}
#ifdef CMAKE_INTDIR
#ifdef BUILD_CONFIG
slname += "/";
slname += CMAKE_INTDIR;
slname += BUILD_CONFIG;
#endif
slname += "/";
slname += kwsys::DynamicLoader::LibPrefix();
testSharedForward.c.in
-31
View File
@@ -1,31 +0,0 @@
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing#kwsys for details. */
#if !defined(_WIN32) && !defined(__APPLE__) && !defined(__OpenBSD__)
/* NOLINTNEXTLINE(bugprone-reserved-identifier) */
# define _XOPEN_SOURCE 600
#endif
#if defined(CMAKE_INTDIR)
# define CONFIG_DIR_PRE CMAKE_INTDIR "/"
# define CONFIG_DIR_POST "/" CMAKE_INTDIR
#else
# define CONFIG_DIR_PRE ""
# define CONFIG_DIR_POST ""
#endif
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD "@EXEC_DIR@"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_BUILD "." CONFIG_DIR_POST
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_PATH_INSTALL 0
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_BUILD \
CONFIG_DIR_PRE "@KWSYS_NAMESPACE@TestProcess"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_EXE_INSTALL \
"@KWSYS_NAMESPACE@TestProcess"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_COMMAND "--command"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_PRINT "--print"
#define @KWSYS_NAMESPACE@_SHARED_FORWARD_OPTION_LDD "--ldd"
#if defined(CMAKE_INTDIR)
# define @KWSYS_NAMESPACE@_SHARED_FORWARD_CONFIG_NAME CMAKE_INTDIR
#endif
#include <@KWSYS_NAMESPACE@/SharedForward.h>
int main(int argc, char** argv)
{
return @KWSYS_NAMESPACE@_shared_forward_to_real(argc, argv);
}