char *get_word(register FILE *fp, register char *word)
{
register int ch, i = 0;
while ((ch = (--(fp)->_cnt>=0? ((int)*(fp)->_ptr++):_filbuf(fp))) != (-1) && ((_ctype_+1)[ch]&010))
;
word[i++] = ch;
while ((ch = (--(fp)->_cnt>=0? ((int)*(fp)->_ptr++):_filbuf(fp))) != (-1) && ! ((_ctype_+1)[ch]&010))
word[i++] = ch;
word[i++] = '\0';
return word;
}
size_t fread(void *vptr, size_t size, size_t count, FILE *iop)
{
char *ptr = (char *)vptr;
int s;
int c;
// __libclog_printf("fread(%x,%u,%u,%x)\n",vptr,size,count,iop);
s = size * count;
while (s > 0) {
if (iop->_cnt < s) {
if (iop->_cnt > 0) {
memcpy(ptr, iop->_ptr, iop->_cnt);
ptr += iop->_cnt;
s -= iop->_cnt;
}
/*
* filbuf clobbers _cnt & _ptr,
* so don't waste time setting them.
*/
if ((c = _filbuf(iop)) == EOF)
break;
*ptr++ = c;
s--;
}
if (iop->_cnt >= s) {
memcpy(ptr, iop->_ptr, s);
iop->_ptr += s;
iop->_cnt -= s;
return count;
}
}
return size != 0 ? count - ((s + size - 1) / size) : 0;
}
void read_cube(register FILE *fp, pPLA PLA)
{
register int var, i;
pset cf = cube.temp[0], cr = cube.temp[1], cd = cube.temp[2];
int savef = 0, saved = 0, saver = 0;
char token[256]; int varx, first, last, offset; set_clear(cf, cube.size);
for(var = 0; var < cube.num_binary_vars; var++)
switch((--(fp)->_cnt>=0? ((int)*(fp)->_ptr++):_filbuf(fp))) {
case (-1):
goto bad_char;
case '\n':
if (! line_length_error)
fprintf((&_iob[2]), "product term(s) %s\n",
"span more than one line (warning only)");
line_length_error = 1;
lineno++;
var--;
break;
case ' ': case '|': case '\t':
var--;
break;
case '2': case '-':
(cf[((( var*2+1) >> 5) + 1)] |= 1 << (( var*2+1) & (32-1)));
case '0':
(cf[((( var*2) >> 5) + 1)] |= 1 << (( var*2) & (32-1)));
break;
case '1':
(cf[((( var*2+1) >> 5) + 1)] |= 1 << (( var*2+1) & (32-1)));
break;
case '?':
break;
default:
goto bad_char;
}
for(var = cube.num_binary_vars; var < cube.num_vars-1; var++)
if (cube.part_size[var] < 0) {
(void) fscanf(fp, "%s", token);
if ((strcmp(token, "-") == 0) || (strcmp(token, "ANY") == 0)) {
if (kiss && var == cube.num_vars - 2) {
} else {
set_or(cf, cf, cube.var_mask[var]);
}
} else if ((strcmp(token, "~") == 0)) {
;
} else {
if (kiss && var == cube.num_vars - 2)
varx = var - 1, offset = ((cube.part_size[var-1]) < 0 ? -(cube.part_size[var-1]) : (cube.part_size[var-1]));
else
varx = var, offset = 0;
first = cube.first_part[varx];
last = cube.last_part[varx];
for(i = first; i <= last; i++)
if (PLA->label[i] == (char *) 0) {
PLA->label[i] = util_strsav(token); (cf[((( i+offset) >> 5) + 1)] |= 1 << (( i+offset) & (32-1)));
break;
} else if ((strcmp(PLA->label[i], token) == 0)) {
void skip_line(register FILE *fpin, register FILE *fpout, register int echo)
{
register int ch;
while ((ch=(--(fpin)->_cnt>=0? ((int)*(fpin)->_ptr++):_filbuf(fpin))) != (-1) && ch != '\n')
if (echo)
(--( fpout)->_cnt >= 0 ? (int)(*( fpout)->_ptr++ = (unsigned char)(ch)) : ((( fpout)->_flag & 0200) && -( fpout)->_cnt < ( fpout)->_bufsiz ? ((*( fpout)->_ptr = (unsigned char)(ch)) != '\n' ? (int)(*( fpout)->_ptr++) : _flsbuf(*(unsigned char *)( fpout)->_ptr, fpout)) : _flsbuf((unsigned char)(ch), fpout)));
if (echo)
(--( fpout)->_cnt >= 0 ? (int)(*( fpout)->_ptr++ = (unsigned char)('\n')) : ((( fpout)->_flag & 0200) && -( fpout)->_cnt < ( fpout)->_bufsiz ? ((*( fpout)->_ptr = (unsigned char)('\n')) != '\n' ? (int)(*( fpout)->_ptr++) : _flsbuf(*(unsigned char *)( fpout)->_ptr, fpout)) : _flsbuf((unsigned char)('\n'), fpout)));
lineno++;
}
extern __inline__ int __attribute__((__cdecl__)) __attribute__ ((__nothrow__)) getchar (void)
{
return (--(&_iob[0])->_cnt >= 0)
? (int) (unsigned char) *(&_iob[0])->_ptr++
: _filbuf ((&_iob[0]));
}
extern __inline__ int __attribute__((__cdecl__)) __attribute__ ((__nothrow__)) getc (FILE* __F)
{
return (--__F->_cnt >= 0)
? (int) (unsigned char) *__F->_ptr++
: _filbuf (__F);
}
int
__filbuf(FILE *iop)
{
return (_filbuf(iop));
}
size_t
fread(void *vptr, size_t size, size_t count, FILE *iop)
{
char *ptr = (char *)vptr;
int s;
int c;
/* grow if we know we're asking for a lot, even if it's in the
buffer, since we'll probably read chunks this size for a while */
while (size*count > iop->_fillsize
&& iop->_fillsize < iop->_bufsiz)
{
if (iop->_fillsize < 512)
iop->_fillsize = 512;
iop->_fillsize *= 2;
}
#if 0
if (__libc_read_termios_hook
&& (iop->_flag & (_IOTERM | _IONTERM)) == 0)
{
/* first time we see this handle--see if termios hooked it */
/* xxx - need to replace isatty somehow */
if (isatty(iop->_file))
iop->_flag |= _IOTERM;
else
iop->_flag |= _IONTERM;
}
#endif
s = size * count;
/*if(!__is_text_file(iop))*/
{
while (s > 0) {
if (iop->_cnt < s) {
if (iop->_cnt > 0) {
memcpy(ptr, iop->_ptr, iop->_cnt);
ptr += iop->_cnt;
s -= iop->_cnt;
}
/*
* filbuf clobbers _cnt & _ptr,
* so don't waste time setting them.
*/
if ((c = _filbuf(iop)) == EOF)
break;
*ptr++ = c;
s--;
}
if (iop->_cnt >= s) {
memcpy(ptr, iop->_ptr, s);
iop->_ptr += s;
iop->_cnt -= s;
return count;
}
}
}
#if 0
else
{
while (s > 0) {
long
_frch(
unit *cup,
long *uda,
long chars,
int mode,
long *status)
{
register int bytsiz;
register int chr;
register long nchr;
register long ncnt;
unsigned char tbuf[TBUFSZB], *tp; /* Line buffer */
FILE *fptr;
struct ffsw stat;
struct fdinfo *fio;
#if defined(_SOLARIS) || (defined(_LITTLE_ENDIAN) && !defined(__sv2))
register long count;
char *tpinterim;
#endif
switch (cup->ufs) {
case FS_TEXT:
case STD:
fptr = cup->ufp.std;
/*
* Switch the FILE structure into read mode
*/
#if !defined(_LITTLE_ENDIAN) || (defined(_LITTLE_ENDIAN) && defined(__sv2))
if ((FILE_FLAG(fptr) & (_IOREAD | _IORW)) == _IORW) {
if (FILE_FLAG(fptr) & _IOWRT)
(void) fseek(fptr, 0, SEEK_CUR);
FILE_FLAG(fptr) |= _IOREAD;
}
#endif
/*
* Loop on getc until the character count has been
* exhausted, an end of file is encountered, or end
* of record.
*/
nchr = 0;
#if defined(_SOLARIS) || (defined(_LITTLE_ENDIAN) && !defined(__sv2))
while (nchr < chars) {
fill:
errno = 0;
count = chars - nchr;
tp = tbuf;
count = MIN(TBUFSZB, (count + 1));
tpinterim = fgets((char *)tp, count, fptr);
if (tpinterim == NULL) {
/*
* Search for the newline char in the buffer, but
* search only the number of characters left in
* the request, plus one in case it is the
* newline (if it is in the buffer). If we find
* newline, we're done.
*/
/* EOF here means incomplete record. */
if (ferror(fptr)) {
if ( errno == EINTR && _GINTIO == 0) {
clearerr(fptr);
goto fill;
}
if (errno == 0)
errno = FESTIOER;
return(IOERR);
}
/*
* If nchr > zero, file has no newline.
* Make sure we handle it properly.
*/
if (feof(fptr)) {
if (nchr == 0) {
*status = EOD;
return(0);
}
*status = CNT;
return(nchr);
}
} else {
unsigned char *tmpptr;
ncnt = count - 1;
#ifdef KEY /* Bug 3797 */
/* no newline if fgets encountered eof */
tmpptr = strchr(tp, '\n');
#ifdef KEY /* Bug 3975 */
char *nlptr = memchr(tp, '\n', ncnt);
/* Temporary fix to deal with the situation
* in which nulls appear before the newline.
* Correct fix is to eliminate those nulls.
*/
if (NULL == tmpptr && NULL != nlptr) {
tmpptr = nlptr;
}
#endif /* KEY Bug 3975 */
#else
tmpptr = memchr(tp, '\n', ncnt);
#endif /* KEY Bug 3797 */
if (tmpptr != NULL) { /* eor */
*status = EOR;
ncnt = tmpptr - tp;
nchr += ncnt;
_unpack(tp, uda, ncnt, -1);
/* Return number of chars read */
return(nchr);
}
#ifdef KEY /* Bug 3797 */
/* fgets got chars ending in eof, not newline */
else if (feof(fptr)) {
*status = EOR;
ncnt = strlen(tp);
nchr += ncnt;
_unpack(tp, uda, ncnt, -1);
return nchr;
}
#endif /* KEY Bug 3797 */
_unpack(tp, uda, ncnt, -1);
nchr += ncnt;
uda += ncnt;
/* go refill the buffer */
}
}
#else
while (nchr < chars) {
if (FILE_CNT(fptr) <= 0) {
fill:
errno = 0;
chr = _filbuf(fptr);
/* EOF here means incomplete record. */
if (chr == EOF) {
if (ferror(fptr)) {
if ( errno == EINTR &&
_GINTIO == 0 ) {
clearerr(fptr);
goto fill;
}
if (errno == 0)
errno = FESTIOER;
return(IOERR);
}
/*
* If nchr > zero, file has no newline.
* Make sure we handle it properly.
*/
if (nchr == 0) {
*status = EOD;
return(0);
}
*status = CNT;
return(nchr);
}
/*
* Put character returned by filbuf() back
*/
FILE_CNT(fptr)++;
FILE_PTR(fptr)--;
}
/*
* Search for a newline char in the buffer, but search
* only the number of characters left in the request,
* plus one in case it is the newline (if it is in
* the buffer). If we find the newline, we're done.
*/
if ((chars - nchr) < FILE_CNT(fptr)) {
ncnt = chars - nchr;
tp = memchr(FILE_PTR(fptr), '\n', ncnt + 1);
}
else {
ncnt = FILE_CNT(fptr); /* assume no EOR yet */
tp = memchr(FILE_PTR(fptr), '\n', ncnt);
}
if (tp != NULL) { /* Found end of record */
*status = EOR;
ncnt = tp - FILE_PTR(fptr);
nchr += ncnt;
_unpack((char *)FILE_PTR(fptr), uda, ncnt, -1);
FILE_CNT(fptr) -= ncnt + 1;
FILE_PTR(fptr) += ncnt + 1;
return(nchr); /* Return number of characters read */
}
_unpack((char *)FILE_PTR(fptr), uda, ncnt, -1);
FILE_CNT(fptr) -= ncnt;
FILE_PTR(fptr) += ncnt;
nchr += ncnt;
uda += ncnt;
/* go refill the buffer */
}
#endif
/*
* Get the next character to see if at end of record.
* Set the user's status word accordingly.
*/
chr = getc(fptr);
*status = CNT;
if (chr == '\n' ) {
*status = EOR;
return(nchr); /* Return number of characters read */
}
/*
* We are not at end of record. Thus if reading in full
* record mode skip until EOR is found. If reading in
* partial record mode, unget the last character read.
*/
if (mode == FULL)
#if defined(_SOLARIS) || (defined(_LITTLE_ENDIAN) && !defined(__sv2))
{
fill2:
count = TBUFSZB;
tp = tbuf;
tpinterim = fgets((char *)tp, count, fptr);
if (tpinterim == NULL) {
/* EOF means incomplete record. */
if (ferror(fptr)) {
if ( errno == EINTR && _GINTIO == 0 ) {
clearerr(fptr);
goto fill2;
}
}
/* Return number of chars read. */
return(nchr);
} else {
unsigned char *tmpptr;
ncnt = count - 1;
tmpptr = memchr(tp, '\n', ncnt);
if (tmpptr != NULL) { /* Found eor */
/* Return number of chars read */
return(nchr);
} else
goto fill2;
}
}
#else
while (1) {
if (FILE_CNT(fptr) <= 0) {
fill2:
chr = _filbuf(fptr);
/* EOF here means incomplete record. */
if (chr == EOF) {
if (ferror(fptr)) {
if ( errno == EINTR &&
_GINTIO == 0 ) {
clearerr(fptr);
goto fill2;
}
}
/* Return number of characters read */
return(nchr);
}
FILE_CNT(fptr)++;
FILE_PTR(fptr)--;
}
tp = memchr(FILE_PTR(fptr), '\n', FILE_CNT(fptr));
if (tp != NULL) {
tp++;
FILE_CNT(fptr) -= tp - FILE_PTR(fptr);
FILE_PTR(fptr) = tp;
return(nchr);
}
else
FILE_CNT(fptr) = 0;
}
#endif
else {
ungetc ((char) chr, fptr);
}
return(nchr); /* return number of character read */
case FS_FDC:
nchr = 0;
fio = cup->ufp.fdc;
/*
* If no conversion is to be done, or no characters requested
* (usually for null request, FULL mode), make it simple and direct.
*/
if (cup->ucharset == 0 || chars == 0) {
register long breq;
register int ffstat;
register int ret;
/*
* If file is direct access, we know that all reads are
* going to be whole records in FULL mode. We also
* know that the open code would not let us get this far
* if we were not dealing with a stream layer.
*/
breq = chars;
ret = XRCALL(fio, readcrtn) fio, CPTR2BP(uda),
breq, &stat, mode);
if (ret < 0) {
errno = stat.sw_error;
return(IOERR);
}
ffstat = FFSTAT(stat);
if (!cup->useq && !cup->ublkd && ffstat == FFCNT)
ffstat = FFEOR;
*status = FF2FTNST(ffstat);
nchr = ret;
return(nchr); /* Return number of characters read */
}
/*
* Get proper byte size (might not be 8-bits if doing conversion).
*/
#if NUMERIC_DATA_CONVERSION_ENABLED
bytsiz = __fndc_charsz[cup->ucharset];
#else
bytsiz = 8;
#endif
FFSTAT(cup->uffsw) = FFCNT;
*status = CNT;
while (nchr < chars && FFSTAT(cup->uffsw) != FFEOR) {
register long bgot;
register long breq;
register long padc;
register int ret;
register long totbits;
int ubc;
/*
* Calculate the number of bits that need to be taken
* from the foreign data stream.
*
* ncnt = number of resultant bytes
*/
ncnt = chars - nchr;
if (ncnt > TBUFSZB)
ncnt = TBUFSZB;
totbits = bytsiz * ncnt; /* bit count */
breq = (totbits + 7) >> 3; /* full 8-bit bytes */
ubc = (breq << 3) - totbits;/* unused bits */
ret = XRCALL(fio, readrtn) fio, CPTR2BP(tbuf),
breq, &cup->uffsw, PARTIAL, &ubc);
if (ret < 0) { /* if an error */
errno = cup->uffsw.sw_error;
return(IOERR);
}
/* if end of file */
if (ret == 0) {
if (nchr == 0)
*status = FF2FTNST(FFSTAT(stat));
return(nchr); /* Return number of characters read */
}
/*
* how many bits did we get? Convert back to foreign
* character count.
*/
totbits = (ret << 3) - ubc;
bgot = totbits / bytsiz; /* foreign bytes */
ubc = totbits - (bgot * bytsiz);
if (ubc != 0) {
errno = FEINTUNK;
return(IOERR);
}
padc = 0;
if (FFSTAT(cup->uffsw) == FFEOR) {
padc = chars - (bgot + nchr);
*status = EOR;
}
if (_fdc_unpackc(tbuf, &uda[nchr], bgot, padc,
cup->ucharset) < 0) {
return(IOERR);
}
nchr += bgot;
}
/* check for null request, non-EOR */
if (FFSTAT(cup->uffsw) == FFCNT && mode == FULL) {
register int ret;
int ubc;
ret = XRCALL(fio, readrtn) fio, CPTR2BP(tbuf), 0,
&cup->uffsw, FULL, &ubc);
if (ret < 0) { /* if an error */
errno = cup->uffsw.sw_error;
return(IOERR);
}
}
return(nchr);
case FS_AUX:
errno = FEMIXAUX;
return(IOERR);
default:
errno = FEINTFST;
return(IOERR);
}
