/* External procedures for tangle/weave */
/* Written by: H. Trickey, 11/17/83 */
/* Modified for 8-bit input by don, 8/31/89 */
/* Note: these procedures aren't necessary; the default input_ln and
* flush_buffer routines in tangle/weave work fine on UNIX.
* However a very big time improvement is achieved by using these.
*/
#define BUF_SIZE 100 /* should agree with tangle.web */
extern short buffer[]; /* 0..BUF_SIZE. Input goes here */
extern short outbuf[]; /* 0..OUT_BUF_SIZE. Output from here */
extern short xord[];
extern char xchr[]; /* character translation arrays */
extern char limit; /* index into buffer, defined in the range
0..BUF_SIZE (and note that this is a
char rather than a short because BUF_SIZE
is 100) */
/*
* lineread reads from the Pascal text file with iorec pointer filep
* into buffer[0], buffer[1],..., buffer[limit-1] (and
* setting "limit").
* Characters are read until a newline is found (which isn't put in the
* buffer) or until the next character would go into buffer[BUF_SIZE].
* And trailing blanks are to be ignored, so limit is really set to
* one past the last non-blank.
* The characters need to be translated, so really xord[c] is put into
* the buffer when c is read.
* If end-of-file is encountered, the funit field of *filep is set
* appropriately.
*/
lineread(filep)
struct iorec *filep;
{
register int c;
register short *cs; /* pointer into buffer where next char goes */
register short *cnb; /* last non-blank character input */
register FILE *iop; /* stdio-style FILE pointer */
register int l; /* how many chars before buffer overflow */
/* overflow when next char would go into buffer[BUF_SIZE] */
while ((--l >= 0) && ((c = getc(iop)) != EOF) && (c != '\n')) {
if ((*cs++ = xord[c]) != ' ')
cnb = cs;
}
if (c == EOF)
filep->funit |= EOFF; /* we hit end-of-file */
limit = (cnb - &buffer[0]);
}
/*
* linewrite writes to the Pascal text file with iorec pointer filep
* from outbuf[0], outbuf[1],..., outbuf[cnt-1].
* Translation is done, so that xchr[c] is output instead of c.
*/
linewrite(filep, cnt)
struct iorec *filep;
int cnt;
{
register FILE *iop; /* stdio-style FILE pointer */
register short *cs; /* pointer to next character to output */
register int l; /* how many characters left to output */
iop = filep->fbuf;
cs = &outbuf[0];
l = cnt;
while (--l >= 0)
putc(xchr[*cs++], iop);
}
/*
* testeof(filep)
*
* Test whether or not the Pascal text file with iorec pointer filep
* has reached end-of-file (when the only I/O on it is done with
* lineread, above).
* We may have to read the next character and unget it to see if perhaps
* the end-of-file is next.
*/
bool
testeof(filep)
register struct iorec *filep;
{
register char c;
register FILE *iop; /* stdio-style FILE pointer */
if (filep->funit & EOFF)
return(TRUE);
else { /* check to see if next is EOF */
iop = filep->fbuf;
c = getc(iop);
if (c == EOF)
return(TRUE);
else {
ungetc(c,iop);
return(FALSE);
}
}
}
