/*

 * Copyright (C) 1984-2012  Mark Nudelman

 * Modified for use with illumos by Garrett D'Amore.

 * Copyright 2014 Garrett D'Amore <garrett@damore.org>

 *

 * You may distribute under the terms of either the GNU General Public

 * License or the Less License, as specified in the README file.

 *

 * For more information, see the README file.

 */

/*

 * Low level character input from the input file.

 * We use these special purpose routines which optimize moving

 * both forward and backward from the current read pointer.

 */

#include <sys/stat.h>

#include "less.h"

extern dev_t curr_dev;

extern ino_t curr_ino;

extern int less_is_more;

typedef off_t BLOCKNUM;

int ignore_eoi;

/*

 * Pool of buffers holding the most recently used blocks of the input file.

 * The buffer pool is kept as a doubly-linked circular list,

 * in order from most- to least-recently used.

 * The circular list is anchored by the file state "thisfile".

 */

struct bufnode {

	struct bufnode *next, *prev;

	struct bufnode *hnext, *hprev;

};

#define	LBUFSIZE	8192

struct buf {

	struct bufnode node;

	BLOCKNUM block;

	unsigned int datasize;

	unsigned char data[LBUFSIZE];

};

#define	bufnode_buf(bn)  ((struct buf *)bn)

/*

 * The file state is maintained in a filestate structure.

 * A pointer to the filestate is kept in the ifile structure.

 */

#define	BUFHASH_SIZE	64

struct filestate {

	struct bufnode buflist;

	struct bufnode hashtbl[BUFHASH_SIZE];

	int file;

	int flags;

	off_t fpos;

	int nbufs;

	BLOCKNUM block;

	unsigned int offset;

	off_t fsize;

};

#define	ch_bufhead	thisfile->buflist.next

#define	ch_buftail	thisfile->buflist.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

#define	END_OF_CHAIN	(&thisfile->buflist)

#define	END_OF_HCHAIN(h) (&thisfile->hashtbl[h])

#define	BUFHASH(blk)	((blk) & (BUFHASH_SIZE-1))

/*

 * Macros to manipulate the list of buffers in thisfile->buflist.

 */

#define	FOR_BUFS(bn) \

	for ((bn) = ch_bufhead; (bn) != END_OF_CHAIN; (bn) = (bn)->next)

#define	BUF_RM(bn) \

	(bn)->next->prev = (bn)->prev; \

	(bn)->prev->next = (bn)->next;

#define	BUF_INS_HEAD(bn) \

	(bn)->next = ch_bufhead; \

	(bn)->prev = END_OF_CHAIN; \

	ch_bufhead->prev = (bn); \

	ch_bufhead = (bn);

#define	BUF_INS_TAIL(bn) \

	(bn)->next = END_OF_CHAIN; \

	(bn)->prev = ch_buftail; \

	ch_buftail->next = (bn); \

	ch_buftail = (bn);

/*

 * Macros to manipulate the list of buffers in thisfile->hashtbl[n].

 */

#define	FOR_BUFS_IN_CHAIN(h, bn) \

	for ((bn) = thisfile->hashtbl[h].hnext; \

	    (bn) != END_OF_HCHAIN(h); (bn) = (bn)->hnext)

#define	BUF_HASH_RM(bn) \

	(bn)->hnext->hprev = (bn)->hprev; \

	(bn)->hprev->hnext = (bn)->hnext;

#define	BUF_HASH_INS(bn, h) \

	(bn)->hnext = thisfile->hashtbl[h].hnext; \

	(bn)->hprev = END_OF_HCHAIN(h); \

	thisfile->hashtbl[h].hnext->hprev = (bn); \

	thisfile->hashtbl[h].hnext = (bn);

static struct filestate *thisfile;

static int ch_ungotchar = -1;

static int maxbufs = -1;

extern int autobuf;

extern volatile sig_atomic_t sigs;

extern int secure;

extern int screen_trashed;

extern int follow_mode;

extern IFILE curr_ifile;

extern int logfile;

extern char *namelogfile;

static int ch_addbuf(void);

/*

 * Get the character pointed to by the read pointer.

 */

int

ch_get(void)

{

	struct buf *bp;

	struct bufnode *bn;

	int n;

	int slept;

	int h;

	off_t pos;

	off_t len;

	/*

	 * Quick check for the common case where

	 * the desired char is in the head buffer.

	 */

	}

	slept = FALSE;

	/*

	 * Look for a buffer holding the desired block.

	 */

				/*

				 * Need more data in this buffer.

				 */

				break;

			goto found;

		}

	}

		/*

		 * Block is not in a buffer.

		 * Take the least recently used buffer

		 * and read the desired block into it.

		 * If the LRU buffer has data in it,

		 * then maybe allocate a new buffer.

		 */

			/*

			 * There is no empty buffer to use.

			 * Allocate a new buffer if:

			 * 1. We can't seek on this file and -b is not in

			 *    effect; or

			 * 2. We haven't allocated the max buffers for this

			 *    file yet.

			 */

					/*

					 * Allocation failed: turn off autobuf.

					 */

		}

read_more:

		/*

		 * At end of file.

		 */

		/*

		 * Not at the correct position: must seek.

		 * If input is a pipe, we're in trouble (can't seek on a pipe).

		 * Some data has been lost: just return "?".

		 */

		}

	/*

	 * Read the block.

	 * If we read less than a full block, that's ok.

	 * We use partial block and pick up the rest next time.

	 */

		n = 1;

	}

		n = 0;

	}

	/*

	 * If we have a log file, write the new data to it.

	 */

	/*

	 * If we have read to end of file, set ch_fsize to indicate

	 * the position of the end of file.

	 */

			/*

			 * We are ignoring EOF.

			 * Wait a while, then try again.

			 */

			}

			slept = TRUE;

				/*

				 * See whether the file's i-number has changed.

				 * If so, force the file to be closed and

				 * reopened.

				 */

					/*

					 * screen_trashed=2 causes

					 * make_display to reopen the file.

					 */

				}

			}

		}

	}

