add LCC - a better C-Compiler for WEGA
This commit is contained in:
Oliver Lehmann
parent
248a4b9042
commit
2b6598fb74
|
|
@ -0,0 +1,17 @@
|
|||
struct hdr {
|
||||
char *lpc;
|
||||
char *hpc;
|
||||
int nfns;
|
||||
};
|
||||
|
||||
struct cnt {
|
||||
char *fnpc;
|
||||
long mcnt;
|
||||
};
|
||||
|
||||
typedef unsigned short WORD;
|
||||
|
||||
#define MON_OUT "mon.out"
|
||||
#define MPROGS0 600
|
||||
#define MSCALE0 4
|
||||
#define NULL 0
|
||||
|
|
@ -0,0 +1,235 @@
|
|||
#include <stdio.h>
|
||||
#include "stdiom.h"
|
||||
#include <errno.h>
|
||||
|
||||
extern void free();
|
||||
extern int errno, write(), close(), isatty();
|
||||
extern char *malloc();
|
||||
extern FILE *_lastbuf;
|
||||
extern unsigned char *_stdbuf[];
|
||||
extern unsigned char _smbuf[][_SBFSIZ];
|
||||
|
||||
/*
|
||||
* Flush buffers on exit
|
||||
*/
|
||||
|
||||
void
|
||||
_cleanup()
|
||||
{
|
||||
register FILE *iop;
|
||||
|
||||
for(iop = _iob; iop < _lastbuf; iop++)
|
||||
(void) fclose(iop);
|
||||
}
|
||||
/*
|
||||
fclose() will flush (output) buffers for a buffered open
|
||||
FILE and then issue a system close on the _fileno. The
|
||||
_base field will be reset to NULL for any but stdin and
|
||||
stdout, the _ptr field will be set the same as the _base
|
||||
field. The _flags and the _cnt field will be zeroed.
|
||||
If buffers had been obtained via malloc(), the space will
|
||||
be free()'d. In case the FILE was not open, or fflush()
|
||||
or close() failed, an EOF will be returned, otherwise the
|
||||
return value is 0.
|
||||
*/
|
||||
|
||||
int
|
||||
fclose(iop)
|
||||
register FILE *iop;
|
||||
{
|
||||
register int rtn=EOF;
|
||||
|
||||
if(iop == NULL)
|
||||
return(rtn);
|
||||
if(iop->_flag & (_IOREAD | _IOWRT | _IORW)) {
|
||||
rtn = (iop->_flag & _IONBF)? 0: fflush(iop);
|
||||
if(close(fileno(iop)) < 0) {
|
||||
rtn = EOF;
|
||||
errno = ENOENT;
|
||||
}
|
||||
}
|
||||
if(iop->_flag & _IOMYBUF) {
|
||||
free((char*)iop->_base);
|
||||
iop->_base = NULL;
|
||||
}
|
||||
iop->_flag = 0;
|
||||
iop->_cnt = 0;
|
||||
iop->_ptr = iop->_base;
|
||||
return(rtn);
|
||||
}
|
||||
|
||||
/*
|
||||
The fflush() routine must take care because of the
|
||||
possibility for recursion. The calling program might
|
||||
do IO in an interupt catching routine that is likely
|
||||
to interupt the write() call within fflush()
|
||||
*/
|
||||
|
||||
int
|
||||
fflush(iop)
|
||||
register FILE *iop;
|
||||
{
|
||||
if (!(iop->_flag & _IOWRT)) {
|
||||
iop->_cnt = 0;
|
||||
return(0);
|
||||
}
|
||||
while(!(iop->_flag & _IONBF) && (iop->_flag & _IOWRT) &&
|
||||
(iop->_base != NULL) && (iop->_ptr > iop->_base) )
|
||||
(void) _xflsbuf(iop);
|
||||
return(ferror(iop) ? EOF : 0);
|
||||
}
|
||||
|
||||
/* The routine _flsbuf may or may not actually flush the output buffer. If
|
||||
* the file is line-buffered, the fact that iop->_cnt has run below zero
|
||||
* is meaningless: it is always kept below zero so that invocations of putc
|
||||
* will consistently give control to _flsbuf, even if the buffer is far from
|
||||
* full. _flsbuf, on seeing the "line-buffered" flag, determines whether the
|
||||
* buffer is actually full by comparing iop->_ptr to the end-of-buffer pointer
|
||||
* _bufend(iop). If it is full, or if an output line is completed (with a
|
||||
* newline), the buffer is flushed. (Note: the character argument to _flsbuf
|
||||
* is not flushed with the current buffer if the buffer is actually full--
|
||||
* it goes into the buffer after flushing.)
|
||||
*/
|
||||
|
||||
int
|
||||
_flsbuf(c, iop)
|
||||
unsigned char c;
|
||||
register FILE *iop;
|
||||
{
|
||||
unsigned char c1;
|
||||
|
||||
do {
|
||||
if ( (iop->_flag & (_IOLBF | _IOWRT | _IOEOF)) == (_IOLBF | _IOWRT) ) {
|
||||
if ( iop->_ptr >= _bufend(iop) ) /* if buffer full, */
|
||||
break; /* exit do-while, and flush buf. */
|
||||
if ( (*iop->_ptr++ = c) != '\n' )
|
||||
return(c);
|
||||
return(_xflsbuf(iop) == EOF ? EOF : c);
|
||||
}
|
||||
if ( (iop->_flag & (_IONBF | _IOWRT | _IOEOF)) == (_IONBF | _IOWRT) ) {
|
||||
c1 = c;
|
||||
if (write(fileno(iop), (char *) &c1, 1) == 1)
|
||||
return(c);
|
||||
iop->_flag |= _IOERR;
|
||||
return(EOF);
|
||||
}
|
||||
/* The _wrtchk call is here rather than at the top of _flsbuf to re- */
|
||||
/* duce overhead for line-buffered I/O under normal circumstances. */
|
||||
|
||||
if (_WRTCHK(iop)) /* is writing legitimate? */
|
||||
return(EOF);
|
||||
} while ( (iop->_flag & (_IONBF | _IOLBF)) );
|
||||
|
||||
|
||||
(void) _xflsbuf(iop); /* full buffer: flush buffer */
|
||||
(void) putc((char) c, iop); /* then put "c" in newly emptied buf */
|
||||
/* (which, because of signals, may NOT be empty) */
|
||||
return( ferror(iop) ? EOF : c);
|
||||
}
|
||||
|
||||
/* The function _xflsbuf writes out the current contents of the output
|
||||
* buffer delimited by iop->_base and iop->_ptr.
|
||||
* iop->_cnt is reset appropriately, but its value on entry to _xflsbuf
|
||||
* is ignored.
|
||||
*
|
||||
* The following code is not strictly correct. If a signal is raised,
|
||||
* invoking a signal-handler which generates output into the same buffer
|
||||
* being flushed, a peculiar output sequence may result (for example,
|
||||
* the output generated by the signal-handler may appear twice). At
|
||||
* present no means has been found to guarantee correct behavior without
|
||||
* resorting to the disabling of signals, a means considered too expensive.
|
||||
* For now the code has been written with the intent of reducing the
|
||||
* probability of strange effects and, when they do occur, of confining
|
||||
* the damage. Except under extremely pathological circumstances, this
|
||||
* code should be expected to respect buffer boundaries even in the face
|
||||
* of interrupts and other signals.
|
||||
*/
|
||||
|
||||
int
|
||||
_xflsbuf(iop)
|
||||
register FILE *iop;
|
||||
{
|
||||
register unsigned char *base;
|
||||
register int n;
|
||||
|
||||
n = iop->_ptr - (base = iop->_base);
|
||||
iop->_ptr = base;
|
||||
iop->_cnt = (iop->_flag &(_IONBF | _IOLBF)) ? 0 : _bufsiz(iop);
|
||||
_BUFSYNC(iop);
|
||||
if (n > 0 && n != write(fileno(iop),(char*)base,(unsigned)n) ) {
|
||||
iop->_flag |= _IOERR;
|
||||
return(EOF);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* The function _wrtchk checks to see whether it is legitimate to write
|
||||
* to the specified device. If it is, _wrtchk sets flags in iop->_flag for
|
||||
* writing, assures presence of a buffer, and returns 0. If writing is not
|
||||
* legitimate, EOF is returned.
|
||||
*/
|
||||
|
||||
int
|
||||
_wrtchk(iop)
|
||||
register FILE *iop;
|
||||
{
|
||||
if ( (iop->_flag & (_IOWRT | _IOEOF)) != _IOWRT ) {
|
||||
if (!(iop->_flag & (_IOWRT | _IORW)))
|
||||
return(EOF); /* bogus call--read-only file */
|
||||
iop->_flag = iop->_flag & ~_IOEOF | _IOWRT; /* fix flags */
|
||||
}
|
||||
if (iop->_base == NULL) /* this is first I/O to file--get buffer */
|
||||
_findbuf(iop);
|
||||
if (iop->_ptr == iop->_base && !(iop->_flag & (_IONBF | _IOLBF)) ) {
|
||||
iop->_cnt = _bufsiz(iop); /* first write since seek--set cnt */
|
||||
_BUFSYNC(iop);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
/*
|
||||
* _findbuf, called only when iop->_base == NULL, locates a predefined buffer
|
||||
* or allocates a buffer using malloc. If a buffer is obtained from malloc,
|
||||
* the _IOMYBUF flag is set in iop->_flag.
|
||||
*/
|
||||
|
||||
_findbuf(iop)
|
||||
register FILE *iop;
|
||||
{
|
||||
register int fno = fileno(iop); /* file number */
|
||||
|
||||
if (fno < 2) /* use existing bufs for stdin, stdout */
|
||||
_bufend(iop) = (iop->_base = _stdbuf[fno]) + BUFSIZ;
|
||||
else
|
||||
if ((iop->_base = (unsigned char *) malloc(BUFSIZ+8)) != NULL) {
|
||||
iop->_flag |= _IOMYBUF;
|
||||
_bufend(iop) = iop->_base + BUFSIZ;
|
||||
}
|
||||
else
|
||||
_bufend(iop) = (iop->_base = _smbuf[fno]) + _SBFSIZ;
|
||||
|
||||
iop->_ptr = iop->_base;
|
||||
if ( isatty(fno) && !(iop->_flag & _IONBF) )
|
||||
iop->_flag |= _IOLBF;
|
||||
}
|
||||
|
||||
/* The function _bufsync is called because interrupts and other signals
|
||||
* which occur in between the decrementing of iop->_cnt and the incrementing
|
||||
* of iop->_ptr, or in other contexts as well, may upset the synchronization
|
||||
* of iop->_cnt and iop->ptr. If this happens, calling _bufsync should
|
||||
* resynchronize the two quantities (this is not always possible). Resyn-
|
||||
* chronization guarantees that putc invocations will not write beyond
|
||||
* the end of the buffer. Note that signals during _bufsync can cause
|
||||
* _bufsync to do the wrong thing, but usually with benign effects.
|
||||
*/
|
||||
|
||||
_bufsync(iop)
|
||||
register FILE *iop;
|
||||
{
|
||||
register int spaceleft;
|
||||
|
||||
if ((spaceleft = _bufend(iop) - iop->_ptr) < 0)
|
||||
iop->_ptr = _bufend(iop);
|
||||
else if (spaceleft < iop->_cnt)
|
||||
iop->_cnt = spaceleft;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include <stdio.h>
|
||||
|
||||
extern void free();
|
||||
extern int isatty();
|
||||
extern unsigned char _smbuf[][_SBFSIZ];
|
||||
extern unsigned char *_stdbuf[];
|
||||
|
||||
void
|
||||
setbuf(iop, buf)
|
||||
register FILE *iop;
|
||||
char *buf;
|
||||
{
|
||||
register int fno = fileno(iop); /* file number */
|
||||
|
||||
if(iop->_base != NULL && iop->_flag & _IOMYBUF)
|
||||
free((char*)iop->_base);
|
||||
iop->_flag &= ~(_IOMYBUF | _IONBF | _IOLBF);
|
||||
if((iop->_base = (unsigned char*)buf) == NULL) {
|
||||
iop->_flag |= _IONBF; /* file unbuffered except in fastio */
|
||||
if (fno < 2) /* for stdin, stdout, use the existing bufs */
|
||||
_bufend(iop) = (iop->_base = _stdbuf[fno]) + BUFSIZ;
|
||||
|
||||
else /* otherwise, use small buffers reserved for this */
|
||||
_bufend(iop) = (iop->_base = _smbuf[fno]) + _SBFSIZ;
|
||||
}
|
||||
else { /* regular buffered I/O, standard buffer size */
|
||||
_bufend(iop) = iop->_base + BUFSIZ;
|
||||
if (isatty(fno))
|
||||
iop->_flag |= _IOLBF;
|
||||
}
|
||||
iop->_ptr = iop->_base;
|
||||
iop->_cnt = 0;
|
||||
}
|
||||
Loading…
Reference in New Issue