#include "less.h"
#if MSDOS_COMPILER==WIN32C
#include <errno.h>
#include <windows.h>
#endif
public int ignore_eoi;
#define LBUFSIZE 1024
struct buf {
struct buf *next, *prev;
long block;
unsigned int datasize;
unsigned char data[LBUFSIZE];
};
struct filestate {
struct buf *buf_next, *buf_prev;
long buf_block;
int file;
int flags;
POSITION fpos;
int nbufs;
long block;
unsigned int offset;
POSITION fsize;
};
#define END_OF_CHAIN ((struct buf *)thisfile)
#define ch_bufhead thisfile->buf_next
#define ch_buftail thisfile->buf_prev
#define ch_nbufs thisfile->nbufs
#define ch_block thisfile->block
#define ch_offset thisfile->offset
#define ch_fpos thisfile->fpos
#define ch_fsize thisfile->fsize
#define ch_flags thisfile->flags
#define ch_file thisfile->file
static struct filestate *thisfile;
static int ch_ungotchar = -1;
extern int autobuf;
extern int sigs;
extern int cbufs;
extern int secure;
extern constant char helpdata[];
extern constant int size_helpdata;
extern IFILE curr_ifile;
#if LOGFILE
extern int logfile;
extern char *namelogfile;
#endif
static int ch_addbuf();
#define ch_get() ((ch_block == ch_bufhead->block && \
ch_offset < ch_bufhead->datasize) ? \
ch_bufhead->data[ch_offset] : fch_get())
int
fch_get()
{
register struct buf *bp;
register int n;
register int slept;
POSITION pos;
POSITION len;
slept = FALSE;
for (bp = ch_bufhead; bp != END_OF_CHAIN; bp = bp->next)
if (bp->block == ch_block)
{
if (ch_offset >= bp->datasize)
goto read_more;
goto found;
}
if (ch_buftail == END_OF_CHAIN || ch_buftail->block != (long)(-1))
{
if ((autobuf && !(ch_flags & CH_CANSEEK)) ||
(cbufs == -1 || ch_nbufs < cbufs))
if (ch_addbuf())
autobuf = OPT_OFF;
}
bp = ch_buftail;
bp->block = ch_block;
bp->datasize = 0;
read_more:
pos = (ch_block * LBUFSIZE) + bp->datasize;
if ((len = ch_length()) != NULL_POSITION && pos >= len)
return (EOI);
if (pos != ch_fpos)
{
if (!(ch_flags & CH_CANSEEK))
return ('?');
if (lseek(ch_file, (off_t)pos, 0) == BAD_LSEEK)
{
error("seek error", NULL_PARG);
clear_eol();
return (EOI);
}
ch_fpos = pos;
}
if (ch_ungotchar != -1)
{
bp->data[bp->datasize] = ch_ungotchar;
n = 1;
ch_ungotchar = -1;
} else if (ch_flags & CH_HELPFILE)
{
bp->data[bp->datasize] = helpdata[ch_fpos];
n = 1;
} else
{
n = iread(ch_file, &bp->data[bp->datasize],
(unsigned int)(LBUFSIZE - bp->datasize));
}
if (n == READ_INTR)
return (EOI);
if (n < 0)
{
#if MSDOS_COMPILER==WIN32C
if (errno != EPIPE)
#endif
{
error("read error", NULL_PARG);
clear_eol();
}
n = 0;
}
#if LOGFILE
if (!secure && logfile >= 0 && n > 0)
write(logfile, (char *) &bp->data[bp->datasize], n);
#endif
ch_fpos += n;
bp->datasize += n;
if (n == 0)
{
ch_fsize = pos;
if (ignore_eoi)
{
if (!slept)
ierror("Waiting for data", NULL_PARG);
#if !MSDOS_COMPILER
sleep(1);
#else
#if MSDOS_COMPILER==WIN32C
Sleep(1000);
#endif
#endif
slept = TRUE;
}
if (sigs)
return (EOI);
}
found:
if (ch_bufhead != bp)
{
bp->next->prev = bp->prev;
bp->prev->next = bp->next;
bp->next = ch_bufhead;
bp->prev = END_OF_CHAIN;
ch_bufhead->prev = bp;
ch_bufhead = bp;
}
if (ch_offset >= bp->datasize)
goto read_more;
return (bp->data[ch_offset]);
}
public void
ch_ungetchar(c)
int c;
{
if (c != -1 && ch_ungotchar != -1)
error("ch_ungetchar overrun", NULL_PARG);
ch_ungotchar = c;
}
#if LOGFILE
public void
end_logfile()
{
static int tried = FALSE;
if (logfile < 0)
return;
if (!tried && ch_fsize == NULL_POSITION)
{
tried = TRUE;
ierror("Finishing logfile", NULL_PARG);
while (ch_forw_get() != EOI)
if (ABORT_SIGS())
break;
}
close(logfile);
logfile = -1;
namelogfile = NULL;
}
public void
sync_logfile()
{
register struct buf *bp;
int warned = FALSE;
long block;
long nblocks;
nblocks = (ch_fpos + LBUFSIZE - 1) / LBUFSIZE;
for (block = 0; block < nblocks; block++)
{
for (bp = ch_bufhead; ; bp = bp->next)
{
if (bp == END_OF_CHAIN)
{
if (!warned)
{
error("Warning: log file is incomplete",
NULL_PARG);
warned = TRUE;
}
break;
}
if (bp->block == block)
{
write(logfile, (char *) bp->data, bp->datasize);
break;
}
}
}
}
#endif
static int
buffered(block)
long block;
{
register struct buf *bp;
for (bp = ch_bufhead; bp != END_OF_CHAIN; bp = bp->next)
if (bp->block == block)
return (TRUE);
return (FALSE);
}
public int
ch_seek(pos)
register POSITION pos;
{
long new_block;
POSITION len;
len = ch_length();
if (pos < ch_zero() || (len != NULL_POSITION && pos > len))
return (1);
new_block = pos / LBUFSIZE;
if (!(ch_flags & CH_CANSEEK) && pos != ch_fpos && !buffered(new_block))
{
if (ch_fpos > pos)
return (1);
while (ch_fpos < pos)
{
if (ch_forw_get() == EOI)
return (1);
if (ABORT_SIGS())
return (1);
}
return (0);
}
ch_block = new_block;
ch_offset = pos % LBUFSIZE;
return (0);
}
public int
ch_end_seek()
{
POSITION len;
if (ch_flags & CH_CANSEEK)
ch_fsize = filesize(ch_file);
len = ch_length();
if (len != NULL_POSITION)
return (ch_seek(len));
while (ch_forw_get() != EOI)
if (ABORT_SIGS())
return (1);
return (0);
}
public int
ch_beg_seek()
{
register struct buf *bp, *firstbp;
if (ch_seek(ch_zero()) == 0)
return (0);
firstbp = bp = ch_bufhead;
if (bp == END_OF_CHAIN)
return (1);
while ((bp = bp->next) != END_OF_CHAIN)
if (bp->block < firstbp->block)
firstbp = bp;
ch_block = firstbp->block;
ch_offset = 0;
return (0);
}
public POSITION
ch_length()
{
if (ignore_eoi)
return (NULL_POSITION);
if (ch_flags & CH_HELPFILE)
return (size_helpdata);
return (ch_fsize);
}
#define tellpos(blk,off) ((POSITION)((((long)(blk)) * LBUFSIZE) + (off)))
public POSITION
ch_tell()
{
return (tellpos(ch_block, ch_offset));
}
public int
ch_forw_get()
{
register int c;
c = ch_get();
if (c == EOI)
return (EOI);
if (ch_offset < LBUFSIZE-1)
ch_offset++;
else
{
ch_block ++;
ch_offset = 0;
}
return (c);
}
public int
ch_back_get()
{
if (ch_offset > 0)
ch_offset --;
else
{
if (ch_block <= 0)
return (EOI);
if (!(ch_flags & CH_CANSEEK) && !buffered(ch_block-1))
return (EOI);
ch_block--;
ch_offset = LBUFSIZE-1;
}
return (ch_get());
}
public int
ch_nbuf(want_nbufs)
int want_nbufs;
{
PARG parg;
while (ch_nbufs < want_nbufs)
{
if (ch_addbuf())
{
parg.p_int = want_nbufs - ch_nbufs;
error("Cannot allocate %d buffers", &parg);
if (ch_nbufs == 0)
quit(QUIT_ERROR);
break;
}
}
return (ch_nbufs);
}
public void
ch_flush()
{
register struct buf *bp;
if (!(ch_flags & CH_CANSEEK))
{
ch_fsize = NULL_POSITION;
return;
}
for (bp = ch_bufhead; bp != END_OF_CHAIN; bp = bp->next)
bp->block = (long)(-1);
ch_fsize = filesize(ch_file);
ch_fpos = 0;
ch_block = 0;
ch_offset = 0;
#if 1
if (ch_fsize == 0)
{
ch_fsize = NULL_POSITION;
ch_flags &= ~CH_CANSEEK;
}
#endif
if (lseek(ch_file, (off_t)0, 0) == BAD_LSEEK)
{
error("seek error to 0", NULL_PARG);
}
}
static int
ch_addbuf()
{
register struct buf *bp;
bp = (struct buf *) calloc(1, sizeof(struct buf));
if (bp == NULL)
return (1);
ch_nbufs++;
bp->block = (long)(-1);
bp->next = END_OF_CHAIN;
bp->prev = ch_buftail;
ch_buftail->next = bp;
ch_buftail = bp;
return (0);
}
static void
ch_delbufs()
{
register struct buf *bp;
while (ch_bufhead != END_OF_CHAIN)
{
bp = ch_bufhead;
bp->next->prev = bp->prev;;
bp->prev->next = bp->next;
free(bp);
}
ch_nbufs = 0;
}
public int
seekable(f)
int f;
{
#if MSDOS_COMPILER
extern int fd0;
if (f == fd0 && !isatty(fd0))
{
return (0);
}
#endif
return (lseek(f, (off_t)1, 0) != BAD_LSEEK);
}
public void
ch_init(f, flags)
int f;
int flags;
{
thisfile = (struct filestate *) get_filestate(curr_ifile);
if (thisfile == NULL)
{
thisfile = (struct filestate *)
calloc(1, sizeof(struct filestate));
thisfile->buf_next = thisfile->buf_prev = END_OF_CHAIN;
thisfile->buf_block = (long)(-1);
thisfile->nbufs = 0;
thisfile->flags = 0;
thisfile->fpos = 0;
thisfile->block = 0;
thisfile->offset = 0;
thisfile->file = -1;
thisfile->fsize = NULL_POSITION;
ch_flags = flags;
if ((flags & CH_CANSEEK) && !seekable(f))
ch_flags &= ~CH_CANSEEK;
set_filestate(curr_ifile, (void *) thisfile);
}
if (thisfile->file == -1)
thisfile->file = f;
ch_flush();
}
public void
ch_close()
{
int keepstate = FALSE;
if (ch_flags & (CH_CANSEEK|CH_POPENED|CH_HELPFILE))
{
ch_delbufs();
} else
keepstate = TRUE;
if (!(ch_flags & CH_KEEPOPEN))
{
if (!(ch_flags & (CH_POPENED|CH_HELPFILE)))
close(ch_file);
ch_file = -1;
} else
keepstate = TRUE;
if (!keepstate)
{
free(thisfile);
thisfile = NULL;
set_filestate(curr_ifile, (void *) NULL);
}
}
public int
ch_getflags()
{
return (ch_flags);
}
#if 0
public void
ch_dump(struct filestate *fs)
{
struct buf *bp;
unsigned char *s;
if (fs == NULL)
{
printf(" --no filestate\n");
return;
}
printf(" file %d, flags %x, fpos %x, fsize %x, blk/off %x/%x\n",
fs->file, fs->flags, fs->fpos,
fs->fsize, fs->block, fs->offset);
printf(" %d bufs:\n", fs->nbufs);
for (bp = fs->buf_next; bp != (struct buf *)fs; bp = bp->next)
{
printf("%x: blk %x, size %x \"",
bp, bp->block, bp->datasize);
for (s = bp->data; s < bp->data + 30; s++)
if (*s >= ' ' && *s < 0x7F)
printf("%c", *s);
else
printf(".");
printf("\"\n");
}
}
#endif