found:

		/*

		 * Move the buffer to the head of the buffer chain.

		 * This orders the buffer chain, most- to least-recently used.

		 */

		/*

		 * Move to head of hash chain too.

		 */

		/*

		 * After all that, we still don't have enough data.

		 * Go back and try again.

		 */

/*

 * ch_ungetchar is a rather kludgy and limited way to push

 * a single char onto an input file descriptor.

 */

void

ch_ungetchar(int c)

{

/*

 * Close the logfile.

 * If we haven't read all of standard input into it, do that now.

 */

void

end_logfile(void)

{

	static int tried = FALSE;

		return;

				break;

	}

/*

 * Start a log file AFTER less has already been running.

 * Invoked from the - command; see toggle_option().

 * Write all the existing buffered data to the log file.

 */

void

sync_logfile(void)

{

	struct buf *bp;

	struct bufnode *bn;

	int warned = FALSE;

	BLOCKNUM block;

	BLOCKNUM nblocks;

		int wrote = FALSE;

				wrote = TRUE;

			}

		}

			warned = TRUE;

		}

	}

}

/*

 * Determine if a specific block is currently in one of the buffers.

 */

static int

buffered(BLOCKNUM block)

{

	struct buf *bp;

	struct bufnode *bn;

	int h;

	}

}

/*

 * Seek to a specified position in the file.

 * Return 0 if successful, non-zero if can't seek there.

 */

int

ch_seek(off_t pos)

{

	BLOCKNUM new_block;

	off_t len;

		}

	}

	/*

	 * Set read pointer.

	 */

/*

 * Seek to the end of the file.

 */

int

ch_end_seek(void)

{

	off_t len;

	/*

	 * Do it the slow way: read till end of data.

	 */

}

/*

 * Seek to the beginning of the file, or as close to it as we can get.

 * We may not be able to seek there if input is a pipe and the

 * beginning of the pipe is no longer buffered.

 */

int

ch_beg_seek(void)

{

	struct bufnode *bn;

	struct bufnode *firstbn;

	/*

	 * Try a plain ch_seek first.

	 */

	/*

	 * Can't get to position 0.

	 * Look thru the buffers for the one closest to position 0.

	 */

	}

}

/*

 * Return the length of the file, if known.

 */

off_t

ch_length(void)

{

/*

 * Return the current position in the file.

 */

off_t

ch_tell(void)

{

/*

 * Get the current char and post-increment the read pointer.

 */

int

ch_forw_get(void)

{

	int c;

	}

/*

 * Pre-decrement the read pointer and get the new current char.

 */

int

ch_back_get(void)

{

	}

/*

 * Set max amount of buffer space.

 * bufspace is in units of 1024 bytes.  -1 mean no limit.

 */

void

ch_setbufspace(int bufspace)

{

		maxbufs = -1;

	} else {

			maxbufs = 1;

	}

/*

 * Flush (discard) any saved file state, including buffer contents.

 */

void

ch_flush(void)

{

	struct bufnode *bn;

		/*

		 * If input is a pipe, we don't flush buffer contents,

		 * since the contents can't be recovered.

		 */

	}

	/*

	 * Initialize all the buffers.

	 */

	}

	/*

	 * Figure out the size of the file, if we can.

	 */

	/*

	 * Seek to a known position: the beginning of the file.

	 */

#if 1

	/*

	 * This is a kludge to workaround a Linux kernel bug: files in

	 * /proc have a size of 0 according to fstat() but have readable

	 * data.  They are sometimes, but not always, seekable.

	 * Force them to be non-seekable here.

	 */

	}

#endif

		/*

		 * Warning only; even if the seek fails for some reason,

		 * there's a good chance we're at the beginning anyway.

		 * {{ I think this is bogus reasoning. }}

		 */

	}

/*

 * Allocate a new buffer.

 * The buffer is added to the tail of the buffer chain.

 */

static int

ch_addbuf(void)

{

	struct buf *bp;

	struct bufnode *bn;

	/*

	 * Allocate and initialize a new buffer and link it

	 * onto the tail of the buffer list.

	 */

/*

 *

 */

static void

init_hashtbl(void)

{

	int h;

	}

/*

 * Delete all buffers for this file.

 */

static void

ch_delbufs(void)

{

	struct bufnode *bn;

		bn = ch_bufhead;

	}

/*

 * Is it possible to seek on a file descriptor?

 */

int

seekable(int f)

{

}

/*

 * Force EOF to be at the current read position.

 * This is used after an ignore_eof read, during which the EOF may change.

 */

void

ch_set_eof(void)

{

}

/*

 * Initialize file state for a new file.

 */

void

ch_init(int f, int flags)

{

	/*

	 * See if we already have a filestate for this file.

	 */

		/*

		 * Allocate and initialize a new filestate.

		 */

		/*

		 * Try to seek; set CH_CANSEEK if it works.

		 */

/*

 * Close a filestate.

 */

void

ch_close(void)

{

	int keepstate = FALSE;

		/*

		 * We can seek or re-open, so we don't need to keep buffers.

		 */

		keepstate = TRUE;

	}

		/*

		 * We don't need to keep the file descriptor open

		 * (because we can re-open it.)

		 * But don't really close it if it was opened via popen(),

		 * because pclose() wants to close it.

		 */

		keepstate = TRUE;

	}

		/*

		 * We don't even need to keep the filestate structure.

		 */

/*

 * Return ch_flags for the current file.

 */

int

ch_getflags(void)

{