mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 06:09:01 +00:00
569 lines
16 KiB
C++
569 lines
16 KiB
C++
//
|
|
// Copyright (c) 2017 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
#include "os_helpers.h"
|
|
#include "errorHelpers.h"
|
|
|
|
// =================================================================================================
|
|
// C++ interface.
|
|
// =================================================================================================
|
|
|
|
#include <cerrno> // errno, error constants
|
|
#include <climits> // PATH_MAX
|
|
#include <cstdlib> // abort, _splitpath, _makepath
|
|
#include <cstring> // strdup, strerror_r
|
|
#include <sstream>
|
|
|
|
#include <vector>
|
|
|
|
#if defined(__ANDROID__)
|
|
#include <android/api-level.h>
|
|
#endif
|
|
|
|
#define CHECK_PTR( ptr ) \
|
|
if ( (ptr) == NULL ) { \
|
|
abort(); \
|
|
}
|
|
|
|
typedef std::vector< char > buffer_t;
|
|
|
|
#if ! defined( PATH_MAX )
|
|
#define PATH_MAX 1000
|
|
#endif
|
|
|
|
int const _size = PATH_MAX + 1; // Initial buffer size for path.
|
|
int const _count = 8; // How many times we will try to double buffer size.
|
|
|
|
// -------------------------------------------------------------------------------------------------
|
|
// MacOS X
|
|
// -------------------------------------------------------------------------------------------------
|
|
|
|
#if defined( __APPLE__ )
|
|
|
|
|
|
#include <mach-o/dyld.h> // _NSGetExecutablePath
|
|
#include <libgen.h> // dirname
|
|
|
|
|
|
static
|
|
std::string
|
|
_err_msg(
|
|
int err, // Error number (e. g. errno).
|
|
int level // Nesting level, for avoiding infinite recursion.
|
|
) {
|
|
|
|
/*
|
|
There are 3 incompatible versions of strerror_r:
|
|
|
|
char * strerror_r( int, char *, size_t ); // GNU version
|
|
int strerror_r( int, char *, size_t ); // BSD version
|
|
int strerror_r( int, char *, size_t ); // XSI version
|
|
|
|
BSD version returns error code, while XSI version returns 0 or -1 and sets errno.
|
|
|
|
*/
|
|
|
|
// BSD version of strerror_r.
|
|
buffer_t buffer( 100 );
|
|
int count = _count;
|
|
for ( ; ; ) {
|
|
int rc = strerror_r( err, & buffer.front(), buffer.size() );
|
|
if ( rc == EINVAL ) {
|
|
// Error code is not recognized, but anyway we got the message.
|
|
return & buffer.front();
|
|
} else if ( rc == ERANGE ) {
|
|
// Buffer is not enough.
|
|
if ( count > 0 ) {
|
|
// Enlarge the buffer.
|
|
-- count;
|
|
buffer.resize( buffer.size() * 2 );
|
|
} else {
|
|
std::stringstream ostr;
|
|
ostr
|
|
<< "Error " << err << " "
|
|
<< "(Getting error message failed: "
|
|
<< "Buffer of " << buffer.size() << " bytes is still too small"
|
|
<< ")";
|
|
return ostr.str();
|
|
}; // if
|
|
} else if ( rc == 0 ) {
|
|
// We got the message.
|
|
return & buffer.front();
|
|
} else {
|
|
std::stringstream ostr;
|
|
ostr
|
|
<< "Error " << err << " "
|
|
<< "(Getting error message failed: "
|
|
<< ( level < 2 ? _err_msg( rc, level + 1 ) : "Oops" )
|
|
<< ")";
|
|
return ostr.str();
|
|
}; // if
|
|
}; // forever
|
|
|
|
} // _err_msg
|
|
|
|
|
|
std::string
|
|
dir_sep(
|
|
) {
|
|
return "/";
|
|
} // dir_sep
|
|
|
|
|
|
std::string
|
|
exe_path(
|
|
) {
|
|
buffer_t path( _size );
|
|
int count = _count;
|
|
for ( ; ; ) {
|
|
uint32_t size = path.size();
|
|
int rc = _NSGetExecutablePath( & path.front(), & size );
|
|
if ( rc == 0 ) {
|
|
break;
|
|
}; // if
|
|
if ( count > 0 ) {
|
|
-- count;
|
|
path.resize( size );
|
|
} else {
|
|
log_error(
|
|
"ERROR: Getting executable path failed: "
|
|
"_NSGetExecutablePath failed: Buffer of %lu bytes is still too small\n",
|
|
(unsigned long) path.size()
|
|
);
|
|
exit( 2 );
|
|
}; // if
|
|
}; // forever
|
|
return & path.front();
|
|
} // exe_path
|
|
|
|
|
|
std::string
|
|
exe_dir(
|
|
) {
|
|
std::string path = exe_path();
|
|
// We cannot pass path.c_str() to `dirname' bacause `dirname' modifies its argument.
|
|
buffer_t buffer( path.c_str(), path.c_str() + path.size() + 1 ); // Copy with trailing zero.
|
|
return dirname( & buffer.front() );
|
|
} // exe_dir
|
|
|
|
|
|
#endif // __APPLE__
|
|
|
|
// -------------------------------------------------------------------------------------------------
|
|
// Linux
|
|
// -------------------------------------------------------------------------------------------------
|
|
|
|
#if defined( __linux__ )
|
|
|
|
|
|
#include <cerrno> // errno
|
|
#include <libgen.h> // dirname
|
|
#include <unistd.h> // readlink
|
|
|
|
|
|
static
|
|
std::string
|
|
_err_msg(
|
|
int err,
|
|
int level
|
|
) {
|
|
|
|
/*
|
|
There are 3 incompatible versions of strerror_r:
|
|
|
|
char * strerror_r( int, char *, size_t ); // GNU version
|
|
int strerror_r( int, char *, size_t ); // BSD version
|
|
int strerror_r( int, char *, size_t ); // XSI version
|
|
|
|
BSD version returns error code, while XSI version returns 0 or -1 and sets errno.
|
|
|
|
*/
|
|
|
|
#if (defined(__ANDROID__) && __ANDROID_API__ < 23) || ( ( _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 ) && ! _GNU_SOURCE )
|
|
|
|
// XSI version of strerror_r.
|
|
#warning Not tested!
|
|
buffer_t buffer( 200 );
|
|
int count = _count;
|
|
for ( ; ; ) {
|
|
int rc = strerror_r( err, & buffer.front(), buffer.size() );
|
|
if ( rc == -1 ) {
|
|
int _err = errno;
|
|
if ( _err == ERANGE ) {
|
|
if ( count > 0 ) {
|
|
// Enlarge the buffer.
|
|
-- count;
|
|
buffer.resize( buffer.size() * 2 );
|
|
} else {
|
|
std::stringstream ostr;
|
|
ostr
|
|
<< "Error " << err << " "
|
|
<< "(Getting error message failed: "
|
|
<< "Buffer of " << buffer.size() << " bytes is still too small"
|
|
<< ")";
|
|
return ostr.str();
|
|
}; // if
|
|
} else {
|
|
std::stringstream ostr;
|
|
ostr
|
|
<< "Error " << err << " "
|
|
<< "(Getting error message failed: "
|
|
<< ( level < 2 ? _err_msg( _err, level + 1 ) : "Oops" )
|
|
<< ")";
|
|
return ostr.str();
|
|
}; // if
|
|
} else {
|
|
// We got the message.
|
|
return & buffer.front();
|
|
}; // if
|
|
}; // forever
|
|
|
|
#else
|
|
|
|
// GNU version of strerror_r.
|
|
char buffer[ 2000 ];
|
|
return strerror_r( err, buffer, sizeof( buffer ) );
|
|
|
|
#endif
|
|
|
|
} // _err_msg
|
|
|
|
|
|
std::string
|
|
dir_sep(
|
|
) {
|
|
return "/";
|
|
} // dir_sep
|
|
|
|
|
|
std::string
|
|
exe_path(
|
|
) {
|
|
|
|
static std::string const exe = "/proc/self/exe";
|
|
|
|
buffer_t path( _size );
|
|
int count = _count; // Max number of iterations.
|
|
|
|
for ( ; ; ) {
|
|
|
|
ssize_t len = readlink( exe.c_str(), & path.front(), path.size() );
|
|
|
|
if ( len < 0 ) {
|
|
// Oops.
|
|
int err = errno;
|
|
log_error(
|
|
"ERROR: Getting executable path failed: "
|
|
"Reading symlink `%s' failed: %s\n",
|
|
exe.c_str(), err_msg( err ).c_str()
|
|
);
|
|
exit( 2 );
|
|
}; // if
|
|
|
|
if ( len < path.size() ) {
|
|
// We got the path.
|
|
path.resize( len );
|
|
break;
|
|
}; // if
|
|
|
|
// Oops, buffer is too small.
|
|
if ( count > 0 ) {
|
|
-- count;
|
|
// Enlarge the buffer.
|
|
path.resize( path.size() * 2 );
|
|
} else {
|
|
log_error(
|
|
"ERROR: Getting executable path failed: "
|
|
"Reading symlink `%s' failed: Buffer of %lu bytes is still too small\n",
|
|
exe.c_str(),
|
|
(unsigned long) path.size()
|
|
);
|
|
exit( 2 );
|
|
}; // if
|
|
|
|
}; // forever
|
|
|
|
return std::string( & path.front(), path.size() );
|
|
|
|
} // exe_path
|
|
|
|
|
|
std::string
|
|
exe_dir(
|
|
) {
|
|
std::string path = exe_path();
|
|
// We cannot pass path.c_str() to `dirname' bacause `dirname' modifies its argument.
|
|
buffer_t buffer( path.c_str(), path.c_str() + path.size() + 1 ); // Copy with trailing zero.
|
|
return dirname( & buffer.front() );
|
|
} // exe_dir
|
|
|
|
#endif // __linux__
|
|
|
|
// -------------------------------------------------------------------------------------------------
|
|
// MS Windows
|
|
// -------------------------------------------------------------------------------------------------
|
|
|
|
#if defined( _WIN32 )
|
|
|
|
|
|
#include <windows.h>
|
|
#if defined( max )
|
|
#undef max
|
|
#endif
|
|
|
|
#include <cctype>
|
|
#include <algorithm>
|
|
|
|
|
|
static
|
|
std::string
|
|
_err_msg(
|
|
int err,
|
|
int level
|
|
) {
|
|
|
|
std::string msg;
|
|
|
|
LPSTR buffer = NULL;
|
|
DWORD flags =
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
FORMAT_MESSAGE_IGNORE_INSERTS;
|
|
|
|
DWORD len =
|
|
FormatMessageA(
|
|
flags,
|
|
NULL,
|
|
err,
|
|
LANG_USER_DEFAULT,
|
|
reinterpret_cast< LPSTR >( & buffer ),
|
|
0,
|
|
NULL
|
|
);
|
|
|
|
if ( buffer == NULL || len == 0 ) {
|
|
|
|
int _err = GetLastError();
|
|
char str[1024] = { 0 };
|
|
snprintf(str, sizeof(str), "Error 0x%08x (Getting error message failed: %s )", err, ( level < 2 ? _err_msg( _err, level + 1 ).c_str() : "Oops" ));
|
|
msg = std::string(str);
|
|
|
|
} else {
|
|
|
|
// Trim trailing whitespace (including `\r' and `\n').
|
|
while ( len > 0 && isspace( buffer[ len - 1 ] ) ) {
|
|
-- len;
|
|
}; // while
|
|
|
|
// Drop trailing full stop.
|
|
if ( len > 0 && buffer[ len - 1 ] == '.' ) {
|
|
-- len;
|
|
}; // if
|
|
|
|
msg.assign( buffer, len );
|
|
|
|
}; //if
|
|
|
|
if ( buffer != NULL ) {
|
|
LocalFree( buffer );
|
|
}; // if
|
|
|
|
return msg;
|
|
|
|
} // _get_err_msg
|
|
|
|
|
|
std::string
|
|
dir_sep(
|
|
) {
|
|
return "\\";
|
|
} // dir_sep
|
|
|
|
|
|
std::string
|
|
exe_path(
|
|
) {
|
|
|
|
buffer_t path( _size );
|
|
int count = _count;
|
|
|
|
for ( ; ; ) {
|
|
|
|
DWORD len = GetModuleFileNameA( NULL, & path.front(), path.size() );
|
|
|
|
if ( len == 0 ) {
|
|
int err = GetLastError();
|
|
log_error( "ERROR: Getting executable path failed: %s\n", err_msg( err ).c_str() );
|
|
exit( 2 );
|
|
}; // if
|
|
|
|
if ( len < path.size() ) {
|
|
path.resize( len );
|
|
break;
|
|
}; // if
|
|
|
|
// Buffer too small.
|
|
if ( count > 0 ) {
|
|
-- count;
|
|
path.resize( path.size() * 2 );
|
|
} else {
|
|
log_error(
|
|
"ERROR: Getting executable path failed: "
|
|
"Buffer of %lu bytes is still too small\n",
|
|
(unsigned long) path.size()
|
|
);
|
|
exit( 2 );
|
|
}; // if
|
|
|
|
}; // forever
|
|
|
|
return std::string( & path.front(), path.size() );
|
|
|
|
} // exe_path
|
|
|
|
|
|
std::string
|
|
exe_dir(
|
|
) {
|
|
|
|
std::string exe = exe_path();
|
|
int count = 0;
|
|
|
|
// Splitting path into components.
|
|
buffer_t drv( _MAX_DRIVE );
|
|
buffer_t dir( _MAX_DIR );
|
|
count = _count;
|
|
#if defined(_MSC_VER)
|
|
for ( ; ; ) {
|
|
int rc =
|
|
_splitpath_s(
|
|
exe.c_str(),
|
|
& drv.front(), drv.size(),
|
|
& dir.front(), dir.size(),
|
|
NULL, 0, // We need neither name
|
|
NULL, 0 // nor extension
|
|
);
|
|
if ( rc == 0 ) {
|
|
break;
|
|
} else if ( rc == ERANGE ) {
|
|
if ( count > 0 ) {
|
|
-- count;
|
|
// Buffer is too small, but it is not clear which one.
|
|
// So we have to enlarge all.
|
|
drv.resize( drv.size() * 2 );
|
|
dir.resize( dir.size() * 2 );
|
|
} else {
|
|
log_error(
|
|
"ERROR: Getting executable path failed: "
|
|
"Splitting path `%s' to components failed: "
|
|
"Buffers of %lu and %lu bytes are still too small\n",
|
|
exe.c_str(),
|
|
(unsigned long) drv.size(),
|
|
(unsigned long) dir.size()
|
|
);
|
|
exit( 2 );
|
|
}; // if
|
|
} else {
|
|
log_error(
|
|
"ERROR: Getting executable path failed: "
|
|
"Splitting path `%s' to components failed: %s\n",
|
|
exe.c_str(),
|
|
err_msg( rc ).c_str()
|
|
);
|
|
exit( 2 );
|
|
}; // if
|
|
}; // forever
|
|
|
|
#else // __MINGW32__
|
|
|
|
// MinGW does not have the "secure" _splitpath_s, use the insecure version instead.
|
|
_splitpath(
|
|
exe.c_str(),
|
|
& drv.front(),
|
|
& dir.front(),
|
|
NULL, // We need neither name
|
|
NULL // nor extension
|
|
);
|
|
#endif // __MINGW32__
|
|
|
|
// Combining components back to path.
|
|
// I failed with "secure" `_makepath_s'. If buffer is too small, instead of returning
|
|
// ERANGE, `_makepath_s' pops up dialog box and offers to debug the program. D'oh!
|
|
// So let us try to guess the size of result and go with insecure `_makepath'.
|
|
buffer_t path( std::max( drv.size() + dir.size(), size_t( _MAX_PATH ) ) + 10 );
|
|
_makepath( & path.front(), & drv.front(), & dir.front(), NULL, NULL );
|
|
|
|
return & path.front();
|
|
|
|
} // exe_dir
|
|
|
|
|
|
#endif // _WIN32
|
|
|
|
|
|
std::string
|
|
err_msg(
|
|
int err
|
|
) {
|
|
|
|
return _err_msg( err, 0 );
|
|
|
|
} // err_msg
|
|
|
|
|
|
// =================================================================================================
|
|
// C interface.
|
|
// =================================================================================================
|
|
|
|
|
|
char *
|
|
get_err_msg(
|
|
int err
|
|
) {
|
|
char * msg = strdup( err_msg( err ).c_str() );
|
|
CHECK_PTR( msg );
|
|
return msg;
|
|
} // get_err_msg
|
|
|
|
|
|
char *
|
|
get_dir_sep(
|
|
) {
|
|
char * sep = strdup( dir_sep().c_str() );
|
|
CHECK_PTR( sep );
|
|
return sep;
|
|
} // get_dir_sep
|
|
|
|
|
|
char *
|
|
get_exe_path(
|
|
) {
|
|
char * path = strdup( exe_path().c_str() );
|
|
CHECK_PTR( path );
|
|
return path;
|
|
} // get_exe_path
|
|
|
|
|
|
char *
|
|
get_exe_dir(
|
|
) {
|
|
char * dir = strdup( exe_dir().c_str() );
|
|
CHECK_PTR( dir );
|
|
return dir;
|
|
} // get_exe_dir
|
|
|
|
|
|
// end of file //
|