1666 lines
41 KiB
C
1666 lines
41 KiB
C
/* Release 3.00 */
|
|
/*-------------------------------------------------------------------------*
|
|
* *
|
|
* cio2.c - common I/O *
|
|
* *
|
|
* COPYRIGHT (C) 1989 Jensen and Partners. All Rights Reserved *
|
|
* Written by Simon Knight. *
|
|
* *
|
|
* COPYRIGHT (C) 1991 Psion PLC. All Rights Reserved *
|
|
* Modified by NSM. *
|
|
* *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
#define _USE_TIME
|
|
#define _USE_CONIO
|
|
#include "clib.h"
|
|
|
|
/****************************************************************************
|
|
* buffer flushing functions. *
|
|
****************************************************************************/
|
|
|
|
int _flsbuf(int ch, FILE *st) {
|
|
|
|
int flag;
|
|
|
|
ch&=0xFF;
|
|
flag=st->_flag;
|
|
if( (!flag) || (flag&_F_ERR))
|
|
return(-1);
|
|
if((flag&_F_EOF) && (flag&_F_IN)) {
|
|
lseek(st->_file, 0L, SEEK_END);
|
|
st->_flag|=_F_RST;
|
|
st->_flag&=(~(_F_IN|_F_EOF));
|
|
if(st->_size) {
|
|
_flusher(st);
|
|
--st->_cnt;
|
|
*st->_ptr++= (char) ch;
|
|
return(ch);
|
|
}
|
|
}
|
|
else {
|
|
if((!(flag&_F_WRIT)) || (flag&_F_IN)
|
|
|| ((!(flag&_F_BIN)) && ((char) ch == EOF))) {
|
|
st->_flag|=_F_ERR;
|
|
return(-1);
|
|
} /* return error */
|
|
if(st->_size) { /* buffered */
|
|
if(_flusher(st)== -1 ) /* flush buffer */
|
|
return(-1);
|
|
--st->_cnt; /* put overflow char in buffer */
|
|
*st->_ptr++= (char) ch;
|
|
return(ch);
|
|
}
|
|
st->_flag&=~_F_RST; /* clear reset flag */
|
|
if(flag&_F_APP)
|
|
lseek(st->_file, 0L, SEEK_END); /* unbuffered - write data */
|
|
}
|
|
st->_cnt=0; /* set buffer pointers */
|
|
st->_ptr=NULL;
|
|
st->_flag|=_F_OUT; /* set output flag */
|
|
if(_write(st->_file,&ch,1) != 1) {
|
|
st->_flag|=_F_ERR;
|
|
return(-1);
|
|
}
|
|
if((ch == _CTLZ) && (!(flag&(_F_BIN|_F_DEV))))
|
|
/* ctl z - set EOF flag if */
|
|
st->_flag|=_F_EOF; /* text mode and not device */
|
|
return(ch);
|
|
}
|
|
|
|
int _flusher(FILE *st) /* empties output buffer */
|
|
|
|
{
|
|
unsigned wnum, flag;
|
|
char zbuf[128];
|
|
long pos;
|
|
int nr, sr;
|
|
|
|
flag=st->_flag;
|
|
if(flag&(_F_IN|_F_EOF))
|
|
return(-1);
|
|
if(flag&_F_RST) /* set up reset buffer for output */
|
|
{
|
|
st->_flag&=(~_F_RST);
|
|
st->_flag|=_F_OUT;
|
|
st->_cnt=st->_size;
|
|
st->_ptr=st->_base;
|
|
return(0); /* return - buffer wasn't full */
|
|
}
|
|
if(st->_cnt<0)
|
|
st->_cnt=0;
|
|
wnum=st->_size-st->_cnt;
|
|
if(wnum == 0) /* nothing to do - return */
|
|
return(0); /* buffer empty */
|
|
if(flag&_F_BIN) /* binary mode */
|
|
{
|
|
if(flag&_F_APP)
|
|
lseek(st->_file, 0L, SEEK_END); /* append */
|
|
if(_write(st->_file, st->_base, wnum) != wnum)
|
|
goto error;
|
|
}
|
|
else /* text mode */
|
|
{
|
|
if(flag&_F_APP) {
|
|
pos = lseek(st->_file, -128L, SEEK_END);
|
|
if(pos < 0)
|
|
lseek(st->_file, 0, SEEK_SET);
|
|
nr = _read(st->_file, zbuf, 128);
|
|
sr = nr;
|
|
if (nr == -1)
|
|
goto error;
|
|
while(--sr >= 0) {
|
|
if(zbuf[sr] != _CTLZ)
|
|
break;
|
|
}
|
|
pos = sr - nr + 1;
|
|
lseek(st->_file, pos, SEEK_END); /* append after last cltZ */
|
|
}
|
|
if(_write(st->_file, st->_base, wnum) == -1)
|
|
goto error;
|
|
if(st->_flag&_F_CTZ) {
|
|
st->_flag|=_F_EOF;
|
|
st->_cnt=0;
|
|
st->_ptr=st->_base;
|
|
return(0);
|
|
}
|
|
}
|
|
st->_cnt=st->_size; /* set buffer pointers */
|
|
st->_ptr=st->_base;
|
|
st->_flag|=_F_OUT; /* set output flag */
|
|
return(0);
|
|
error:
|
|
st->_flag|=_F_ERR;
|
|
st->_cnt=0;
|
|
return(-1);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* buffer filling functions *
|
|
****************************************************************************/
|
|
|
|
int _filbuf(FILE *st)
|
|
{
|
|
int ch, n, flag;
|
|
|
|
flag=st->_flag;
|
|
if((!flag)||(flag&(_F_EOF|_F_ERR)))
|
|
return(-1);
|
|
if((flag&_F_OUT) || (!(flag&_F_READ)))
|
|
{
|
|
st->_flag|=_F_ERR;
|
|
return(-1); /* return error */
|
|
}
|
|
if(st->_size) /* buffered */
|
|
{
|
|
if(_filler(st) <= 0 ) /* fill buffer */
|
|
return(-1);
|
|
--st->_cnt; /* get first char from buffer */
|
|
ch=*st->_ptr++;
|
|
return(ch&0xFF); /* return first character in buffer */
|
|
}
|
|
st->_cnt=0; /* reset pointers */
|
|
st->_flag|=_F_IN; /* set input flag */
|
|
st->_ptr=NULL;
|
|
st->_flag&=~_F_RST;
|
|
for(n=0; n<2; n++) /* unbuffered - read character */
|
|
{
|
|
if(_read(st->_file, &ch, 1) != 1)
|
|
{
|
|
st->_flag|=_F_EOF;
|
|
return(-1);
|
|
}
|
|
ch&=0xFF;
|
|
if((flag&_F_BIN)||(ch != '\r')) /* dont translate if binary mode */
|
|
break;
|
|
}
|
|
if((!(flag&(_F_BIN|_F_DEV))) && (ch == _CTLZ))
|
|
st->_flag|=_F_EOF; /* ctl z end of file */
|
|
return(ch);
|
|
}
|
|
|
|
int _filler(FILE *st) /* fills buffer */
|
|
{
|
|
int flag, num;
|
|
|
|
flag=st->_flag;
|
|
if(flag&(_F_OUT|_F_EOF))
|
|
return(-1);
|
|
if(flag&_F_RST)
|
|
st->_flag&=~_F_RST;
|
|
num =_read(st->_file, st->_base, st->_size);
|
|
st->_ptr=st->_base;
|
|
if(( num == -1) && (num != st->_size))
|
|
goto error;
|
|
st->_cnt=num; /* reset pointers */
|
|
st->_flag|=_F_IN; /* set input flag */
|
|
if(num == 0)
|
|
{
|
|
st->_flag|=_F_EOF; /* end of file */
|
|
return(-1);
|
|
}
|
|
return(num);
|
|
error: /* read error */
|
|
st->_flag|=_F_ERR;
|
|
st->_cnt=0;
|
|
return(-1);
|
|
}
|
|
|
|
int fputchar(int ch)
|
|
{
|
|
return(fputc(ch, stdout));
|
|
}
|
|
|
|
int fgetchar()
|
|
{
|
|
return(fgetc(stdin));
|
|
}
|
|
|
|
/****************************************************************************
|
|
* ungetc - put character back onto input stream *
|
|
****************************************************************************/
|
|
|
|
int ungetc(int ch, FILE *st)
|
|
{
|
|
int flag;
|
|
|
|
flag=st->_flag;
|
|
if((!flag) || (flag&_F_ERR))
|
|
return(EOF);
|
|
if(ch == EOF)
|
|
return(EOF); /* return EOF if error, EOF or not read mode */
|
|
if(flag&_F_OUT)
|
|
{
|
|
st->_flag|=_F_ERR;
|
|
return(EOF); /* return EOF if error, EOF or not read mode */
|
|
}
|
|
ch&=0xFF;
|
|
st->_flag&=(~_F_EOF); /* clear EOF */
|
|
if((flag&_F_RST) || (st->_size == 0))
|
|
{
|
|
st->_flag&=(~_F_RST);
|
|
st->_flag|=_F_IN;
|
|
if(st->_size)
|
|
st->_ptr=st->_base;
|
|
else
|
|
st->_ptr= (char *) &st->_pback;
|
|
if((ch == 0xA) && (!(st->_flag&_F_BIN))) {
|
|
st->_cnt=2;
|
|
*((unsigned *)st->_ptr)=0xA0D;
|
|
}
|
|
else {
|
|
st->_cnt=1;
|
|
*st->_ptr=ch;
|
|
}
|
|
return(ch);
|
|
}
|
|
if((ch == 0xA) && (!(st->_flag&_F_BIN)) && (st->_cnt < st->_size-2)) {
|
|
*--st->_ptr= (char) 0xD;
|
|
st->_cnt++;
|
|
}
|
|
*--st->_ptr= (char) ch; /* buffer not full - put it in buffer */
|
|
st->_cnt++;
|
|
return(ch);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* rewind - rewind and clear error flag *
|
|
****************************************************************************/
|
|
|
|
void rewind(FILE *st)
|
|
{
|
|
if(st->_flag)
|
|
{
|
|
st->_flag&=(~_F_ERR);
|
|
fseek(st, 0L, SEEK_SET);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* flushall - flush all open streams *
|
|
****************************************************************************/
|
|
|
|
int flushall()
|
|
{
|
|
int n, count;
|
|
|
|
count=0;
|
|
for(n=0; n< _open_max; n++)
|
|
{
|
|
if(_iob[n]._flag) /* inc count if open file */
|
|
{
|
|
fflush(&_iob[n]); /* flush buffer */
|
|
count++;
|
|
}
|
|
}
|
|
return(count); /* return number of open streams */
|
|
}
|
|
|
|
void _flushall()
|
|
{
|
|
int n;
|
|
|
|
for(n=0; n<_open_max; n++)
|
|
{
|
|
if((_iob[n]._flag) && (_iob[n]._size))
|
|
_flusher(&_iob[n]); /* flush buffer */
|
|
}
|
|
return; /* return number of open streams */
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fopen - open stream *
|
|
****************************************************************************/
|
|
|
|
#define _WRITE 2
|
|
#define NODEFMODE 4
|
|
#define _READ 8
|
|
|
|
FILE *fopen(const char *path, const char *type)
|
|
{
|
|
int num;
|
|
int handle, flag, mode;
|
|
|
|
flag=_F_RST;
|
|
mode=0;
|
|
if(_scan_type(type, &flag, &mode) < 0) /* get access mode */
|
|
return(NULL);
|
|
handle=_open_stream(path, &flag, mode); /* open the file */
|
|
if(handle < 0)
|
|
return(NULL);
|
|
num=_free_stream(); /* find a free stream */
|
|
if(num < 0)
|
|
{
|
|
close(handle);
|
|
return(NULL);
|
|
}
|
|
return(_alloc_stream(&_iob[num], handle, flag));
|
|
} /* allocate the stream */
|
|
|
|
int _scan_type(const char *type, int *fptr, int *mptr)
|
|
{ /* evaluate file mode */
|
|
int c, n;
|
|
|
|
switch(type[0])
|
|
{
|
|
case 'r':
|
|
*mptr|=(_READ|O_EXCL);
|
|
break;
|
|
case 'w':
|
|
*mptr|=(O_TRUNC|O_CREAT|_WRITE);
|
|
break;
|
|
case 'a':
|
|
*fptr|=_F_APP;
|
|
*mptr|=(_WRITE|O_APPEND|O_CREAT);
|
|
break;
|
|
default:
|
|
return(-1);
|
|
}
|
|
n=0;
|
|
do
|
|
{
|
|
c=type[++n];
|
|
switch(c)
|
|
{
|
|
case'+':
|
|
*mptr|=(_READ|_WRITE);
|
|
break;
|
|
case'b':
|
|
*fptr|=_F_BIN;
|
|
*mptr|=NODEFMODE|O_BINARY;
|
|
break;
|
|
case't':
|
|
*mptr|=NODEFMODE|O_TEXT;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} while((n < 3) && (c));
|
|
return(0);
|
|
}
|
|
|
|
int _open_stream(const char *path, int *fptr, int mode)
|
|
{
|
|
unsigned access, permission;
|
|
|
|
access=0; /* translates level 2 */
|
|
permission=0; /* access and permission */
|
|
if(!(mode&NODEFMODE)) /* flags to level 1 and */
|
|
{ /* uses open to get handle */
|
|
if(_fmode==O_BINARY)
|
|
{
|
|
*fptr|=_F_BIN;
|
|
access= O_BINARY;
|
|
}
|
|
else
|
|
access=O_TEXT;
|
|
}
|
|
if(mode&_WRITE)
|
|
{
|
|
permission|=S_IWRITE;
|
|
if(mode&_READ)
|
|
{
|
|
*fptr|=_F_RDWR;
|
|
permission|=S_IREAD;
|
|
access|=O_RDWR;
|
|
}
|
|
else
|
|
{
|
|
*fptr|=_F_WRIT;
|
|
access|=O_WRONLY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
access|=O_RDONLY;
|
|
permission=S_IREAD;
|
|
*fptr|=_F_READ;
|
|
}
|
|
access|= (mode&(O_TEXT|O_BINARY|O_CREAT|O_TRUNC|O_EXCL|O_APPEND));
|
|
return(open(path, access, permission));
|
|
}
|
|
|
|
int _valid_stream(FILE *st) /* checks stream pointer is valid */
|
|
{
|
|
if((st > &_iob[_open_max-1]) || (st < _iob) || (st->_flag==0) )
|
|
return(FALSE);
|
|
return(TRUE);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fgetpos - get current stream position *
|
|
****************************************************************************/
|
|
|
|
int fgetpos(FILE *st, fpos_t *fp)
|
|
{
|
|
long pos;
|
|
|
|
pos=ftell(st);
|
|
if(pos == -1)
|
|
return(-1);
|
|
*fp= (fpos_t) pos;
|
|
return(0);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fsetpos - set current stream position *
|
|
****************************************************************************/
|
|
|
|
int fsetpos(FILE *st, const fpos_t *fp)
|
|
{
|
|
return fseek(st, *fp, SEEK_SET);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* close.c - level 1 I/O - close file. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int close(int handle)
|
|
{
|
|
int n;
|
|
|
|
n=_close(handle); /* close file */
|
|
if(n < 0)
|
|
return(-1); /* return -1 if error */
|
|
_openfd[handle]=0; /* zero file descriptor */
|
|
return(0); /* success - return 0 */
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* eof.c - level 1 I/O - test for eof. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int eof(int handle)
|
|
{
|
|
if( (_openfd[handle]&O_TEXT) && (_openfd[handle]&_O_EOF))
|
|
return(1); /* text file ctl z eof */
|
|
if(_openfd[handle]&O_DEVICE)
|
|
return(0); /* device - no eof unless text mode */
|
|
return(_eof(handle));
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* umask.c - level 1 I/O - set file permission mask. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
unsigned umask(unsigned permission)
|
|
{
|
|
unsigned ret;
|
|
|
|
ret=_fmask;
|
|
_fmask=permission;
|
|
return(ret);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* filelength.c - returns file length. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
long filelength(int handle)
|
|
{
|
|
long pos, size;
|
|
|
|
pos=tell(handle); /* save file position */
|
|
if(pos == -1)
|
|
return(pos);
|
|
size=lseek(handle, 0L, SEEK_END); /* get file length */
|
|
lseek(handle, pos, SEEK_SET); /* restore original file position */
|
|
return(size);
|
|
}
|
|
|
|
int rmtmp(void)
|
|
{
|
|
int n, files;
|
|
|
|
n=0;
|
|
files=0;
|
|
while(n < _open_max)
|
|
{
|
|
if (_tmpfiles[n])
|
|
{
|
|
fclose(_tmpfptrs[n]);
|
|
unlink(_tmpfiles[n]);
|
|
_tmpfiles[n]=NULL;
|
|
++files;
|
|
}
|
|
++n;
|
|
}
|
|
_exit_tmp=NULL;
|
|
return(files);
|
|
}
|
|
|
|
FILE *tmpfile(void)
|
|
{
|
|
int handle,i;
|
|
FILE *ret;
|
|
char *e,*p,name[0x128];
|
|
|
|
name[0]=0;
|
|
if ((e=getenv("TMP"))!=NULL && (i=strlen(e))!=0)
|
|
{
|
|
strcpy(&name[0],e);
|
|
p=(&name[i-1]);
|
|
if (*p!='\\')
|
|
{
|
|
*p++='\\';
|
|
*p=0;
|
|
}
|
|
}
|
|
if ((handle=_creat_temp(&name[0],FA_NORMAL))==(-1))
|
|
return(NULL);
|
|
_openfd[handle]=O_BINARY|O_RDWR;
|
|
i=strlen(&name[0])+1;
|
|
if ((p=malloc(i))==NULL)
|
|
goto failed1;
|
|
strcpy(p,&name[0]);
|
|
_tmpfiles[handle]=p;
|
|
if ((ret=fdopen(handle,"w+b"))==NULL)
|
|
goto failed2;
|
|
_tmpfptrs[handle]=ret;
|
|
_exit_tmp=_exit2;
|
|
return(ret);
|
|
failed2:
|
|
free(_tmpfiles[handle]);
|
|
_tmpfiles[handle]=NULL;
|
|
failed1:
|
|
_openfd[handle]=0;
|
|
_close(handle);
|
|
return(NULL);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* console I/O section. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
char *cgets(char *s)
|
|
{
|
|
extern void *winHandle;
|
|
extern void p_xwind(void);
|
|
|
|
if(!_p_init)
|
|
{
|
|
_i_putch=_d_putch;
|
|
_i_cgets=_d_cgets;
|
|
_p_init=-1;
|
|
if (winHandle==NULL)
|
|
p_xwind();
|
|
}
|
|
return(_i_cgets(s));
|
|
}
|
|
|
|
int sopen(const char *path, int access, int shflag, ...)
|
|
{
|
|
va_list _v_argptr;
|
|
|
|
va_start(_v_argptr, shflag);
|
|
return(open(path, access|shflag, va_arg(_v_argptr, int)));
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* macro equivalents. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int ferror(FILE *st)
|
|
{
|
|
return((st)->_flag & _F_ERR);
|
|
}
|
|
|
|
int feof(FILE *st)
|
|
{
|
|
return((st)->_flag & _F_EOF);
|
|
}
|
|
|
|
int fileno(FILE *st)
|
|
{
|
|
return((st)->_file);
|
|
}
|
|
|
|
int remove(const char *path)
|
|
{
|
|
return(unlink(path));
|
|
}
|
|
|
|
int getc(FILE *st)
|
|
{
|
|
return(fgetc(st));
|
|
}
|
|
|
|
int putc(int c, FILE *st)
|
|
{
|
|
return(fputc(c, st));
|
|
}
|
|
|
|
int getchar()
|
|
{
|
|
return(fgetc(stdin));
|
|
}
|
|
|
|
int putchar(int c)
|
|
{
|
|
return(fputc(c, stdout));
|
|
}
|
|
|
|
/****************************************************************************
|
|
* puts - send string to stdout *
|
|
****************************************************************************/
|
|
|
|
int puts(const char *s)
|
|
{
|
|
int n, c, ret;
|
|
|
|
n=0;
|
|
while((c=s[n++]) != 0)
|
|
{
|
|
if(putchar(c) == EOF)
|
|
{
|
|
ret=-1;
|
|
goto puts_error;
|
|
}
|
|
}
|
|
if(putchar('\n') == EOF)
|
|
{
|
|
ret=-1;
|
|
goto puts_error;
|
|
}
|
|
ret=fflush(stdout);
|
|
puts_error:
|
|
return(ret);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* gets - get string from stdin *
|
|
****************************************************************************/
|
|
|
|
char *gets(char *s)
|
|
{
|
|
int n, c;
|
|
char *ret;
|
|
|
|
n=0;
|
|
while((c=getchar()) != '\n')
|
|
{
|
|
if(c < 0)
|
|
{
|
|
if((feof(stdin)) && (n))
|
|
break;
|
|
ret=NULL;
|
|
goto gets_error;
|
|
}
|
|
s[n++]= (char) c;
|
|
}
|
|
s[n]=0;
|
|
ret=s;
|
|
gets_error:
|
|
return(ret);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fputs - put string on stream *
|
|
****************************************************************************/
|
|
|
|
int fputs(const char *s, FILE *st)
|
|
{
|
|
int n, c, ret;
|
|
|
|
ret=0;
|
|
n=0;
|
|
while((c=s[n++]) != 0)
|
|
{
|
|
if(fputc(c, st) == EOF )
|
|
{
|
|
ret=-1;
|
|
break;
|
|
}
|
|
}
|
|
if(st->_flag&_F_DEV)
|
|
fflush(st);
|
|
return(ret);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fgets - get string from stream *
|
|
****************************************************************************/
|
|
|
|
char *fgets(char *s, int num, FILE *st)
|
|
{
|
|
int n, c;
|
|
char *ret;
|
|
|
|
n=0;
|
|
ret=s;
|
|
while( n < num-1)
|
|
{
|
|
c=fgetc(st);
|
|
if(c == -1)
|
|
{
|
|
if((feof(st)) && (n))
|
|
break;
|
|
ret=NULL;
|
|
goto fgets_end;
|
|
}
|
|
s[n++]= (char) c;
|
|
if(c == '\n')
|
|
break;
|
|
}
|
|
s[n]=0;
|
|
fgets_end:
|
|
return(ret);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* getw - get word from stream *
|
|
* putw - put word on stream *
|
|
****************************************************************************/
|
|
|
|
int getw(FILE *st)
|
|
{
|
|
unsigned hibyte, lobyte;
|
|
|
|
lobyte=fgetc(st);
|
|
hibyte=fgetc(st);
|
|
return( (hibyte*0x100)+lobyte);
|
|
}
|
|
|
|
int putw(int num, FILE *st)
|
|
{
|
|
int ret;
|
|
|
|
fputc(num&0xFF, st);
|
|
ret=fputc((num&0xFF00)>>8, st);
|
|
return(ret);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* clearerr - clear error and EOF flags and reset buffer status *
|
|
****************************************************************************/
|
|
|
|
void clearerr(FILE *st)
|
|
|
|
{
|
|
if(st->_flag)
|
|
{
|
|
st->_flag&=~(_F_ERR|_F_EOF|_F_CTZ);
|
|
_openfd[st->_file]&= (~_O_EOF);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fseek - position stream pointer *
|
|
****************************************************************************/
|
|
|
|
int fseek(FILE *st, long offset, int orig)
|
|
{
|
|
long ret, temp, pos;
|
|
int flag;
|
|
|
|
flag=st->_flag;
|
|
if((!flag) || (flag&_F_ERR))
|
|
{
|
|
errno=EBADF;
|
|
ret=-1;
|
|
goto fseek_end;
|
|
}
|
|
if(orig == SEEK_CUR)
|
|
{
|
|
if((!(flag&(_F_WRIT|_F_RST))) && (st->_size)) {
|
|
if(offset == 0) {
|
|
ret=0;
|
|
goto fseek_end;
|
|
}
|
|
else if(offset < 0)
|
|
pos=st->_ptr-st->_base;
|
|
else
|
|
pos=st->_cnt;
|
|
if(pos > labs(offset)) {
|
|
st->_cnt-=(short)offset;
|
|
st->_ptr+=(short)offset;
|
|
ret=0;
|
|
goto fseek_end;
|
|
}
|
|
}
|
|
temp=ftell(st);
|
|
ret=fseek(st, temp+offset, SEEK_SET);
|
|
if(ret)
|
|
ret = -1L;
|
|
goto fseek_end;
|
|
}
|
|
if((st->_size) && (flag&_F_OUT)) /* flush output buffer */
|
|
_flusher(st);
|
|
st->_pback=0; /* reset buffer */
|
|
st->_cnt=0;
|
|
st->_flag|=_F_RST;
|
|
ret=lseek(st->_file, offset, orig);
|
|
st->_flag&=~(_F_IN|_F_OUT|_F_EOF|_F_CTZ); /* clear direction flag and EOF */
|
|
_openfd[st->_file]&=~(_O_EOF);
|
|
fseek_end:
|
|
if(ret < 0)
|
|
return(1);
|
|
return(0);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* ftell - return stream pointer *
|
|
****************************************************************************/
|
|
|
|
long ftell(FILE *st)
|
|
{
|
|
long pos, ret;
|
|
int flag;
|
|
|
|
flag=st->_flag;
|
|
if((!flag) || (flag&_F_ERR))
|
|
{
|
|
errno=EINVAL;
|
|
ret=-1L;
|
|
goto ftell_error;
|
|
}
|
|
if((flag&_F_RST) || (!st->_size)) /* unbuffered or reset stream */
|
|
{
|
|
st->_cnt=0;
|
|
ret=tell(st->_file);
|
|
}
|
|
else if(flag&_F_OUT) /* output stream */
|
|
{
|
|
_flusher(st); /* flush stream */
|
|
ret=tell(st->_file);
|
|
}
|
|
else
|
|
{
|
|
pos=tell(st->_file); /* input stream */
|
|
if(st->_pback != 0)
|
|
--pos;
|
|
if((flag&_F_BIN) && (st->_pback == 0xA0D))
|
|
--pos;
|
|
ret=pos-st->_cnt;
|
|
}
|
|
ftell_error:
|
|
return(ret);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fflush - flush stream *
|
|
****************************************************************************/
|
|
|
|
int fflush(FILE *st)
|
|
{
|
|
int flag, ret;
|
|
|
|
if(st == NULL)
|
|
{
|
|
flushall();
|
|
return(0);
|
|
}
|
|
flag=st->_flag;
|
|
if((!flag)||(flag&(_F_EOF|_F_ERR)))
|
|
{
|
|
ret=EOF; /* error EOF or not open */
|
|
goto fflush_end;
|
|
}
|
|
if(!st->_size)
|
|
{
|
|
st->_cnt=0;
|
|
st->_flag|=_F_RST;
|
|
st->_flag&=~(_F_OUT|_F_IN);
|
|
ret=0; /* no buffer */
|
|
goto fflush_end;
|
|
}
|
|
if(flag&_F_OUT)
|
|
ret=_flusher(st); /* flush output buffer */
|
|
else
|
|
{
|
|
fseek(st, ftell(st), SEEK_SET);
|
|
ret=0;
|
|
goto fflush_end;
|
|
}
|
|
st->_pback=0; /* reset buffer */
|
|
st->_cnt=0;
|
|
st->_flag|=_F_RST;
|
|
st->_flag&=~(_F_OUT|_F_IN);
|
|
fflush_end:
|
|
return(ret);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fdopen - assign stream to handle *
|
|
****************************************************************************/
|
|
|
|
#define _WRITE 2
|
|
#define NODEFMODE 4
|
|
#define _READ 8
|
|
|
|
FILE *fdopen(int handle, char *type)
|
|
{
|
|
int num;
|
|
int flag, mode;
|
|
|
|
flag=_F_RST;
|
|
mode=0;
|
|
if(handle < 0) /* bad handle */
|
|
{
|
|
errno=EBADF;
|
|
return(NULL);
|
|
}
|
|
if(_scan_type(type, &flag, &mode) < 0) /* get the access mode */
|
|
return(NULL);
|
|
if((!(mode&NODEFMODE))&&(_fmode==O_BINARY))
|
|
flag|=_F_BIN;
|
|
if(mode&_WRITE)
|
|
{
|
|
if(mode&_READ)
|
|
flag|=_F_RDWR;
|
|
else
|
|
flag|=_F_WRIT;
|
|
}
|
|
else
|
|
flag|=_F_READ;
|
|
num=_free_stream(); /* find a free stream */
|
|
if(num < 0)
|
|
{
|
|
close(handle);
|
|
return(NULL);
|
|
}
|
|
return(_alloc_stream(&_iob[num], handle, flag));
|
|
} /* allocate the stream */
|
|
|
|
FILE * _alloc_stream(FILE *stream, int handle, int flag)
|
|
{
|
|
stream->_file=handle; /* allocates buffer and sets flags */
|
|
stream->_flag=flag;
|
|
stream->_cnt=0;
|
|
stream->_pback=0;
|
|
stream->_size=BUFSIZ;
|
|
if(_openfd[handle]&O_DEVICE)
|
|
stream->_flag|=_F_DEV;
|
|
if((stream->_base= (char *) malloc(BUFSIZ)) == NULL)
|
|
{
|
|
stream->_size=0; /* no memory for buffer */
|
|
stream->_ptr=NULL;
|
|
errno=ENOMEM;
|
|
}
|
|
else
|
|
{
|
|
stream->_size=BUFSIZ;
|
|
stream->_ptr=stream->_base;
|
|
}
|
|
return(stream);
|
|
}
|
|
|
|
int _free_stream() /* find a free stream */
|
|
{
|
|
int n;
|
|
|
|
for(n=0; n < _open_max; n++)
|
|
{
|
|
if(_iob[n]._flag == 0)
|
|
return(n);
|
|
}
|
|
return(-1);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* freopen - close existing stream and assign new file *
|
|
****************************************************************************/
|
|
|
|
FILE *freopen(const char *path, const char *type, FILE *st)
|
|
{
|
|
int handle, flag, mode;
|
|
|
|
if(fclose(st) == EOF) /* close old stream */
|
|
return(NULL);
|
|
flag=_F_RST;
|
|
mode=0;
|
|
if(_scan_type(type, &flag, &mode) < 0) /* get file mode */
|
|
goto fr_error;
|
|
handle=_open_stream(path, &flag, mode); /* open new */
|
|
if(handle < 0)
|
|
goto fr_error;
|
|
return(_alloc_stream(st, handle, flag)); /* assign to stream */
|
|
fr_error:
|
|
return(NULL);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fclose - close stream *
|
|
****************************************************************************/
|
|
|
|
int fclose(FILE *st)
|
|
{
|
|
int ret;
|
|
|
|
ret=0;
|
|
if(!_valid_stream(st))
|
|
{
|
|
ret=-1;
|
|
goto fclose_error;
|
|
}
|
|
if(st->_size)
|
|
_flusher(st); /* flush buffer if any */
|
|
if(close(st->_file) < 0) /* close file */
|
|
ret=-1;
|
|
if((st->_base != NULL) && (!(st->_flag&_F_UBUF)))
|
|
free(st->_base); /* free system allocated buffer */
|
|
st->_flag=0; /* free stream */
|
|
if(_tmpfiles[st->_file])
|
|
{
|
|
unlink(_tmpfiles[st->_file]);
|
|
free(_tmpfiles[st->_file]);
|
|
_tmpfiles[st->_file]=NULL;
|
|
}
|
|
fclose_error:
|
|
return(ret);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fcloseall - closes all streams except standards *
|
|
****************************************************************************/
|
|
|
|
int fcloseall(void)
|
|
{
|
|
int n, count;
|
|
|
|
count=0;
|
|
for(n=3; n < _open_max; n++)
|
|
{
|
|
if(fclose(&_iob[n]) == 0)
|
|
count++;
|
|
}
|
|
return(count);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* setbuf - allocates user buffer to stream *
|
|
****************************************************************************/
|
|
|
|
void setbuf(FILE *st, char *buffer)
|
|
{
|
|
if((!_valid_stream(st))||(!(st->_flag&_F_RST))||(st->_flag&_F_UBUF))
|
|
return;
|
|
if(st->_base != NULL) /* free any system buffer */
|
|
free(st->_base);
|
|
st->_base=buffer; /* use user buffer */
|
|
st->_ptr=buffer;
|
|
if(buffer != NULL)
|
|
{
|
|
st->_size=BUFSIZ;
|
|
st->_flag|=_F_UBUF;
|
|
}
|
|
else
|
|
{
|
|
st->_size=0;
|
|
st->_flag&=~_F_LBUF;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* setvbuf - allocates user or system buffer to stream *
|
|
****************************************************************************/
|
|
|
|
int setvbuf(FILE *st, char *buffer, int type, size_t size)
|
|
{
|
|
int flag;
|
|
|
|
if((type < _IOFBF) || (type > _IONBF) || ((int) size < 0))
|
|
return(1);
|
|
flag=st->_flag;
|
|
if((!_valid_stream(st))||(!(flag&_F_RST))||(size < 0))
|
|
{
|
|
return(1);
|
|
}
|
|
if((st->_base != NULL) || (!(st->_flag&_F_UBUF))) /* free old buffer */
|
|
free(st->_base);
|
|
st->_flag&=(~_F_LBUF|_F_IN|_F_OUT);
|
|
if(type != _IONBF)
|
|
{
|
|
if(buffer==NULL)
|
|
{ /* allocate new system buffer */
|
|
buffer=malloc(size);
|
|
if(buffer==NULL)
|
|
{
|
|
errno=ENOMEM;
|
|
return(1);
|
|
}
|
|
}
|
|
else /* user buffer */
|
|
st->_flag|=_F_UBUF;
|
|
st->_base=buffer;
|
|
st->_ptr=buffer;
|
|
st->_size=size;
|
|
if(type == _IOLBF) /* line buffered */
|
|
st->_flag|=_F_LBUF;
|
|
}
|
|
else /* no buffer */
|
|
{
|
|
st->_size=0;
|
|
st->_base=NULL;
|
|
st->_ptr=NULL;
|
|
st->_cnt=0;
|
|
}
|
|
setvbuf_error:
|
|
return(0);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fread - get a number of data blocks from stream *
|
|
****************************************************************************/
|
|
|
|
size_t fread(void *buf, size_t size, size_t count, FILE *st)
|
|
{
|
|
unsigned numtoread;
|
|
unsigned pos;
|
|
int flag;
|
|
char *buffer;
|
|
long total, numleft, p;
|
|
size_t ret;
|
|
|
|
flag=st->_flag;
|
|
if((!flag) || (size == 0) || (count==0) || (flag&(_F_ERR|_F_EOF)))
|
|
{
|
|
ret=0;
|
|
goto fread_error;
|
|
}
|
|
if((flag&_F_OUT) || (!(st->_flag&_F_READ)))
|
|
{
|
|
st->_flag|=_F_ERR;
|
|
ret=0;
|
|
goto fread_error;
|
|
}
|
|
st->_flag|=_F_IN;
|
|
buffer=(char *)buf;
|
|
total=size*count; /* how many bytes are there to read */
|
|
pos=0;
|
|
if((st->_size == 0) || (!(st->_flag&_F_BIN)))
|
|
{
|
|
for(p=0; p < total; p++) /* unbuffered */
|
|
{
|
|
ret=getc(st);
|
|
if(ret == EOF )
|
|
break;
|
|
buffer[pos]= (char) ret;
|
|
pos++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
numleft=total;
|
|
p=0;
|
|
do
|
|
{
|
|
if(st->_cnt == 0) /* fill empty buffer */
|
|
{
|
|
if(_filler(st) <= 0)
|
|
break; /* error or EOF */
|
|
}
|
|
if( (long) (unsigned) st->_cnt >= numleft) /* read entire item */
|
|
numtoread = (unsigned) numleft;
|
|
else
|
|
numtoread=st->_cnt; /* read entire buffer */
|
|
memcpy(buffer, st->_ptr, numtoread);
|
|
st->_cnt-=numtoread;
|
|
buffer+=numtoread;
|
|
st->_ptr+=numtoread;
|
|
numleft-=numtoread;
|
|
p+=numtoread;
|
|
}while(numleft);
|
|
}
|
|
ret=(int) p/size;
|
|
fread_error:
|
|
return(ret); /* return number of complete items read */
|
|
}
|
|
|
|
/****************************************************************************
|
|
* fwrite - put a number of data blocks on stream *
|
|
****************************************************************************/
|
|
|
|
size_t fwrite(const void *buf, size_t size, size_t count, FILE *st)
|
|
{
|
|
unsigned numtowrite;
|
|
unsigned pos;
|
|
char *buffer;
|
|
long total, numleft, p;
|
|
int flag;
|
|
size_t ret;
|
|
|
|
flag=st->_flag;
|
|
if((!flag) || (size == 0) || (count==0) || (flag&(_F_ERR|_F_EOF)))
|
|
{
|
|
ret=0;
|
|
goto fwrite_error;
|
|
}
|
|
if((flag&_F_IN) || (!(st->_flag&_F_WRIT)))
|
|
{
|
|
st->_flag|=_F_ERR;
|
|
ret=0;
|
|
goto fwrite_error;
|
|
}
|
|
st->_flag|=_F_OUT;
|
|
buffer=(char *)buf;
|
|
pos=0;
|
|
total=size*count;
|
|
if((st->_size == 0) || (!(st->_flag&_F_BIN)))
|
|
{
|
|
for(p=0; p < total; p++) /* unbuffered */
|
|
{
|
|
if(putc(buffer[pos], st) == -1)
|
|
break;
|
|
pos++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
numleft=total;
|
|
p=0;
|
|
do
|
|
{
|
|
if( (long) (unsigned) st->_cnt >= numleft) /* write entire item */
|
|
numtowrite= (unsigned) numleft;
|
|
else
|
|
numtowrite=st->_cnt; /* write entire buffer */
|
|
memcpy(st->_ptr, buffer, numtowrite);
|
|
st->_cnt-=numtowrite;
|
|
buffer+=numtowrite;
|
|
st->_ptr+=numtowrite;
|
|
numleft-= (long) numtowrite;
|
|
if(st->_cnt == 0)
|
|
{
|
|
if(_flusher(st) < 0)
|
|
break; /* error */
|
|
}
|
|
p+=numtowrite;
|
|
}while(numleft);
|
|
}
|
|
ret=(int) p/size;
|
|
fwrite_error:
|
|
return(ret); /* return number of complete items written */
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* creat.c - creates a file.
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
int creat(const char *path, int permission)
|
|
{
|
|
int fh, fdesc;
|
|
|
|
fdesc=_fmode; /* set RTL I/O flags */
|
|
permission^=_fmask;
|
|
if(permission == S_IREAD)
|
|
{
|
|
permission=FA_RDONLY;
|
|
}
|
|
else
|
|
{
|
|
fdesc|=O_RDWR;
|
|
permission=FA_NORMAL;
|
|
}
|
|
if(_fmode&O_TEXT)
|
|
permission=FA_TEXT;
|
|
fh=_creat_trunc(path, permission); /* truncate if exists and !readonly */
|
|
if((fh < 0) || (fh >= _open_max))
|
|
return(-1);
|
|
if(isatty(fh))
|
|
fdesc|=O_DEVICE;
|
|
_openfd[fh]=fdesc; /* store file descriptor */
|
|
return(fh); /* return handle */
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* open.c - opens a file. *
|
|
* This function opens a file, setting DOS access and permision modes, *
|
|
* and stores access and translation modes in the file descriptor array *
|
|
* _openfd. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
#pragma warn(wvnu => off)
|
|
|
|
int open(const char *path, int access, ...)
|
|
{
|
|
va_list varg;
|
|
int fh, fdesc;
|
|
unsigned permission;
|
|
|
|
fdesc=0;
|
|
if(access&O_TEXT) /* defaults to _fmode */
|
|
fdesc|=O_TEXT;
|
|
else if(access&O_BINARY)
|
|
fdesc|=O_BINARY;
|
|
else if( (_fmode == O_BINARY) || (_fmode == O_TEXT))
|
|
fdesc|=_fmode;
|
|
else
|
|
fdesc|=O_BINARY;
|
|
if(access&(O_CREAT|O_APPEND|O_TRUNC)) /* create append or truncate */
|
|
{
|
|
if(access&O_CREAT)
|
|
{
|
|
va_start(varg, access);
|
|
permission=va_arg(varg, unsigned); /* get permission */
|
|
}
|
|
else
|
|
{
|
|
if(!(access&(O_RDWR|O_WRONLY)))
|
|
permission=S_IREAD;
|
|
else
|
|
permission=S_IREAD|S_IWRITE;
|
|
}
|
|
permission^=_fmask; /* exclusive or with fmask */
|
|
if(permission == S_IREAD) /* set DOS access modes */
|
|
{
|
|
permission=FA_RDONLY;
|
|
}
|
|
else
|
|
{
|
|
fdesc|=O_RDWR;
|
|
permission=FA_NORMAL;
|
|
}
|
|
if (fdesc&O_TEXT)
|
|
permission|=FA_TEXT;
|
|
if(_exists(path)) /* does file exist ? */
|
|
{
|
|
if(access&O_EXCL)
|
|
{
|
|
errno=EEXIST;
|
|
return(-1); /* if exclusive flag return error */
|
|
}
|
|
if(!(access&O_TRUNC))
|
|
goto open_file; /* if not truncate open file */
|
|
}
|
|
else if(!(access&O_CREAT)) /* create only if flag set */
|
|
{
|
|
errno=ENOENT;
|
|
return(-1);
|
|
}
|
|
fh=_creat_trunc(path, permission);
|
|
}
|
|
else
|
|
{
|
|
open_file: /* open file */
|
|
if(!(access&(O_RDWR|O_WRONLY)))
|
|
fdesc|=O_RDONLY; /* write access given */
|
|
else
|
|
{
|
|
access&=~(O_RDONLY|O_WRONLY);
|
|
access|=O_RDWR;
|
|
fdesc|=O_RDWR;
|
|
}
|
|
access&=~(O_TEXT|O_BINARY);
|
|
if (fdesc&O_TEXT)
|
|
access|=O_TEXT;
|
|
fh=_open(path, access);
|
|
}
|
|
if((fh < 0) || (fh >= _open_max)) /* invalid handle from _open or _creat */
|
|
return(-1);
|
|
if(access&O_APPEND) /* if O_APPEND set flag */
|
|
fdesc|=O_APPEND;
|
|
if(isatty(fh)) /* check for character device */
|
|
fdesc|=O_DEVICE;
|
|
_openfd[fh]=fdesc; /* store file descriptor */
|
|
return(fh); /* return handle */
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* dup.c - level 1 I/O - force duplicate file handle. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int dup(int handle)
|
|
{
|
|
int nh;
|
|
|
|
if(((nh=_dup(handle)) == -1) || (nh >= _open_max))
|
|
return(-1); /* duplication failed */
|
|
_openfd[nh]=_openfd[handle]; /* copy file desc */
|
|
return(nh); /* success - return new handle */
|
|
}
|
|
|
|
#pragma warn(wvnu => on)
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* dup2.c - level 1 I/O - force duplicate file handle. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int dup2(int oldhandle, int newhandle)
|
|
{
|
|
if(_openfd[newhandle]) /* close new handle if open */
|
|
close(newhandle); /* at level 1 */
|
|
if(_dup2(oldhandle, newhandle) < 0)
|
|
return(-1); /* duplication failed */
|
|
_openfd[newhandle]=_openfd[oldhandle]; /* copy file desc */
|
|
return(0); /* success - return 0 */
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* setmode.c - set file translation mode . *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
|
|
int setmode(int handle, unsigned mode)
|
|
{
|
|
int ret, n;
|
|
char name[P_FNAMESIZE];
|
|
|
|
if((mode != O_BINARY) && (mode != O_TEXT))
|
|
{
|
|
invalid:
|
|
errno=EINVAL;
|
|
return(-1);
|
|
}
|
|
ret=-1;
|
|
if(_openfd[handle])
|
|
{
|
|
_FsChanToName(getRealHandle(handle),&name[0]);
|
|
if (memcmp("LOC",&name[0],3)!=0)
|
|
goto invalid;
|
|
ret=_openfd[handle]&(O_BINARY|O_TEXT); /* save old mode */
|
|
_openfd[handle]&= ~(O_BINARY|O_TEXT); /* mask out old mode */
|
|
_openfd[handle]|=mode; /* set new mode */
|
|
n=-1;
|
|
while(++n < _open_max) /* look for level 2 stream */
|
|
{
|
|
if(_iob[n]._file == handle)
|
|
{
|
|
if(mode == O_BINARY) /* Binary - set flag */
|
|
_iob[n]._flag|=_F_BIN;
|
|
else
|
|
_iob[n]._flag&=~(_F_BIN); /* Text - clear flag */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
errno=EBADF; /* file wasn't open */
|
|
return(ret);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* stat and fstat - return file status information in stat structure. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
#define MAX_EXTS 4
|
|
static char exec_exts[MAX_EXTS][5]={ ".BTF", ".OPO", ".APP",".IMG"};
|
|
|
|
int stat(const char *path, struct stat *statbuf)
|
|
|
|
{
|
|
int fmode, temp, drive, fh, n;
|
|
long time;
|
|
|
|
if (!_isloc(path))
|
|
{
|
|
errno=EINVAL;
|
|
return(-1);
|
|
}
|
|
temp=0;
|
|
fmode=_chmod(path, 0, 0); /* get access mode and file type */
|
|
if(fmode == -1)
|
|
{
|
|
errno=ENOENT;
|
|
return(-1);
|
|
}
|
|
statbuf->st_nlink=1; /* nlink is always one */
|
|
if(fmode&0x18)
|
|
{
|
|
statbuf->st_mode=S_IFDIR;
|
|
return(0);
|
|
}
|
|
else
|
|
temp|=S_IFREG;
|
|
if(fmode&1)
|
|
temp|=S_IREAD;
|
|
else
|
|
temp|=S_IREAD|S_IWRITE;
|
|
fh=_open(path, O_RDONLY); /* open the file */
|
|
if(fh < 0)
|
|
return(-1);
|
|
if(isatty(fh)) /* is it a device */
|
|
temp|=S_IFCHR;
|
|
else /* if it is a file get drive, length */
|
|
/* and time info plus exec status */
|
|
{
|
|
drive=_filedrive(fh);
|
|
statbuf->st_dev=drive;
|
|
statbuf->st_rdev=drive;
|
|
n=0;
|
|
while(n < MAX_EXTS)
|
|
{
|
|
if(strstr(path, exec_exts[n]))
|
|
{
|
|
temp|=S_IEXEC;
|
|
break;
|
|
}
|
|
++n;
|
|
}
|
|
statbuf->st_size=filelength(fh);
|
|
time=get_utime(fh);
|
|
statbuf->st_atime=time;
|
|
statbuf->st_mtime=time;
|
|
statbuf->st_ctime=time;
|
|
}
|
|
statbuf->st_mode=temp;
|
|
_close(fh); /* close the file */
|
|
return(0);
|
|
}
|
|
|
|
int fstat(int handle, struct stat *statbuf)
|
|
{
|
|
int fmode, temp, drive;
|
|
long time;
|
|
|
|
temp=0;
|
|
fmode=_openfd[handle];
|
|
if(fmode == 0)
|
|
{
|
|
errno=EBADF;
|
|
return(-1);
|
|
}
|
|
temp|=S_IFREG; /* get access etc from file descriptor */
|
|
if(fmode&O_RDWR)
|
|
temp|=S_IREAD|S_IWRITE;
|
|
else if(fmode&O_WRONLY)
|
|
temp|=S_IWRITE;
|
|
else
|
|
temp|=S_IREAD;
|
|
if(fmode&O_DEVICE)
|
|
{
|
|
temp|=S_IFCHR;
|
|
drive=handle;
|
|
}
|
|
else /* if it is a file get length, drive */
|
|
{ /* and time info */
|
|
statbuf->st_size=filelength(handle);
|
|
time=get_utime(handle);
|
|
statbuf->st_atime=time;
|
|
statbuf->st_mtime=time;
|
|
statbuf->st_ctime=time;
|
|
drive=_filedrive(handle);
|
|
}
|
|
statbuf->st_dev=drive;
|
|
statbuf->st_rdev=drive;
|
|
statbuf->st_mode=temp;
|
|
statbuf->st_nlink=1; /* nlink is always one */
|
|
return(0);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* chsize - change size of file . *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
#define SECSIZE 2024L
|
|
|
|
int chsize(int handle, long size)
|
|
{
|
|
char *h;
|
|
int ret,mode;
|
|
|
|
if ((h=getRealHandle(handle))==NULL)
|
|
return(-1);
|
|
if ((ret=_iow3(h,P_FSETEOF,&size))<0)
|
|
{
|
|
_ioerr(ret);
|
|
return(-1);
|
|
}
|
|
mode=P_FABS;
|
|
_iow4(h,P_FSEEK,&mode,&size);
|
|
return(0);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* getcwd.c - returns pointer to buffer containing current directory. *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
char *getcwd(char *buf, int maxlen)
|
|
{
|
|
char temp[P_FNAMESIZE];
|
|
int n,p,aflag;
|
|
|
|
aflag=0;
|
|
_getPath(&temp[0]);
|
|
if(buf == NULL)
|
|
{
|
|
buf=(char *) malloc(maxlen); /* if buffer is null allocate memory */
|
|
if(buf == NULL)
|
|
{
|
|
errno=ENOMEM; /* no memory - error */
|
|
return(NULL);
|
|
}
|
|
aflag=1;
|
|
}
|
|
n=0;
|
|
p=P_FSYSNAMESIZE;
|
|
while(n < maxlen) /* copy maxlen bytes to buffer */
|
|
{
|
|
if((buf[n++]=temp[p++]) == 0)
|
|
{
|
|
if ((n=strlen(&buf[0]))!=3)
|
|
buf[n-1]=0;
|
|
return(buf);
|
|
}
|
|
}
|
|
errno=ERANGE; /* string too long */
|
|
if(aflag) /* free heap alocated buffer */
|
|
free(buf);
|
|
return(NULL);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*
|
|
* console I/O *
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void cputs(const char *s)
|
|
{
|
|
int n, c;
|
|
|
|
n=0;
|
|
if(_ungotchar!=(-1))
|
|
{
|
|
putch(_ungotchar);
|
|
_ungotchar=(-1);
|
|
}
|
|
while((c=s[n++]) != 0)
|
|
{
|
|
putch(c);
|
|
}
|
|
return;
|
|
}
|
|
|