_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 ); }