RET_T TouchFile( const char *name )
/****************************************/
{
tiny_date_t dt;
tiny_time_t tm;
tiny_ftime_t p_hms;
tiny_fdate_t p_ymd;
tiny_ret_t ret;
ret = TinyOpen( name, TIO_WRITE );
if( TINY_OK( ret ) ) {
dt = TinyGetDate();
p_ymd.year = dt.year + (1900 - 1980);
p_ymd.month = dt.month;
p_ymd.day = dt.day_of_month;
tm = TinyGetTime();
p_hms.hours = tm.hour;
p_hms.minutes = tm.minutes;
p_hms.twosecs = tm.seconds / 2;
TinySetFileStamp( TINY_INFO( ret ), p_hms, p_ymd );
TinyClose( TINY_INFO( ret ) );
} else {
ret = TinyCreate( name, TIO_NORMAL );
if( TINY_OK( ret ) ) {
TinyClose( TINY_INFO( ret ) );
} else {
return( RET_ERROR );
}
}
return( RET_SUCCESS );
}
sys_handle LocalOpen( const char *name, open_access access )
{
tiny_ret_t ret;
unsigned mode;
if( (access & OP_WRITE) == 0 ) {
mode = TIO_READ;
access &= ~(OP_CREATE|OP_TRUNC);
} else if( access & OP_READ ) {
mode = TIO_READ_WRITE;
} else {
mode = TIO_WRITE;
}
if( access & (OP_CREATE|OP_TRUNC) ) {
ret = TinyCreate( name, TIO_NORMAL );
} else {
if( _osmajor >= 3 ) mode |= 0x80; /* set no inheritance */
ret = TinyOpen( name, mode );
}
if( TINY_ERROR( ret ) ) {
StashErrCode( TINY_INFO( ret ), OP_LOCAL );
return( NIL_SYS_HANDLE );
}
return( TINY_INFO( ret ) );
}
size_t LocalRead( sys_handle filehndl, void *ptr, size_t len )
{
tiny_ret_t ret;
size_t total;
unsigned piece_len;
unsigned read_len;
piece_len = INT_MAX;
total = 0;
while( len > 0 ) {
if( piece_len > len )
piece_len = (unsigned)len;
ret = TinyRead( filehndl, ptr, piece_len );
if( TINY_ERROR( ret ) ) {
StashErrCode( TINY_INFO( ret ), OP_LOCAL );
return( ERR_RETURN );
}
read_len = TINY_INFO( ret );
total += read_len;
if( read_len != piece_len )
break;
ptr = (char *)ptr + read_len;
len -= read_len;
}
return( total );
}
f_handle QOpenRW( char *name )
/***********************************/
{
tiny_ret_t h;
h = DoOpen( name, TRUE, TIO_NORMAL );
if( TINY_OK( h ) ) return( (f_handle)TINY_INFO( h ) );
LnkMsg( FTL+MSG_CANT_OPEN, "12", name, QErrMsg( TINY_INFO( h ) ) );
return( NIL_HANDLE );
}
f_handle ExeCreate( char *name )
/*************************************/
{
tiny_ret_t h;
h = DoOpen( name, TRUE, TIO_NORMAL );
LastResult = TINY_INFO( h );
if( TINY_OK( h ) ) return( TINY_INFO( h ) );
return( NIL_HANDLE );
}
static f_handle NSOpen( char *name, unsigned mode )
/*************************************************/
{
tiny_ret_t h;
h = DoOpen( name, FALSE, mode );
LastResult = TINY_INFO( h );
if( TINY_OK( h ) ) return( TINY_INFO( h ) );
return( NIL_HANDLE );
}
unsigned LocalWrite( sys_handle filehndl, const void *ptr, unsigned len )
{
tiny_ret_t ret;
ret = TinyWrite( filehndl, ptr, len );
if( TINY_ERROR( ret ) ) {
StashErrCode( TINY_INFO( ret ), OP_LOCAL );
return( ERR_RETURN );
}
return( TINY_INFO( ret ) );
}
trap_retval ReqFile_write_console( void )
{
tiny_ret_t rc;
file_write_console_ret *ret;
ret = GetOutPtr( 0 );
rc = TinyWrite( TINY_ERR, GetInPtr( sizeof( file_write_console_req ) ), ( GetTotalSize() - sizeof( file_write_console_req ) ) );
ret->len = TINY_INFO( rc );
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
return( sizeof( *ret ) );
}
void QDelete( char *name )
/*******************************/
{
tiny_ret_t h;
if( name == NULL ) return;
h = TinyDelete( name );
if( TINY_ERROR( h ) ) {
if( TINY_INFO( h ) != 2 ) { /* file not found is OK */
LnkMsg( ERR+MSG_IO_PROBLEM, "12", name, QErrMsg( TINY_INFO( h ) ) );
}
}
}
trap_retval ReqFile_write( void )
{
tiny_ret_t rc;
file_write_req *acc;
file_write_ret *ret;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
rc = TinyWrite( TRPH2LH( acc ), GetInPtr( sizeof( *acc ) ), ( GetTotalSize() - sizeof( *acc ) ) );
ret->len = TINY_INFO( rc );
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
return( sizeof( *ret ) );
}
_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
}
_WCRTLINK unsigned _dos_open( const char *path, unsigned mode, int *handle )
/**************************************************************************/
{
#ifdef __WATCOM_LFN__
tiny_ret_t rc = 0;
if( _RWD_uselfn && TINY_OK( rc = __dos_open_lfn( path, mode ) ) ) {
*handle = TINY_INFO( rc );
return( 0 );
}
if( IS_LFN_ERROR( rc ) ) {
return( __set_errno_dos_reterr( TINY_INFO( rc ) ) );
}
#endif
return( __dos_open_sfn_err( path, mode, handle ) );
}
_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 unsigned _dos_findnext( struct find_t *buf ) {
/*****************************************************/
#if defined(__OS2_286__)
if( _RWD_osmode == OS2_MODE ) { /* protected mode */
#endif
APIRET rc;
FF_BUFFER dir_buff;
OS_UINT searchcount = 1;
rc = DosFindNext( FIND_HANDLE_OF( buf ), (PVOID)&dir_buff,
sizeof( dir_buff ), &searchcount );
if( rc != 0 ) {
return( __set_errno_dos_reterr( rc ) );
}
copydir( buf, &dir_buff );
#if defined(__OS2_286__)
} else { /* real mode */
tiny_ret_t rc;
void __far * old_dta;
old_dta = TinyFarChangeDTA( buf ); /* set our DTA */
rc = TinyFindNext();
TinyFarSetDTA( old_dta ); /* restore DTA */
if( TINY_ERROR( rc ) ) {
return( __set_errno_dos_reterr( TINY_INFO( rc ) ) );
}
}
#endif
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 );
}
trap_retval ReqFile_run_cmd( void )
{
file_run_cmd_ret *ret;
#if defined(__WINDOWS__)
ret = GetOutPtr( 0 );
ret->err = 0;
#else
bool chk;
char buff[64];
file_run_cmd_req *acc;
unsigned len;
tiny_ret_t rc;
acc = GetInPtr( 0 );
len = GetTotalSize() - sizeof( *acc );
ret = GetOutPtr( 0 );
chk = CheckPointMem( acc->chk_size, buff );
rc = Fork( (char *)GetInPtr( sizeof(*acc) ), len );
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
if( chk ) CheckPointRestore();
#endif
return( sizeof( *ret ) );
}
trap_retval ReqFile_string_to_fullpath( void )
{
char *name;
char *fullname;
char *ext_list;
file_string_to_fullpath_req *acc;
file_string_to_fullpath_ret *ret;
tiny_ret_t rc;
acc = GetInPtr( 0 );
name = GetInPtr( sizeof( *acc ) );
ret = GetOutPtr( 0 );
fullname = GetOutPtr( sizeof( *ret ) );
if( acc->file_type == TF_TYPE_EXE ) {
ext_list = GetExeExtensions();
} else {
ext_list = "";
}
rc = FindFilePath( name, fullname, ext_list );
if( TINY_OK( rc ) ) {
ret->err = 0;
} else {
ret->err = TINY_INFO( rc );
*fullname = '\0';
}
return( sizeof( *ret ) + 1 + strlen( fullname ) );
}
unsigned QRead( f_handle file, void *buffer, unsigned len, char *name )
/****************************************************************************/
/* read into far memory */
{
tiny_ret_t h;
CheckBreak();
h = TinyRead( file, buffer, len );
if( TINY_ERROR( h ) ) {
if( name != NULL ) {
LnkMsg( ERR+MSG_IO_PROBLEM, "12", name, QErrMsg( TINY_INFO( h ) ) );
} else {
return( -1 );
}
}
return( TINY_INFO(h) );
}
trap_retval ReqFile_erase( void )
{
tiny_ret_t rc;
file_erase_ret *ret;
ret = GetOutPtr( 0 );
rc = TinyDelete( (char *)GetInPtr( sizeof( file_erase_req ) ) );
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
return( sizeof( *ret ) );
}
error_idx LocalClose( sys_handle filehndl )
{
tiny_ret_t ret;
ret = TinyClose( filehndl );
if( TINY_ERROR( ret ) ) {
return( StashErrCode( TINY_INFO( ret ), OP_LOCAL ) );
}
return( 0 );
}
error_idx LocalErase( const char *name )
{
tiny_ret_t ret;
ret = TinyDelete( name );
if( TINY_ERROR( ret ) ) {
return( StashErrCode( TINY_INFO( ret ), OP_LOCAL ) );
}
return( 0 );
}
static void ioSuppTempOpen( // OPEN TEMPORARY FILE
void )
{
auto char fname[_MAX_PATH];
for(;;) {
tempFname( fname );
#if defined(__DOS__)
{
tiny_ret_t rc;
rc = TinyCreateNew( fname, 0 );
if( TINY_ERROR( rc ) ) {
temphandle = -1;
} else {
temphandle = TINY_INFO( rc );
__SetIOMode( temphandle, _READ | _WRITE | _BINARY );
}
}
#else
temphandle = open( fname, AMODE, PMODE_RW );
#endif
if( temphandle != -1 ) break;
if( workFile[5] == 'Z' ) {
temphandle = -1;
break;
}
switch( workFile[5] ) {
case '9':
workFile[5] = 'A';
break;
case 'I':
workFile[5] = 'J'; /* file-system may be EBCDIC */
break;
case 'R':
workFile[5] = 'S'; /* file-system may be EBCDIC */
break;
default:
++workFile[5];
break;
}
}
#if defined(__UNIX__)
/* Under POSIX it's legal to remove a file that's open. The file
space will be reclaimed when the handle is closed. This makes
sure that the work file always gets removed. */
remove( fname );
tempname = NULL;
#else
tempname = FNameAdd( fname );
#endif
if( temphandle == -1 ) {
ioSuppError( ERR_UNABLE_TO_OPEN_WORK_FILE );
}
}
trap_retval ReqFile_read( void )
{
tiny_ret_t rc;
file_read_req *acc;
file_read_ret *ret;
char *buff;
unsigned len;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
buff = GetOutPtr( sizeof( *ret ) );
rc = TinyRead( acc->handle, buff, acc->len );
if( TINY_ERROR( rc ) ) {
ret->err = TINY_INFO( rc );
len = 0;
} else {
ret->err = 0;
len = TINY_INFO( rc );
}
return( sizeof( *ret ) + len );
}
trap_retval ReqFile_close( void )
{
tiny_ret_t rc;
file_close_req *acc;
file_close_ret *ret;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
rc = TinyClose( acc->handle );
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
return( sizeof( *ret ) );
}
unsigned long LocalSeek( sys_handle hdl, unsigned long len, unsigned method )
{
tiny_ret_t ret;
unsigned long pos;
ret = TinyLSeek( hdl, len, method, &pos );
if( TINY_ERROR( ret ) ) {
StashErrCode( TINY_INFO( ret ), OP_LOCAL );
return( -1UL );
}
return( pos );
}
unsigned long LocalSeek( sys_handle hdl, unsigned long npos, seek_method method )
{
tiny_ret_t ret;
unsigned long pos;
ret = TinyLSeek( hdl, npos, method, (u32_stk_ptr)&pos );
if( TINY_ERROR( ret ) ) {
StashErrCode( TINY_INFO( ret ), OP_LOCAL );
return( -1UL );
}
return( pos );
}
void QClose( f_handle file, char *name )
/*********************************************/
/* file close */
{
tiny_ret_t h;
CheckBreak();
h = TinyClose( file );
OpenFiles--;
if( TINY_OK( h ) || name == NULL ) return;
LnkMsg( ERR+MSG_IO_PROBLEM, "12", name, QErrMsg( TINY_INFO( h ) ) );
}
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 unsigned _dos_findfirst( const char *path, unsigned attrib,
struct find_t *fdta )
/******************************************************************************/
{
#ifdef __WATCOM_LFN__
lfnfind_t lfndta;
tiny_ret_t rc = 0;
LFN_SIGN_OF( fdta ) = 0;
LFN_HANDLE_OF( fdta ) = 0;
if( _RWD_uselfn && TINY_OK( rc = _dos_find_first_lfn( path, attrib, &lfndta ) ) ) {
convert_to_find_t( fdta, &lfndta );
LFN_SIGN_OF( fdta ) = _LFN_SIGN;
LFN_HANDLE_OF( fdta ) = TINY_INFO( rc );
return( 0 );
}
if( IS_LFN_ERROR( rc ) ) {
return( __set_errno_dos_reterr( TINY_INFO( rc ) ) );
}
#endif
return( __dos_find_first_dta( path, attrib, fdta ) );
}
static unsigned dosalloc( unsigned min )
{
tiny_ret_t rc;
unsigned block;
rc = TinyAllocBlock( min );
if( TINY_ERROR( rc ) ) {
return( 0 );
}
block = TINY_INFO( rc );
dosexpand( block );
return( block );
}
