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); }