lyrathorpe/sibo-playground
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity
Files
0e765bc90cdacbbcda26cf424cb449c1e8c86263
sibo-playground/code/SIBOSDK/src/cio2.c
T

1666 lines
41 KiB
C
Raw Normal View History

build: add the SIBO SDK
2026-07-06 18:01:36 +01:00
/* 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;
}
Reference in New Issue Copy Permalink