6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-11-01 15:11:24 +00:00
Code Issues Projects Releases Wiki Activity

Remove lib/System contents until a satisfactory solution can be

Browse Source 
provided.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15816 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Reid Spencer 2004-08-16 07:08:38 +00:00
parent 2a069fa003
commit 08bfab175a
7 changed files with 0 additions and 828 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
lib/System/ErrorCode.cpp
View File

@ -1,38 +0,0 @@
//===- ErrorCode.cpp - Define the ErrorCode class ---------------*- C++ -*-===//
//
// Copyright (C) 2004 eXtensible Systems, Inc. All Rights Reserved.
//
// This program is open source software; you can redistribute it and/or modify
// it under the terms of the University of Illinois Open Source License. See
// LICENSE.TXT (distributed with this software) for details.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.
//
//===----------------------------------------------------------------------===//
//
// This file defines the members of the llvm::sys::ErrorCode class. This class
// is used to hold operating system and other error codes in a platform
// agnostic manner.
//
//===----------------------------------------------------------------------===//
/// @file lib/System/ErrorCode.h
/// @author Reid Spencer <raspencer@x10sys.com> (original author)
/// @version \verbatim $Id$ \endverbatim
/// @date 2004/08/14
/// @since 1.4
/// @brief Declares the llvm::sys::ErrorCode class.
//===----------------------------------------------------------------------===//
#include "llvm/System/ErrorCode.h"
namespace llvm {
namespace sys {
}
}
#include "linux/ErrorCode.cpp"
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab

13
lib/System/Makefile
View File

@ -1,13 +0,0 @@
##===- lib/System/Makefile ---------------------------------*- Makefile -*-===##
#
# The LLVM Compiler Infrastructure
#
# This file was developed by Reid Spencer and is distributed under the
# University of Illinois Open Source License. See LICENSE.TXT for details.
#
##===----------------------------------------------------------------------===##
LEVEL = ../..
LIBRARYNAME = system
BUILD_ARCHIVE = 1
include $(LEVEL)/Makefile.common

90
lib/System/Path.cpp
View File

@ -1,90 +0,0 @@
//===- Path.cpp - Path Operating System Concept -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// Copyright (C) 2004 eXtensible Systems, Inc. All Rights Reserved.
//
// This program is open source software; you can redistribute it and/or modify
// it under the terms of the University of Illinois Open Source License. See
// LICENSE.TXT (distributed with this software) for details.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.
//
//===----------------------------------------------------------------------===//
//
// This file implements the common Path concept for a variety of platforms.
// A path is simply the name of some file system storage place. Paths can be
// either directories or files.
//
//===----------------------------------------------------------------------===//
/// @file lib/System/Path.cpp
/// @author Reid Spencer <raspencer@x10sys.com> (original author)
/// @version \verbatim $Id$ \endverbatim
/// @date 2004/08/14
/// @since 1.4
/// @brief Defines the llvm::sys::Path class.
//===----------------------------------------------------------------------===//
#include "llvm/System/Path.h"
namespace llvm {
namespace sys {
ErrorCode
Path::append_directory( const std::string& dirname ) throw() {
this->append( dirname );
make_directory();
return NOT_AN_ERROR;
}
ErrorCode
Path::append_file( const std::string& filename ) throw() {
this->append( filename );
return NOT_AN_ERROR;
}
ErrorCode
Path::create( bool create_parents)throw() {
ErrorCode result ( NOT_AN_ERROR );
if ( is_directory() ) {
if ( create_parents ) {
result = this->create_directories( );
} else {
result = this->create_directory( );
}
} else if ( is_file() ) {
if ( create_parents ) {
result = this->create_directories( );
}
if ( result ) {
result = this->create_file( );
}
} else {
result = ErrorCode(ERR_SYS_INVALID_ARG);
}
return result;
}
ErrorCode
Path::remove() throw() {
ErrorCode result( NOT_AN_ERROR );
if ( is_directory() ) {
if ( exists() )
this->remove_directory( );
} else if ( is_file() ) {
if ( exists() ) this->remove_file( );
} else {
result = ErrorCode(ERR_SYS_INVALID_ARG);
}
return result;
}
}
}
// Include the platform specific portions of this class
#include "linux/Path.cpp"
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab

23
lib/System/README.txt
View File

@ -1,23 +0,0 @@
System Utilities Interface
==========================
The design of this library has several key constraints aimed at shielding LLVM
from the vagaries of operating system differences. The goal here is to provide
interfaces to operating system concepts (files, memory maps, sockets, signals,
locking, etc) efficiently and in such a way that the remainder of LLVM is
completely operating system agnostic.
PLEASE READ AND COMPREHEND FULLY THE DOCUMENTATION in
llvm/docs/SystemLibrary.html
before making changes to this library.
Briefly, the rules are:
1. This library may not expose no system-specific header files (STL excepted).
2. This library may not allocate memory (directly).
3. This library may not throw exceptions.
4. This library may not use virtual methods in its classes.
5. This library may not expose system specific types, data or functions through
its interface

57
lib/System/linux/ErrorCode.cpp
View File

@ -1,57 +0,0 @@
//===- ErrorCode.cpp - Define the ErrorCode class ---------------*- C++ -*-===//
//
// Copyright (C) 2004 eXtensible Systems, Inc. All Rights Reserved.
//
// This program is open source software; you can redistribute it and/or modify
// it under the terms of the University of Illinois Open Source License. See
// LICENSE.TXT (distributed with this software) for details.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.
//
//===----------------------------------------------------------------------===//
//
// This file defines the linux specific members of the llvm::sys::ErrorCode
// class.
//
//===----------------------------------------------------------------------===//
/// @file lib/System/ErrorCode.h
/// @author Reid Spencer <raspencer@x10sys.com> (original author)
/// @version \verbatim $Id$ \endverbatim
/// @date 2004/08/14
/// @since 1.4
/// @brief Declares the linux specific methods of llvm::sys::ErrorCode class.
//===----------------------------------------------------------------------===//
namespace llvm {
namespace sys {
std::string
ErrorCode::description() const throw()
{
switch (domain()) {
case OSDomain:
char buffer[1024];
if (0 != strerror_r(index(),buffer,1024) )
return "<Error Message Unavalabile>";
return buffer;
case SystemDomain:
switch (index()) {
case ERR_SYS_INVALID_ARG:
return "Invalid argument to lib/System call";
default:
return "Unknown lib/System Error";
}
break;
default:
return "Unknown Error";
}
}
}
}
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab

157
lib/System/linux/LinuxCommon.h
View File

