_WCRTLINK void _WCHUGE * halloc( unsigned long n, unsigned size )
{
unsigned long len;
USHORT error, tseg;
SEL seg;
USHORT number_segments, remaining_bytes;
USHORT increment;
len = n * size;
if( len == 0 ) return( (void _WCHUGE *)0 );
if( n > 65536 && ! only_one_bit( size ) ) return( (void _WCHUGE *)0 );
error = DosGetHugeShift( &increment );
if( error ) {
__set_errno_dos( error );
return( ( void _WCHUGE *)0 );
}
number_segments = len >> 16;
remaining_bytes = len & 0xffff;
error = DosAllocHuge( number_segments, remaining_bytes, &seg, 0, 0 );
if( error ) {
__set_errno_dos( error );
return( (void _WCHUGE *)0 ); /* allocation failed */
}
tseg = seg;
increment = 1 << increment;
while( number_segments-- ) {
_os2zero64k( 0, 0x8000, tseg, 0 );
tseg += increment;
}
if( remaining_bytes != 0 ) { /* 30-apr-91 */
_os2zero_rest( 0, remaining_bytes, tseg, 0 );
}
return( (void _WCHUGE *)((unsigned long )seg << 16) );
}
_WCRTLINK long __lseek( int handle, long offset, int origin )
{
long pos;
__handle_check( handle, -1 );
#if defined( __OS2__ )
{
APIRET rc;
rc = DosChgFilePtr( handle, offset, origin, (PULONG)&pos );
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
}
#elif defined( __NT__ )
pos = SetFilePointer( __getOSHandle( handle ), offset, 0, origin );
if( pos == INVALID_SET_FILE_POINTER ) {
return( __set_errno_nt() );
}
#elif defined( __DOS__ ) || defined( __WINDOWS__ )
{
tiny_ret_t rc;
rc = TinyLSeek( handle, offset, origin, (u32_stk_ptr)&pos );
if( TINY_ERROR( rc ) ) {
return( __set_errno_dos( TINY_INFO( rc ) ) );
}
}
#endif
return( pos );
}
_WCRTLINK int _findnext( long handle, struct _finddata_t *fileinfo )
#endif
#endif
{
#ifdef __NT__
WIN32_FIND_DATA ffb;
BOOL rc;
/*** Try to find another matching file ***/
rc = FIND_NEXT( (HANDLE)handle, &ffb );
if( rc == FALSE ) {
return( __set_errno_nt() );
}
if( !CHECK_FIND_NEXT_ATTR( (HANDLE)handle, FIND_ATTR, &ffb ) ) {
return( __set_errno_dos( ERROR_FILE_NOT_FOUND ) );
}
/*** Got one! ***/
#ifdef __INT64__
__F_NAME(__nt_finddatai64_cvt,__nt_wfinddatai64_cvt)( &ffb, fileinfo );
#else
__F_NAME(__nt_finddata_cvt,__nt_wfinddata_cvt)( &ffb, fileinfo );
#endif
#elif defined( __OS2__ )
APIRET rc;
FF_BUFFER ffb;
OS_UINT searchcount = 1;
rc = DosFindNext( (HDIR)handle, &ffb, sizeof( ffb ), &searchcount );
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
/*** Got one! ***/
#ifdef __INT64__
__F_NAME(__os2_finddatai64_cvt,__os2_wfinddatai64_cvt)( &ffb, fileinfo );
#else
__F_NAME(__os2_finddata_cvt,__os2_wfinddata_cvt)( &ffb, fileinfo );
#endif
#elif defined( __RDOS__ )
RDOSFINDTYPE * findbuf = (RDOSFINDTYPE*) handle;
findbuf->entry++;
if( __rdos_finddata_get( findbuf, fileinfo ) )
return( 0 );
else
return( -1 );
#else /* DOS */
if( __F_NAME(_dos_findnext,_wdos_findnext)( (DOSFINDTYPE *)handle ) ) {
return( -1 );
}
#ifdef __INT64__
__F_NAME(__dos_finddatai64_cvt,__dos_wfinddatai64_cvt)( (DOSFINDTYPE *)handle, fileinfo );
#else
__F_NAME(__dos_finddata_cvt,__dos_wfinddata_cvt)( (DOSFINDTYPE *)handle, fileinfo );
#endif
#endif
return( 0 );
}
_WCRTLINK int __F_NAME(access,_waccess)( const CHAR_TYPE *path, int pmode )
{
APIRET rc;
OS_UINT attr;
#ifndef _M_I86
FILESTATUS3 fs;
#endif
#ifdef __WIDECHAR__
char mbPath[MB_CUR_MAX * _MAX_PATH]; /* single-byte char */
if( wcstombs( mbPath, path, sizeof( mbPath ) ) == -1 ) {
mbPath[0] = '\0';
}
#endif
#ifdef _M_I86
rc = DosQFileMode( (PSZ)__F_NAME(path,mbPath), &attr, 0 );
#else
rc = DosQueryPathInfo( (PSZ)__F_NAME(path,mbPath), FIL_STANDARD, &fs, sizeof( fs ) );
attr = fs.attrFile;
#endif
if( rc ) {
return( __set_errno_dos( rc ) );
}
if( (pmode & ACCESS_WR) && (attr & _A_RDONLY) ) {
return( __set_errno_dos( ERROR_ACCESS_DENIED ) ); /* invalid access mode */
}
return( 0 );
}
int __FreeSeg( __segment seg )
{
#if defined(__QNX__)
if( qnx_segment_free( seg ) == -1 ) {
return( -1 );
}
#elif defined(__WINDOWS__)
if( __DoFreeSeg( seg ) ) {
return( -1 );
}
#elif defined(__OS2__)
APIRET rc;
rc = __DoFreeSeg( seg );
if( rc ) {
return( __set_errno_dos( rc ) );
}
#else
tiny_ret_t rc;
rc = TinyFreeBlock( seg );
if( TINY_ERROR( rc ) ) {
return( __set_errno_dos( TINY_INFO( rc ) ) );
}
#endif
return( 0 );
}
int __qread( int handle, void *buffer, unsigned len )
{
#if defined( __NT__ )
DWORD amount_read;
#elif defined(__OS2__)
OS_UINT amount_read;
APIRET rc;
#else
unsigned amount_read;
tiny_ret_t rc;
#endif
__handle_check( handle, -1 );
#ifdef DEFAULT_WINDOWING
if( _WindowsStdin != NULL ) {
LPWDATA res;
res = _WindowsIsWindowedHandle( handle );
if( res ) {
int rt;
rt = _WindowsStdin( res, buffer, len );
return( rt );
}
}
#endif
#if defined(__NT__)
if( !ReadFile( __getOSHandle( handle ), buffer, len, &amount_read, NULL ) ) {
DWORD err;
err = GetLastError();
__set_errno_dos( err );
if( err != ERROR_BROKEN_PIPE || amount_read != 0 ) {
return( -1 );
}
}
#elif defined(__OS2__)
rc = DosRead( handle, buffer, len, &amount_read );
if( rc ) {
return( __set_errno_dos( rc ) );
}
#else
#if defined( __WINDOWS_386__ )
rc = __TinyRead( handle, buffer, len );
#else
rc = TinyRead( handle, buffer, len );
#endif
if( TINY_ERROR( rc ) ) {
return( __set_errno_dos( TINY_INFO( rc ) ) );
}
amount_read = TINY_LINFO( rc );
#endif
return( amount_read );
}
_WCRTLINK int __F_NAME(mkdir,_wmkdir)( const CHAR_TYPE *path )
/************************************************************/
{
#ifdef __WIDECHAR__
size_t rcConvert;
char mbcsPath[MB_CUR_MAX * _MAX_PATH];
unsigned char *p;
/*** Convert the wide character string to a multibyte string ***/
rcConvert = wcstombs( mbcsPath, path, sizeof( mbcsPath ) );
p = _mbsninc( (unsigned char *)mbcsPath, rcConvert );
*p = '\0';
return( mkdir( mbcsPath ) );
#else
#ifdef __WATCOM_LFN__
tiny_ret_t rc = 0;
if( _RWD_uselfn && TINY_OK( rc = _mkdir_lfn( path ) ) ) {
return( 0 );
}
if( IS_LFN_ERROR( rc ) ) {
return( __set_errno_dos( TINY_INFO( rc ) ) );
}
#endif
return( __mkdir_sfn( path ) );
#endif
}
int eno_setOSerror(int errnr)
{
#ifdef __TURBOC__
int eno;
#endif
DBG_ENTER("eno_setOSerror", Suppl_error)
DBG_ARGUMENTS( ("errnr=%u", errnr) )
#ifdef __TURBOC__
if((unsigned)errnr > 88) {
DBG_INFO( ("Errnr exceeds range") )
eno = EFAULT;
} else {
eno = _dosErrorToSV[errnr];
}
errno = eno;
DBG_RETURN_BI(_doserrno = errnr)
#elif __WATCOMC__
__set_errno_dos(errnr);
DBG_RETURN_I( errnr)
#endif
}
static int os_write( int handle, const void *buffer, unsigned len, unsigned *amt )
/********************************************************************************/
{
int rc;
#ifdef DEFAULT_WINDOWING
LPWDATA res;
#endif
#if defined(__NT__)
HANDLE h;
#elif defined(__OS2__)
APIRET rc1;
#else
tiny_ret_t rc1;
#endif
rc = 0;
#ifdef DEFAULT_WINDOWING
if( _WindowsStdout != NULL && (res = _WindowsIsWindowedHandle( handle )) != NULL ) {
*amt = _WindowsStdout( res, buffer, len );
} else
#endif
{
#if defined(__NT__)
h = __getOSHandle( handle );
if( !WriteFile( h, (LPCVOID)buffer, (DWORD)len, (LPDWORD)amt, NULL ) ) {
return( __set_errno_nt() );
}
#elif defined(__OS2__)
rc1 = DosWrite( handle, (PVOID)buffer, (OS_UINT)len, (OS_PUINT)amt );
if( rc1 ) {
return( __set_errno_dos( rc1 ) );
}
#else
rc1 = TinyWrite( handle, buffer, len );
if( TINY_ERROR( rc1 ) ) {
return( __set_errno_dos( TINY_INFO( rc1 ) ) );
}
*amt = TINY_LINFO( rc1 );
#endif
}
if( *amt != len ) {
rc = ENOSPC;
_RWD_errno = rc;
}
return( rc );
}
_WCRTLINK int chsize( int handle, long size )
{
long curOffset, endOffset;
char buf[512];
long diff;
unsigned amount;
int retCode;
__handle_check( handle, -1 );
/*** Prepare to change the size ***/
_AccessFileH( handle );
curOffset = __lseek( handle, 0L, SEEK_CUR ); /* get current offset */
if( curOffset == -1 ) {
_ReleaseFileH( handle );
return( -1 );
}
endOffset = __lseek( handle, 0L, SEEK_END ); /* get file size */
if( endOffset == -1 ) {
_ReleaseFileH( handle );
return( -1 );
}
if( size > endOffset ) {
/*** Increase file size ***/
diff = size - endOffset; /* number of bytes to pad */
memset( buf, 0, 512 ); /* zero buffer */
do {
if( diff >= 512 ) {
amount = 512;
} else {
amount = (unsigned)diff;
}
retCode = write( handle, buf, amount );
if( retCode != amount ) {
__set_errno( ENOSPC );
retCode = -1;
break;
}
diff -= amount;
} while( diff != 0 );
if( retCode != -1 ) retCode = 0;
} else {
/*** Shrink file ***/
retCode = DosNewSize( handle, size );
if( retCode != 0 ) {
__set_errno_dos( retCode );
retCode = -1;
}
if( curOffset > size ) curOffset = size;
}
/*** Clean up and go home ***/
curOffset = __lseek( handle, curOffset, SEEK_SET );
if( curOffset == -1 ) retCode = -1;
_ReleaseFileH( handle );
return( retCode );
}
_WCRTLINK int __F_NAME(utime,_wutime)( CHAR_TYPE const *fn, struct utimbuf const *times )
/***************************************************************************************/
{
APIRET rc;
OS_UINT actiontaken;
FILESTATUS stat;
HFILE handle;
struct tm *split;
time_t curr_time;
struct utimbuf time_buf;
#ifdef __WIDECHAR__
char mbPath[MB_CUR_MAX * _MAX_PATH]; /* single-byte char */
if( wcstombs( mbPath, fn, sizeof( mbPath ) ) == -1 ) {
mbPath[0] = '\0';
}
#endif
rc = DosOpen( (PSZ)__F_NAME(fn,mbPath), &handle, &actiontaken, 0ul, _A_NORMAL,
OPENFLAG_FAIL_IF_NOT_EXISTS | OPENFLAG_OPEN_IF_EXISTS,
OPENMODE_DENY_NONE | OPENMODE_ACCESS_RDWR,
0ul );
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
if( DosQFileInfo( handle, 1, (PBYTE)&stat, sizeof( FILESTATUS ) ) != 0 ) {
DosClose( handle );
__set_errno( EACCES );
return( -1 );
}
if( times == NULL ) {
curr_time = time( NULL );
time_buf.modtime = curr_time;
time_buf.actime = curr_time;
times = &time_buf;
}
split = localtime( &(times->modtime) );
stat.fdateLastWrite.year = split->tm_year - 80;
stat.fdateLastWrite.month = split->tm_mon + 1;
stat.fdateLastWrite.day = split->tm_mday;
stat.ftimeLastWrite.hours = split->tm_hour;
stat.ftimeLastWrite.minutes = split->tm_min;
stat.ftimeLastWrite.twosecs = split->tm_sec >> 1;
/* 5-Apr-90 DJG
* Early versions of OS/2 (1.10) do not support this fields properly.
* We'll assume that if OS/2 returned a value here that we can set it
* ourselves. Day has to be non-zero if the date is valid.
*/
if( stat.fdateLastAccess.day != 0 ) {
split = localtime( &(times->actime) );
stat.fdateLastAccess.year = split->tm_year - 80;
stat.fdateLastAccess.month = split->tm_mon + 1;
stat.fdateLastAccess.day = split->tm_mday;
stat.ftimeLastAccess.hours = split->tm_hour;
stat.ftimeLastAccess.minutes = split->tm_min;
stat.ftimeLastAccess.twosecs = split->tm_sec >> 1;
}
_WCRTLINK int closedir( DIR_TYPE *dirp )
{
if( dirp == NULL || dirp->d_first == _DIR_CLOSED ) {
return( __set_errno_dos( E_ihandle ) );
}
_dos_findclose( (struct _find_t *)dirp->d_dta );
dirp->d_first = _DIR_CLOSED;
if( dirp->d_openpath != NULL )
free( dirp->d_openpath );
lib_free( dirp );
return( 0 );
}
_WCRTLINK int __F_NAME(chmod,_wchmod)( const CHAR_TYPE *pathname, int pmode )
{
APIRET rc;
OS_UINT attr;
#ifndef _M_I86
FILESTATUS3 fs;
#endif
#ifdef __WIDECHAR__
char mbPath[MB_CUR_MAX * _MAX_PATH];
if( wcstombs( mbPath, pathname, sizeof( mbPath ) ) == -1 ) {
mbPath[0] = '\0';
}
#endif
#ifdef _M_I86
rc = DosQFileMode( (PSZ)__F_NAME(pathname,mbPath), &attr, 0 );
#else
rc = DosQueryPathInfo( (PSZ)__F_NAME(pathname,mbPath), FIL_STANDARD,
&fs, sizeof( fs ) );
attr = fs.attrFile;
#endif
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
attr &= ~_A_RDONLY;
if( !( pmode & S_IWRITE ) ) {
attr |= _A_RDONLY;
}
#ifdef _M_I86
rc = DosSetFileMode( (PSZ)__F_NAME(pathname,mbPath), attr, 0 );
#else
fs.attrFile = attr;
rc = DosSetPathInfo( (PSZ)__F_NAME(pathname,mbPath), FIL_STANDARD,
&fs, sizeof( fs ), 0 );
#endif
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
return( 0 );
}
static int os_write( int handle, const void *buffer, unsigned len, unsigned *amt )
/********************************************************************************/
{
#ifdef DEFAULT_WINDOWING
LPWDATA res;
#endif
#if defined(__NT__)
HANDLE h;
int rc;
#else
tiny_ret_t rc;
#endif
rc = 0;
#ifdef DEFAULT_WINDOWING
if( _WindowsStdout != 0 && (res = _WindowsIsWindowedHandle( handle )) != 0 ) {
*amt = _WindowsStdout( res, buffer, len );
} else
#endif
{
#if defined(__NT__)
h = __getOSHandle( handle );
if( !WriteFile( h, (LPCVOID)buffer, (DWORD)len, (LPDWORD)amt, NULL ) ) {
rc = __set_errno_nt();
}
#elif defined(__OS2_286__)
rc = DosWrite( handle, (PVOID)buffer, (USHORT)len, (PUSHORT)amt );
#elif defined(__OS2__)
rc = DosWrite( handle, (PVOID)buffer, (ULONG)len, (PULONG)amt );
#else
rc = TinyWrite( handle, buffer, len );
*amt = TINY_LINFO( rc );
if( TINY_OK( rc ) ) {
rc = 0;
}
#endif
}
#if !defined(__NT__)
if( TINY_ERROR( rc ) ) {
rc = __set_errno_dos( TINY_INFO( rc ) );
}
#endif
if( *amt != len ) {
rc = ENOSPC;
__set_errno( rc );
}
return( rc );
}
_WCRTLINK int dup2( int handle1, int handle2 )
{
tiny_ret_t rc;
__handle_check( handle1, -1 );
if( handle1 == handle2 ) {
return( handle2 );
}
rc = TinyDup2( handle1, handle2 );
if( TINY_ERROR(rc) ) {
return( __set_errno_dos( TINY_INFO(rc) ) );
}
__SetIOMode( handle2, __GetIOMode( handle1 ) );
return( 0 ); /* indicate success */
}
_WCRTLINK int dup2( int handle1, int handle2 )
{
APIRET rc;
__handle_check( handle1, -1 );
if( handle1 == handle2 ) {
return( handle2 );
}
rc = DosDupHandle( handle1, (PHFILE)&handle2 );
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
__SetIOMode( handle2, __GetIOMode( handle1 ) );
return( 0 ); /* indicate success */
}
_WCRTLINK int __F_NAME(closedir,_wclosedir)( DIR_TYPE *dirp )
/***********************************************************/
{
if( dirp == NULL || dirp->d_first == _DIR_CLOSED ) {
return( __set_errno_dos( ERROR_INVALID_HANDLE ) );
}
if( !FindClose( DIR_HANDLE_OF( dirp ) ) ) {
return( __set_errno_nt() );
}
dirp->d_first = _DIR_CLOSED;
if( dirp->d_openpath != NULL )
free( dirp->d_openpath );
lib_free( dirp );
return( 0 );
}
_WCRTLINK int __F_NAME(closedir,_wclosedir)( DIR_TYPE *dirp )
{
unsigned rc;
if( dirp == NULL || dirp->d_first == _DIR_CLOSED ) {
return( __set_errno_dos( E_ihandle ) );
}
rc = _dos_findclose( (struct _find_t *)dirp->d_dta );
if( rc ) {
return( rc );
}
dirp->d_first = _DIR_CLOSED;
if( dirp->d_openpath != NULL )
free( dirp->d_openpath );
lib_free( dirp );
return( 0 );
}
_WCRTLINK int __F_NAME(mkdir,_wmkdir)( const CHAR_TYPE *path )
{
APIRET rc;
#ifdef __WIDECHAR__
size_t rcConvert;
char mbcsPath[ MB_CUR_MAX * _MAX_PATH ];
unsigned char *p;
/*** Convert the wide character string to a multibyte string ***/
rcConvert = wcstombs( mbcsPath, path, sizeof( mbcsPath ) );
p = _mbsninc( (unsigned char *)mbcsPath, rcConvert );
*p = '\0';
#endif
rc = DosMkDir( (PSZ)__F_NAME(path,mbcsPath), 0 );
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
return( 0 ); /* indicate no error */
}
static DIR_TYPE *__opendir( const char *dirname )
/***********************************************/
{
DIR_TYPE tmp;
DIR_TYPE *dirp;
int i;
char pathname[_MAX_PATH + 6];
tmp.d_attr = _A_SUBDIR;
tmp.d_first = _DIR_CLOSED;
i = is_directory( dirname );
if( i <= 0 ) {
/* it is file or may be file or no dirname */
if( ___opendir( dirname, &tmp ) == NULL ) {
return( NULL );
}
}
if( i >= 0 && (tmp.d_attr & _A_SUBDIR) ) {
size_t len;
/* directory, add wildcards */
len = strlen( dirname );
memcpy( pathname, dirname, len );
if( i < 2 ) {
pathname[len++] = '\\';
}
strcpy( &pathname[len], "*.*" );
if( ___opendir( pathname, &tmp ) == NULL ) {
return( NULL );
}
dirname = pathname;
}
dirp = lib_malloc( sizeof( DIR_TYPE ) );
if( dirp == NULL ) {
_dos_findclose( (struct _find_t *)tmp.d_dta );
__set_errno_dos( E_nomem );
return( NULL );
}
tmp.d_openpath = __clib_strdup( dirname );
*dirp = tmp;
return( dirp );
}
static DIR_TYPE *__F_NAME(__opendir,__wopendir)( const CHAR_TYPE *dirname )
/*************************************************************************/
{
DIR_TYPE tmp;
DIR_TYPE *dirp;
int i;
CHAR_TYPE pathname[MAX_PATH + 6];
tmp.d_attr = _A_SUBDIR; /* assume sub-directory */
tmp.d_first = _DIR_CLOSED;
i = is_directory( dirname );
if( i <= 0 ) {
/* it is file or may be file or no dirname */
if( __F_NAME(___opendir,___wopendir)( dirname, &tmp ) == NULL ) {
return( NULL );
}
}
if( i >= 0 && (tmp.d_attr & _A_SUBDIR) ) {
size_t len;
/* directory, add wildcard */
len = __F_NAME(strlen,wcslen)( dirname );
memcpy( pathname, dirname, len * sizeof( CHAR_TYPE ) );
if( i < 2 ) {
pathname[len++] = '\\';
}
__F_NAME(strcpy,wcscpy)( &pathname[len], STRING( "*.*" ) );
if( __F_NAME(___opendir,___wopendir)( pathname, &tmp ) == NULL ) {
return( NULL );
}
dirname = pathname;
}
dirp = lib_malloc( sizeof( DIR_TYPE ) );
if( dirp == NULL ) {
FindClose( DIR_HANDLE_OF( &tmp ) );
__set_errno_dos( ERROR_NOT_ENOUGH_MEMORY );
return( NULL );
}
tmp.d_openpath = __F_NAME(__clib_strdup,__clib_wcsdup)( dirname );
*dirp = tmp;
return( dirp );
}
static DIR_TYPE *__F_NAME(__opendir,__wopendir)( const CHAR_TYPE *dirname )
/*************************************************************************/
{
DIR_TYPE tmp;
DIR_TYPE *dirp;
int i;
CHAR_TYPE pathname[ _MAX_PATH + 6 ];
tmp.d_attr = _A_SUBDIR;
tmp.d_first = _DIR_CLOSED;
i = is_directory( dirname );
if( i <= 0 ) {
/* it is file or may be file or no dirname */
if( __F_NAME(___opendir,___wopendir)( dirname, &tmp ) == NULL ) {
return( NULL );
}
}
if( i >= 0 && (tmp.d_attr & _A_SUBDIR) ) {
size_t len;
/* directory, add wildcards */
len = __F_NAME(strlen,wcslen)( dirname );
memcpy( pathname, dirname, len * sizeof( CHAR_TYPE ) );
if( i < 2 ) {
pathname[len++] = DIR_SEP;
}
__F_NAME(strcpy,wcscpy)( &pathname[len], STRING( "*.*" ) );
if( __F_NAME(___opendir,___wopendir)( pathname, &tmp ) == NULL ) {
return( NULL );
}
dirname = pathname;
}
dirp = lib_malloc( sizeof( *dirp ) );
if( dirp == NULL ) {
_dos_findclose( (struct _find_t *)tmp.d_dta );
__set_errno_dos( E_nomem );
return( NULL );
}
tmp.d_openpath = __F_NAME(__clib_strdup,__clib_wcsdup)( dirname );
*dirp = tmp;
return( dirp );
}
_WCRTLINK int __F_NAME(unlink,_wunlink)( const CHAR_TYPE *filename )
{
APIRET rc;
#ifdef __WIDECHAR__
char mbFilename[MB_CUR_MAX * _MAX_PATH]; /* single-byte char */
if( wcstombs( mbFilename, filename, sizeof( mbFilename ) ) == -1 ) {
mbFilename[0] = '\0';
}
#endif
#ifdef _M_I86
rc = DosDelete( (PSZ)__F_NAME(filename,mbFilename), 0 );
#else
rc = DosDelete( __F_NAME(filename,mbFilename) );
#endif
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
return( 0 ); /* indicate no error */
}
_WCRTLINK CHAR_TYPE *__F_NAME(getcwd,_wgetcwd)( CHAR_TYPE *buf, size_t size )
{
APIRET error;
ULONG drive_map;
#ifndef __WIDECHAR__
char path[_MAX_PATH]; /* single-byte chars */
OS_UINT pathlen = _MAX_PATH - 3;
#else
char path[MB_CUR_MAX*_MAX_PATH]; /* multi-byte chars */
OS_UINT pathlen = MB_CUR_MAX * _MAX_PATH - 3;
#endif
OS_UINT drive;
error = DosQCurDir( 0, &path[3], &pathlen );
if( error ) {
__set_errno_dos( error );
return( NULL );
}
DosQCurDisk( &drive, &drive_map );
path[ 0 ] = drive + 'A' - 1;
path[ 1 ] = ':';
path[ 2 ] = '\\';
if( buf == NULL ) {
if( (buf = malloc( max(size,pathlen+4)*CHARSIZE )) == NULL ) {
__set_errno( ENOMEM );
return( NULL );
}
size = pathlen + 3;
}
/*** Copy the pathname into a buffer and quit ***/
#ifndef __WIDECHAR__
return( strncpy( buf, path, size ) );
#else
if( mbstowcs( buf, path, size ) != (size_t)-1 )
return( buf );
else
return( NULL );
#endif
}
_WCRTLINK DIR_TYPE *__F_NAME(readdir,_wreaddir)( DIR_TYPE *dirp )
/***************************************************************/
{
WIN32_FIND_DATA ffd;
DWORD err;
if( dirp == NULL || dirp->d_first == _DIR_CLOSED )
return( NULL );
if( dirp->d_first == _DIR_ISFIRST ) {
dirp->d_first = _DIR_NOTFIRST;
} else {
if( !__lib_FindNextFile( DIR_HANDLE_OF( dirp ), &ffd ) ) {
err = GetLastError();
if( err != ERROR_NO_MORE_FILES ) {
__set_errno_dos( err );
}
return( NULL );
}
__GetNTDirInfo( dirp, &ffd );
}
return( dirp );
}
static long _cvt_stamp2dos_lfn( long long *timestamp )
{
#ifdef _M_I86
return( __cvt_stamp2dos_lfn( timestamp ) );
#else
call_struct dpmi_rm;
*((long long *)RM_TB_PARM1_LINEAR) = *timestamp;
memset( &dpmi_rm, 0, sizeof( dpmi_rm ) );
dpmi_rm.ds = RM_TB_PARM1_SEGM;
dpmi_rm.esi = RM_TB_PARM1_OFFS;
dpmi_rm.ebx = 0;
dpmi_rm.eax = 0x71A7;
dpmi_rm.flags = 1;
if( __dpmi_dos_call( &dpmi_rm ) ) {
return( -1 );
}
if( dpmi_rm.flags & 1 ) {
return( __set_errno_dos( dpmi_rm.ax ) );
}
return( dpmi_rm.dx << 16 | dpmi_rm.cx );
#endif
}
_WCRTLINK int __F_NAME(unlink,_wunlink)( const CHAR_TYPE *filename )
/******************************************************************/
{
#ifdef __WIDECHAR__
char mbFilename[MB_CUR_MAX * _MAX_PATH]; /* single-byte char */
if( wcstombs( mbFilename, filename, sizeof( mbFilename ) ) == -1 ) {
mbFilename[0] = '\0';
}
return( unlink( mbFilename ) );
#else
#ifdef __WATCOM_LFN__
tiny_ret_t rc = 0;
if( _RWD_uselfn && TINY_OK( rc = _unlink_lfn( filename ) ) ) {
return( 0 );
}
if( IS_LFN_ERROR( rc ) ) {
return( __set_errno_dos( TINY_INFO( rc ) ) );
}
#endif
return( __unlink_sfn( filename ) );
#endif
}
_WCRTLINK int write( int handle, const void *buffer, unsigned len )
#endif
/**********************************************************************/
{
unsigned iomode_flags;
char *buf;
unsigned buf_size;
unsigned len_written, i, j;
#if defined(__NT__)
HANDLE h;
LONG cur_ptr_low;
LONG cur_ptr_high;
DWORD rc1;
#else
tiny_ret_t rc1;
#endif
int rc2;
__handle_check( handle, -1 );
iomode_flags = __GetIOMode( handle );
if( iomode_flags == 0 ) {
#if defined(__WINDOWS__) || defined(__WINDOWS_386__)
// How can we write to the handle if we never opened it? JBS
return( _lwrite( handle, buffer, len ) );
#else
__set_errno( EBADF );
return( -1 );
#endif
}
if( !(iomode_flags & _WRITE) ) {
__set_errno( EACCES ); /* changed from EBADF to EACCES 23-feb-89 */
return( -1 );
}
#if defined(__NT__)
h = __getOSHandle( handle );
#endif
// put a semaphore around our writes
_AccessFileH( handle );
if( (iomode_flags & _APPEND) && !(iomode_flags & _ISTTY) ) {
#if defined(__NT__)
if( GetFileType( h ) == FILE_TYPE_DISK ) {
cur_ptr_low = 0;
cur_ptr_high = 0;
rc1 = SetFilePointer( h, cur_ptr_low, &cur_ptr_high, FILE_END );
if( rc1 == INVALID_SET_FILE_POINTER ) { // this might be OK so
if( GetLastError() != NO_ERROR ) {
_ReleaseFileH( handle );
return( __set_errno_nt() );
}
}
}
#elif defined(__OS2__)
{
unsigned long dummy;
rc1 = DosChgFilePtr( handle, 0L, SEEK_END, &dummy );
// should we explicitly ignore ERROR_SEEK_ON_DEVICE here?
}
#else
rc1 = TinySeek( handle, 0L, SEEK_END );
#endif
#if !defined(__NT__)
if( TINY_ERROR( rc1 ) ) {
_ReleaseFileH( handle );
return( __set_errno_dos( TINY_INFO( rc1 ) ) );
}
#endif
}
len_written = 0;
rc2 = 0;
// Pad the file with zeros if necessary
if( iomode_flags & _FILEEXT ) {
// turn off file extended flag
__SetIOMode_nogrow( handle, iomode_flags&(~_FILEEXT) );
// It is not required to pad a file with zeroes on an NTFS file system;
// unfortunately it is required on FAT (and probably FAT32). (JBS)
rc2 = zero_pad( handle );
}
if( rc2 == 0 ) {
if( iomode_flags & _BINARY ) { /* if binary mode */
rc2 = os_write( handle, buffer, len, &len_written );
/* end of binary mode part */
} else { /* text mode */
i = stackavail();
if( i < 0x00b0 ) {
__STKOVERFLOW(); /* not enough stack space */
}
buf_size = 512;
if( i < (512 + 48) ) {
buf_size = 128;
}
#if defined(__AXP__) || defined(__PPC__)
buf = alloca( buf_size );
#else
buf = __alloca( buf_size );
#endif
j = 0;
for( i = 0; i < len; ) {
if( ((const char*)buffer)[i] == '\n' ) {
buf[j] = '\r';
++j;
if( j == buf_size ) {
rc2 = os_write( handle, buf, buf_size, &j );
if( rc2 == -1 )
break;
len_written += j;
if( rc2 == ENOSPC )
break;
len_written = i;
j = 0;
}
}
buf[j] = ((const char*)buffer)[i];
++i;
++j;
if( j == buf_size ) {
rc2 = os_write( handle, buf, buf_size, &j );
if( rc2 == -1 )
break;
len_written += j;
if( rc2 == ENOSPC )
break;
len_written = i;
j = 0;
}
}
if( j ) {
rc2 = os_write( handle, buf, j, &i );
if( rc2 == ENOSPC ) {
len_written += i;
} else {
len_written = len;
}
}
/* end of text mode part */
}
}
_ReleaseFileH( handle );
if( rc2 == -1 ) {
return( rc2 );
} else {
return( len_written );
}
}
_WCRTLINK CHAR_TYPE *__F_NAME(_sys_fullpath,_sys_wfullpath)
( CHAR_TYPE *buff, const CHAR_TYPE *path, size_t size )
/*********************************************************************/
{
#if defined(__NT__)
CHAR_TYPE *filepart;
DWORD rc;
if( __F_NAME(stricmp,_wcsicmp)( path, STRING( "con" ) ) == 0 ) {
_WILL_FIT( 3 );
return( __F_NAME(strcpy,wcscpy)( buff, STRING( "con" ) ) );
}
/*** Get the full pathname ***/
rc = __lib_GetFullPathName( path, size, buff, &filepart );
// If the buffer is too small, the return value is the size of
// the buffer, in TCHARs, required to hold the path.
// If the function fails, the return value is zero. To get extended error
// information, call GetLastError.
if( ( rc == 0 ) || ( rc > size ) ) {
__set_errno_nt();
return( NULL );
}
return( buff );
#elif defined(__WARP__)
APIRET rc;
char root[ 4 ]; /* SBCS: room for drive, ':', '\\', and null */
#ifdef __WIDECHAR__
char mbBuff[ _MAX_PATH * MB_CUR_MAX ];
char mbPath[ _MAX_PATH * MB_CUR_MAX ];
#endif
if( __F_NAME(isalpha,iswalpha)( path[ 0 ] ) && ( path[ 1 ] == STRING( ':' ) ) && ( path[ 2 ] == STRING( '\\' ) ) ) {
int i;
i = __F_NAME(strlen,wcslen)( path );
_WILL_FIT( i );
__F_NAME(strcpy,wcscpy)( buff, path );
return( buff );
}
/*
* Check for x:filename.ext when drive x doesn't exist. In this
* case, return x:\filename.ext, not NULL, to be consistent with
* MS and with the NT version of _fullpath.
*/
if( __F_NAME(isalpha,iswalpha)( path[ 0 ] ) && path[ 1 ] == STRING( ':' ) ) {
/*** We got this far, so path can't start with letter:\ ***/
root[ 0 ] = (char)path[ 0 ];
root[ 1 ] = ':';
root[ 2 ] = '\\';
root[ 3 ] = '\0';
rc = DosQueryPathInfo( root, FIL_QUERYFULLNAME, buff, size );
if( rc != NO_ERROR ) {
/*** Drive does not exist; return x:\filename.ext ***/
_WILL_FIT( __F_NAME(strlen,wcslen)( &path[ 2 ] ) + 3 );
buff[ 0 ] = root[ 0 ];
buff[ 1 ] = STRING( ':' );
buff[ 2 ] = STRING( '\\' );
__F_NAME(strcpy,wcscpy)( &buff[ 3 ], &path[ 2 ] );
return( buff );
}
}
#ifdef __WIDECHAR__
if( wcstombs( mbPath, path, sizeof( mbPath ) ) == (size_t)-1 ) {
return( NULL );
}
rc = DosQueryPathInfo( (PSZ)mbPath, FIL_QUERYFULLNAME, mbBuff, sizeof( mbBuff ) );
#else
rc = DosQueryPathInfo( (PSZ)path, FIL_QUERYFULLNAME, buff, size );
#endif
if( rc != 0 ) {
__set_errno_dos( rc );
return( NULL );
}
#ifdef __WIDECHAR__
if( mbstowcs( buff, mbBuff, size ) != (size_t)-1 ) {
return( buff );
} else {
return( NULL );
}
#else
return( buff );
#endif
#elif defined(__QNX__) || defined( __NETWARE__ )
size_t len;
char temp_dir[ _MAX_PATH ];
#if defined(__NETWARE__)
if( ConvertNameToFullPath( path, temp_dir ) != 0 ) {
return( NULL );
}
#else
if( __qnx_fullpath( temp_dir, path ) == NULL ) {
return( NULL );
}
#endif
len = strlen( temp_dir );
if( len >= size ) {
__set_errno( ERANGE );
return( NULL );
}
return( strcpy( buff, temp_dir ) );
#elif defined(__UNIX__)
const char *p;
char *q;
size_t len;
char curr_dir[ _MAX_PATH ];
p = path;
q = buff;
if( ! _IS_SLASH( p[ 0 ] ) ) {
if( getcwd( curr_dir, sizeof( curr_dir ) ) == NULL ) {
__set_errno( ENOENT );
return( NULL );
}
len = strlen( curr_dir );
_WILL_FIT( len );
strcpy( q, curr_dir );
q += len;
if( q[ -1 ] != '/' ) {
_WILL_FIT( 1 );
*(q++) = '/';
}
for( ;; ) {
if( p[ 0 ] == '\0' )
break;
if( p[ 0 ] != '.' ) {
_WILL_FIT( 1 );
*(q++) = *(p++);
continue;
}
++p;
if( _IS_SLASH( p[ 0 ] ) ) {
/* ignore "./" in directory specs */
if( ! _IS_SLASH( q[ -1 ] ) ) {
*q++ = '/';
}
++p;
continue;
}
if( p[ 0 ] == '\0' )
break;
if( p[ 0 ] == '.' && _IS_SLASH( p[ 1 ] ) ) {
/* go up a directory for a "../" */
p += 2;
if( ! _IS_SLASH( q[ -1 ] ) ) {
return( NULL );
}
q -= 2;
for( ;; ) {
if( q < buff ) {
return( NULL );
}
if( _IS_SLASH( *q ) )
break;
--q;
}
++q;
*q = '\0';
continue;
}
_WILL_FIT( 1 );
*(q++) = '.';
}
*q = '\0';
} else {
len = strlen( p );
_WILL_FIT( len );
strcpy( q, p );
}
return( buff );
#else
const CHAR_TYPE *p;
CHAR_TYPE *q;
size_t len;
int path_drive_idx;
char curr_dir[ _MAX_PATH ];
p = path;
q = buff;
_WILL_FIT( 2 );
if( __F_NAME(isalpha,iswalpha)( p[ 0 ] ) && p[ 1 ] == STRING( ':' ) ) {
path_drive_idx = ( __F_NAME(tolower,towlower)( p[ 0 ] ) - STRING( 'a' ) ) + 1;
q[ 0 ] = p[ 0 ];
q[ 1 ] = p[ 1 ];
p += 2;
} else {
#if defined(__OS2__)
ULONG drive_map;
OS_UINT os2_drive;
if( DosQCurDisk( &os2_drive, &drive_map ) ) {
__set_errno( ENOENT );
return( NULL );
}
path_drive_idx = os2_drive;
#else
path_drive_idx = TinyGetCurrDrive() + 1;
#endif
q[ 0 ] = STRING( 'A' ) + ( path_drive_idx - 1 );
q[ 1 ] = STRING( ':' );
}
q += 2;
if( ! _IS_SLASH( p[ 0 ] ) ) {
#if defined(__OS2__)
OS_UINT dir_len = sizeof( curr_dir );
if( DosQCurDir( path_drive_idx, curr_dir, &dir_len ) ) {
__set_errno( ENOENT );
return( NULL );
}
#else
if( __getdcwd( curr_dir, path_drive_idx ) ) {
__set_errno( ENOENT );
return( NULL );
}
#endif
len = strlen( curr_dir );
if( curr_dir[ 0 ] != '\\' ) {
_WILL_FIT( 1 );
*(q++) = STRING( '\\' );
}
_WILL_FIT( len );
#ifdef __WIDECHAR__
if( mbstowcs( q, curr_dir, len + 1 ) == (size_t)-1 ) {
return( NULL );
}
#else
strcpy( q, curr_dir );
#endif
q += len;
if( q[ -1 ] != STRING( '\\' ) ) {
_WILL_FIT( 1 );
*(q++) = STRING( '\\' );
}
for( ;; ) {
if( p[ 0 ] == NULLCHAR )
break;
if( p[ 0 ] != STRING( '.' ) ) {
_WILL_FIT( 1 );
*(q++) = *(p++);
continue;
}
++p; // at least '.'
if( _IS_SLASH( p[ 0 ] ) ) {
/* ignore "./" in directory specs */
if( ! _IS_SLASH( q[ -1 ] ) ) {
*q++ = STRING( '\\' );
}
++p;
continue;
}
if( p[ 0 ] == NULLCHAR )
break;
if( p[ 0 ] == STRING( '.' ) ) { /* .. */
++p;
if( _IS_SLASH( p[ 0 ] ) ) { /* "../" */
++p;
}
if( ! _IS_SLASH( q[ -1 ] ) ) {
return( NULL );
}
q -= 2;
for( ;; ) {
if( q < buff ) {
return( NULL );
}
if( _IS_SLASH( *q ) )
break;
if( *q == STRING( ':' ) ) {
++q;
*q = STRING( '\\' );
break;
}
--q;
}
++q;
*q = NULLCHAR;
continue;
}
_WILL_FIT( 1 );
*(q++) = STRING( '.' );
}
*q = NULLCHAR;
} else {
len = __F_NAME(strlen,wcslen)( p );
_WILL_FIT( len );
__F_NAME(strcpy,wcscpy)( q, p );
}
/* force to all backslashes */
for( q = buff; *q != NULLCHAR; ++q ) {
if( *q == STRING( '/' ) ) {
*q = STRING( '\\' );
}
}
return( buff );
#endif
}
int __F_NAME(_dospawn,_wdospawn)( int mode, CHAR_TYPE *pgmname, CHAR_TYPE *cmdline,
CHAR_TYPE *envp, const CHAR_TYPE * const argv[] )
{
STARTUPINFO sinfo;
PROCESS_INFORMATION pinfo;
DWORD rc;
BOOL osrc;
__F_NAME(__ccmdline,__wccmdline)( pgmname, argv, cmdline, 0 );
memset( &sinfo, 0, sizeof( sinfo ) );
sinfo.cb = sizeof( sinfo );
// set ShowWindow default value for nCmdShow parameter
sinfo.dwFlags = STARTF_USESHOWWINDOW;
if( mode == P_DETACH ) {
sinfo.wShowWindow = SW_HIDE;
} else {
sinfo.wShowWindow = SW_SHOWNORMAL;
}
/* When passing in Unicode environments, the OS may not know which code
* page to use when translating to MBCS in spawned program's startup
* code. Result: Possible corruption of Unicode environment variables.
*/
osrc = __lib_CreateProcess( cmdline, (mode != P_DETACH), envp, &sinfo, &pinfo );
if( osrc == FALSE ) {
DWORD err;
err = GetLastError();
if( (err == ERROR_ACCESS_DENIED)
|| (err == ERROR_BAD_EXE_FORMAT)
|| (err == ERROR_BAD_PATHNAME) ) {
err = ERROR_FILE_NOT_FOUND;
}
return( __set_errno_dos( err ) );
}
if( mode == P_WAIT ) {
if( WIN32_IS_WIN32S ) {
// this is WIN32s
Sleep( 1000 );
rc = STILL_ACTIVE;
while( rc == STILL_ACTIVE ) {
Sleep( 100 );
if( !GetExitCodeProcess( pinfo.hProcess, &rc ) ) {
return( __set_errno_nt() );
}
}
} else {
/* this is WIN32 or Windows95 */
if( WaitForSingleObject( pinfo.hProcess, INFINITE ) == 0 ) {
GetExitCodeProcess( pinfo.hProcess, &rc );
} else {
rc = __set_errno_nt();
}
}
CloseHandle( pinfo.hProcess );
} else if( mode == P_DETACH ) {
/* P_DETACH should just return 0 for success */
rc = 0;
} else {
/* no difference between P_NOWAIT and P_NOWAITO */
rc = (int)pinfo.hProcess;
/* cwait will close (free) the handle */
}
CloseHandle( pinfo.hThread );
return( rc );
}