@ -1,157 +0,0 @@
//===- LinuxCommon.h - Common Declarations For Linux ------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// Copyright (C) 2004 eXtensible Systems, Inc. All Rights Reserved.
//
// This program is open source software; you can redistribute it and/or modify
// it under the terms of the University of Illinois Open Source License. See
// LICENSE.TXT (distributed with this software) for details.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.
//
//===----------------------------------------------------------------------===//
/// @file lib/System/linux/Common.h
/// @author Reid Spencer <rspencer@x10sys.com> (original author)
/// @version \verbatim $Id$ \endverbatim
/// @date 2004/08/14
/// @since 1.4
/// @brief Provides common linux specific declarations and includes.
//===----------------------------------------------------------------------===//
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/param.h>
#include <pthread.h>
#define FATAL(arg) \
{ llvm::sys::panic(LLVM_CONTEXT, arg); }
#define RETURN_ERRNO \
return ErrorCode(LLVM_ERROR_CODE(OSDomain,errno))
#define RETURN_OSERROR(code) \
return ErrorCode(LLVM_ERROR_CODE(OSDomain,code))
#ifdef assert
#define ASSERT_ARG(expr) \
if ( ! (expr) ) {\
return ErrorCode(ERR_SYS_INVALID_ARG);\
}
#else
#define ASSERT_ARG(expr)
#endif
#define CHECK(var,call,args,msg) \
{ \
if ( -1 == ( var = ::call args )) { \
panic(LLVM_CONTEXT, msg); \
} \
}
#define RETURN_ON_ERROR(call,args) \
{ \
errno = 0; \
if ( 0 > ( call args ) ) { \
RETURN_ERRNO; \
} \
}
#define RETURN_ON_ERRORCODE(call,args) \
{ \
ErrorCode code = call args ; \
if ( ! code ) \
return code; \
}
#define PTHREAD_CALL( call, args, cleanup ) \
{ \
int errcode = ::call args ; \
if ( errcode != 0 ) { \
cleanup ; \
RETURN_ERRNO ; \
} \
}
#define CLEANUP_CALL( call, args, cleanup ) \
{ \
int result = call args ; \
if ( result != 0 ) { \
cleanup ; \
RETURN_ERRNO ; \
} \
}
// Define our realtime signals
#define SIG_LOOP_TERMINATE ( SIGRTMIN + 3 )
#define SIG_USER_EVENT_1 ( SIGRTMIN + 4 )
#define SIG_USER_EVENT_2 ( SIGRTMIN + 5 )
#define SIG_USER_EVENT_3 ( SIGRTMIN + 6 )
#define SIG_USER_EVENT_4 ( SIGRTMIN + 7 )
#define SIG_USER_EVENT_5 ( SIGRTMIN + 8 )
#define SIG_USER_EVENT_6 ( SIGRTMIN + 9 )
#define SIG_USER_EVENT_7 ( SIGRTMIN + 10 )
#define SIG_USER_EVENT_8 ( SIGRTMIN + 11 )
#define SIG_AIO_1 ( SIGRTMIN + 12 )
#define SIG_AIO_2 ( SIGRTMIN + 13 )
#define SIG_AIO_3 ( SIGRTMIN + 14 )
#define SIG_AIO_4 ( SIGRTMIN + 15 )
#define SIG_AIO_5 ( SIGRTMIN + 16 )
#define SIG_AIO_6 ( SIGRTMIN + 17 )
#define SIG_AIO_7 ( SIGRTMIN + 18 )
#define SIG_AIO_8 ( SIGRTMIN + 19 )
namespace llvm {
namespace sys {
#if 0
inline void
time_t2TimeValue( time_t t, TimeValue &tv )
{
TimeValue::Seconds_Type seconds = t;
seconds -= TimeValue::posix_zero_time.seconds();
tv.set( seconds, 0 );
}
inline void
TimeValue2timespec( const TimeValue& tv, struct timespec & ts )
{
uint64_t seconds;
uint64_t nanos;
tv.timespec_time( seconds, nanos );
ts.tv_sec = static_cast<time_t>(seconds);
ts.tv_nsec = static_cast<long int>(nanos);
}
inline void
timeval2TimeValue( struct timeval& tval, TimeValue& tv )
{
TimeValue::Seconds_Type seconds = tval.tv_sec;
seconds -= TimeValue::posix_zero_time.seconds();
tv.set( seconds, tval.tv_usec * XPS_NANOSECONDS_PER_MICROSECOND );
}
extern pid_t pid_; ///< This processes' process identification number
extern int pagesize_; ///< The virtual memory page size of this machine
extern long arg_max_; ///< The maximum size in bytes of arguments to exec()
extern long child_max_; ///< The maximum processes per user.
extern long clk_tck_; ///< The number of clock ticks per second on this machine
extern long stream_max_; ///< The maximum number of streams that can be opened
extern long tzname_max_; ///< The maximum length of a timezone name
extern long file_max_; ///< The maximum number of files that can be opened
extern long line_max_; ///< The maximum length of an I/O line
extern long job_control_; ///< Non-zero if POSIX job control enabled
extern long saved_ids_; ///< ?
extern long phys_pages_; ///< Total number of physical pages
extern long avphys_pages_; ///< Average number of free physical pages
#endif
}
}
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab

450
lib/System/linux/Path.cpp
View File

@ -1,450 +0,0 @@
//===- Path.cpp - Path Operating System Concept -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// Copyright (C) 2004 eXtensible Systems, Inc. All Rights Reserved.
//
// This program is open source software; you can redistribute it and/or modify
// it under the terms of the University of Illinois Open Source License. See
// LICENSE.TXT (distributed with this software) for details.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
/// @file lib/System/linux/Path.cpp
/// @author Reid Spencer <raspencer@users.sourceforge.net> (original author)
/// @version \verbatim $Id$ \endverbatim
/// @date 2003/04/17
/// @since 1.4
/// @brief Implements the linux specific portion of class llvm::sys::Path
////////////////////////////////////////////////////////////////////////////////
#include "LinuxCommon.h"
#include <sys/stat.h>
#include <fcntl.h>
namespace llvm {
namespace sys {
Path::Path(ConstructSpecial which) throw() {
switch (which) {
case CONSTRUCT_TEMP_FILE:
this->make_temp_file();
break;
case CONSTRUCT_TEMP_DIR:
this->make_temp_directory();
break;
}
}
bool
Path::is_file() const throw() {
if ( !empty() && ((*this)[length()-1] != '/' ))
return true;
return false;
}
bool
Path::is_directory() const throw() {
if ((!empty()) && ((*this)[length()-1] == '/' ))
return true;
return false;
}
ErrorCode
Path::make_directory() throw() {
char end[2];
end[0] = '/';
end[1] = 0;
if ( empty() )
this->assign( end );
else if ( (*this)[length()-1] != '/' )
this->append( end );
return NOT_AN_ERROR;
}
ErrorCode
Path::make_temp_directory() throw() {
char temp_name[64];
::strcpy(temp_name,"/tmp/llvm_XXXXXX");
char* res = ::mkdtemp(temp_name);
if ( res == 0 )
RETURN_ERRNO;
*this = temp_name;
make_directory();
return NOT_AN_ERROR;
}
ErrorCode
Path::make_file() throw() {
if ( (*this)[length()-1] == '/' )
this->erase( this->length()-1, 1 );
return NOT_AN_ERROR;
}
ErrorCode
Path::make_temp_file() throw() {
char temp_name[64];
::strcpy(temp_name,"/tmp/llvm_XXXXXX");
int fd = ::mkstemp(temp_name);
if ( fd == -1 )
RETURN_ERRNO;
::close(fd);
*this = temp_name;
return NOT_AN_ERROR;
}
ErrorCode
Path::exists() throw() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
RETURN_ON_ERROR( access,( pathname, F_OK | R_OK ) );
return NOT_AN_ERROR;
}
ErrorCode
Path::create_directory() throw() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
RETURN_ON_ERROR( mkdir, ( pathname, S_IRWXU | S_IRWXG ) );
return NOT_AN_ERROR;
}
ErrorCode
Path::create_directories() throw() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
char * next = index(pathname,'/');
if ( pathname[0] == '/' )
next = index(&pathname[1],'/');
while ( next != 0 )
{
*next = 0;
if ( 0 != access( pathname, F_OK | R_OK ) )
RETURN_ON_ERROR( mkdir, (pathname, S_IRWXU | S_IRWXG ) );
char* save = next;
next = index(pathname,'/');
*save = '/';
}
return NOT_AN_ERROR;
}
ErrorCode
Path::remove_directory( ) throw() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
RETURN_ON_ERROR( rmdir, (pathname) );
return NOT_AN_ERROR;
}
ErrorCode
Path::create_file( ) throw() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
RETURN_ON_ERROR( creat, ( pathname, S_IRUSR | S_IWUSR ) );
return NOT_AN_ERROR;
}
ErrorCode
Path::remove_file( ) throw() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
RETURN_ON_ERROR( unlink, (pathname) );
return NOT_AN_ERROR;
}
ErrorCode
Path::find_lib( const char * file ) throw()
{
ASSERT_ARG( file != 0 );
#if 0
ACE_TCHAR tempcopy[MAXPATHLEN + 1];
ACE_TCHAR searchpathname[MAXPATHLEN + 1];
ACE_TCHAR searchfilename[MAXPATHLEN + 1];
// Create a copy of filename to work with.
if (ACE_OS::strlen (filename) + 1
> (sizeof tempcopy / sizeof (ACE_TCHAR)))
{
errno = ENOMEM;
return -1;
}
else
ACE_OS::strcpy (tempcopy, filename);
// Insert canonical directory separators.
ACE_TCHAR *separator_ptr;
#if (ACE_DIRECTORY_SEPARATOR_CHAR != '/')
// Make all the directory separators "canonical" to simplify
// subsequent code.
ACE_Lib_Find::strrepl (tempcopy, ACE_DIRECTORY_SEPARATOR_CHAR, '/');
#endif /* ACE_DIRECTORY_SEPARATOR_CHAR */
// Separate filename from pathname.
separator_ptr = ACE_OS::strrchr (tempcopy, '/');
// This is a relative path.
if (separator_ptr == 0)
{
searchpathname[0] = '\0';
ACE_OS::strcpy (searchfilename, tempcopy);
}
else // This is an absolute path.
{
ACE_OS::strcpy (searchfilename, separator_ptr + 1);
separator_ptr[1] = '\0';
ACE_OS::strcpy (searchpathname, tempcopy);
}
int got_suffix = 0;
// Check to see if this has an appropriate DLL suffix for the OS
// platform.
ACE_TCHAR *s = ACE_OS::strrchr (searchfilename, '.');
const ACE_TCHAR *dll_suffix = ACE_DLL_SUFFIX;
if (s != 0)
{
// If we have a dot, we have a suffix
got_suffix = 1;
// Check whether this matches the appropriate platform-specific
// suffix.
if (ACE_OS::strcmp (s, dll_suffix) != 0)
{
ACE_ERROR ((LM_WARNING,
ACE_LIB_TEXT ("Warning: improper suffix for a ")
ACE_LIB_TEXT ("shared library on this platform: %s\n"),
s));
}
}
// Make sure we've got enough space in searchfilename.
if (ACE_OS::strlen (searchfilename)
+ ACE_OS::strlen (ACE_DLL_PREFIX)
+ got_suffix ? 0 : ACE_OS::strlen (dll_suffix) >= (sizeof searchfilename /
sizeof (ACE_TCHAR)))
{
errno = ENOMEM;
return -1;
}
// Use absolute pathname if there is one.
if (ACE_OS::strlen (searchpathname) > 0)
{
if (ACE_OS::strlen (searchfilename)
+ ACE_OS::strlen (searchpathname) >= maxpathnamelen)
{
errno = ENOMEM;
return -1;
}
else
{
#if (ACE_DIRECTORY_SEPARATOR_CHAR != '/')
// Revert to native path name separators.
ACE_Lib_Find::strrepl (searchpathname,
'/',
ACE_DIRECTORY_SEPARATOR_CHAR);
#endif /* ACE_DIRECTORY_SEPARATOR_CHAR */
// First, try matching the filename *without* adding a
// prefix.
#if defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS)
ACE_OS::sprintf (pathname,
ACE_LIB_TEXT ("%s%s%s"),
searchpathname,
searchfilename,
got_suffix ? ACE_static_cast (ACE_TCHAR *,
ACE_LIB_TEXT (""))
: ACE_static_cast (ACE_TCHAR *,
dll_suffix));
#else /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
ACE_OS::sprintf (pathname,
ACE_LIB_TEXT ("%s%s%s"),
searchpathname,
searchfilename,
got_suffix ? ACE_LIB_TEXT ("") : dll_suffix);
#endif /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
if (ACE_OS::access (pathname, F_OK) == 0)
return 0;
// Second, try matching the filename *with* adding a prefix.
#if defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS)
ACE_OS::sprintf (pathname,
ACE_LIB_TEXT ("%s%s%s%s"),
searchpathname,
ACE_DLL_PREFIX,
searchfilename,
got_suffix ? ACE_static_cast (ACE_TCHAR *,
ACE_LIB_TEXT (""))
: ACE_static_cast (ACE_TCHAR *,
dll_suffix));
#else /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
ACE_OS::sprintf (pathname,
ACE_LIB_TEXT ("%s%s%s%s"),
searchpathname,
ACE_DLL_PREFIX,
searchfilename,
got_suffix ? ACE_LIB_TEXT ("") : dll_suffix);
#endif /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
if (ACE_OS::access (pathname, F_OK) == 0)
return 0;
}
}
// Use relative filenames via LD_LIBRARY_PATH or PATH (depending on
// OS platform).
else
{
ACE_TCHAR *ld_path =
#if defined ACE_DEFAULT_LD_SEARCH_PATH
ACE_DEFAULT_LD_SEARCH_PATH;
#else
ACE_OS::getenv (ACE_LD_SEARCH_PATH);
#endif /* ACE_DEFAULT_LD_SEARCH_PATH */
if (ld_path != 0
&& (ld_path = ACE_OS::strdup (ld_path)) != 0)
{
// strtok has the strange behavior of not separating the
// string ":/foo:/bar" into THREE tokens. One would expect
// that the first iteration the token would be an empty
// string, the second iteration would be "/foo", and the
// third iteration would be "/bar". However, this is not
// the case; one only gets two iterations: "/foo" followed
// by "/bar".
// This is especially a problem in parsing Unix paths
// because it is permissible to specify 'the current
// directory' as an empty entry. So, we introduce the
// following special code to cope with this:
// Look at each dynamic lib directory in the search path.
ACE_TCHAR *nextholder = 0;
const ACE_TCHAR *path_entry =
ACE_Lib_Find::strsplit_r (ld_path,
ACE_LD_SEARCH_PATH_SEPARATOR_STR,
nextholder);
int result = 0;
for (;;)
{
// Check if at end of search path.
if (path_entry == 0)
{
errno = ENOENT;
result = -1;
break;
}
else if (ACE_OS::strlen (path_entry)
+ 1
+ ACE_OS::strlen (searchfilename)
>= maxpathnamelen)
{
errno = ENOMEM;
result = -1;
break;
}
// This works around the issue where a path might have
// an empty component indicating 'current directory'.
// We need to do it here rather than anywhere else so
// that the loop condition will still work.
else if (path_entry[0] == '\0')
path_entry = ACE_LIB_TEXT (".");
// First, try matching the filename *without* adding a
// prefix.
#if defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS)
ACE_OS::sprintf (pathname,
ACE_LIB_TEXT ("%s%c%s%s"),
path_entry,
ACE_DIRECTORY_SEPARATOR_CHAR,
searchfilename,
got_suffix ? ACE_static_cast (ACE_TCHAR *,
ACE_LIB_TEXT (""))
: ACE_static_cast (ACE_TCHAR *,
dll_suffix));
#else /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
ACE_OS::sprintf (pathname,
ACE_LIB_TEXT ("%s%c%s%s"),
path_entry,
ACE_DIRECTORY_SEPARATOR_CHAR,
searchfilename,
got_suffix ? ACE_LIB_TEXT ("") : dll_suffix);
#endif /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
if (ACE_OS::access (pathname, F_OK) == 0)
break;
// Second, try matching the filename *with* adding a
// prefix.
#if defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS)
ACE_OS::sprintf (pathname,
ACE_LIB_TEXT ("%s%c%s%s%s"),
path_entry,
ACE_DIRECTORY_SEPARATOR_CHAR,
ACE_DLL_PREFIX,
searchfilename,
got_suffix ? ACE_static_cast (ACE_TCHAR *,
ACE_LIB_TEXT (""))
: ACE_static_cast (ACE_TCHAR *,
dll_suffix));
#else /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
ACE_OS::sprintf (pathname,
ACE_LIB_TEXT ("%s%c%s%s%s"),
path_entry,
ACE_DIRECTORY_SEPARATOR_CHAR,
ACE_DLL_PREFIX,
searchfilename,
got_suffix ? ACE_LIB_TEXT ("") : dll_suffix);
#endif /* ! defined (ACE_HAS_BROKEN_CONDITIONAL_STRING_CASTS) */
if (ACE_OS::access (pathname, F_OK) == 0)
break;
// Fetch the next item in the path
path_entry = ACE_Lib_Find::strsplit_r (0,
ACE_LD_SEARCH_PATH_SEPARATOR_STR,
nextholder);
}
ACE_OS::free ((void *) ld_path);
return result;
}
}
errno = ENOENT;
return -1;
#endif
/// @todo FIXME: Convert ACE code
*this = Path( file );
return NOT_AN_ERROR;
}
}
}
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab