Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/unix/volume3/less/part2

Internet Message Format | 1986-11-30 | 56.3 KB

From: ihnp4!nsc!nsc-pdc!rgb (Robert Bond)
Subject: less part 2 of 2
Newsgroups: mod.sources
Approved: [e-mail]

Mod.sources:  Volume 3, Issue 121
Submitted by: ihnp4!nsc!nsc-pdc!rgb (Robert Bond)


#!/bin/sh-----cut here-----cut here-----cut here-----cut here-----
# shar:    Shell Archiver
#    Run the following text with /bin/sh to create:
#    ch.c
#    position.c
#    input.c
#    output.c
#    screen.c
#    prompt.c
#    line.c
#    signal.c
#    help.c
#    ttyin.c
#    command.c
#    version.c
echo shar: extracting ch.c
cat - << \SHAR_EOF > ch.c
/*
 * 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 "less.h"

public int file = -1;    /* File descriptor of the input file */

/*
 * Pool of buffers holding the most recently used blocks of the input file.
 */
#define BUFSIZ    1024
static struct buf {
    struct buf *next, *prev;
    long block;
    char data[BUFSIZ];
};
static struct buf *bufs = NULL;
public int nbufs;

/*
 * 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 buf_anchor.
 */
static struct {
    struct buf *next, *prev;
} buf_anchor;
#define    END_OF_CHAIN    ((struct buf *)&buf_anchor)
#define    buf_head    buf_anchor.next
#define    buf_tail    buf_anchor.prev

/*
 * If we fail to allocate enough memory for buffers, we try to limp
 * along with a minimum number of buffers.
 */
#define    DEF_NBUFS    2    /* Minimum number of buffers */

extern int clean_data;
extern int ispipe;

/*
 * Current position in file.
 * Stored as a block number and an offset into the block.
 */
static long ch_block;
static int ch_offset;

/*
 * Length of file, needed if input is a pipe.
 */
static POSITION ch_fsize;

/*
 * Largest block number read if input is standard input (a pipe).
 */
static long last_piped_block;

/*
 * Get the character pointed to by the read pointer.
 * ch_get() is a macro which is more efficient to call
 * than fch_get (the function), in the usual case
 * that the block desired is at the head of the chain.
 */
#define    ch_get()   ((buf_head->block == ch_block) ? \
            buf_head->data[ch_offset] : fch_get())
    static int
fch_get()
{
    register struct buf *bp;
    register int n;
    register int end;
    POSITION pos;

    /*
     * Look for a buffer holding the desired block.
     */
    for (bp = buf_head;  bp != END_OF_CHAIN;  bp = bp->next)
        if (bp->block == ch_block)
            goto found;
    /*
     * Block is not in a buffer.
     * Take the least recently used buffer
     * and read the desired block into it.
     */
    bp = buf_tail;
    bp->block = ch_block;
    pos = ch_block * BUFSIZ;
    if (ispipe)
    {
        /*
         * The block requested should be one more than
         * the last block read.
         */
        if (ch_block != ++last_piped_block)
        {
            /* This "should not happen". */
            char message[80];
            sprintf(message, "Pipe error: last %ld, want %ld\n",
                last_piped_block-1, ch_block);
            error(message);
            quit();
        }
    } else
        lseek(file, pos, 0);

    /*
     * Read the block.  This may take several reads if the input
     * is coming from standard input, due to the nature of pipes.
     */
    end = 0;
    while ((n = read(file, &bp->data[end], BUFSIZ-end)) > 0)
        if ((end += n) >= BUFSIZ)
            break;

    if (n < 0)
    {
        error("read error");
        quit();
    }

    /*
     * Set an EOF marker in the buffered data itself.
     * Then ensure the data is "clean": there are no
     * extra EOF chars in the data and that the "meta"
     * bit (the 0200 bit) is reset in each char.
     */
    if (end < BUFSIZ)
    {
        ch_fsize = pos + end;
        bp->data[end] = EOF;
    }

    if (!clean_data)
        while (--end >= 0)
        {
            bp->data[end] &= 0177;
            if (bp->data[end] == EOF)
                bp->data[end] = '@';
        }

    found:
    /* if (buf_head != bp) {this is guaranteed by the ch_get macro} */
    {
        /*
         * Move the buffer to the head of the buffer chain.
         * This orders the buffer chain, most- to least-recently used.
         */
        bp->next->prev = bp->prev;
        bp->prev->next = bp->next;

        bp->next = buf_head;
        bp->prev = END_OF_CHAIN;
        buf_head->prev = bp;
        buf_head = bp;
    }
    return (bp->data[ch_offset]);
}

/*
 * Determine if a specific block is currently in one of the buffers.
 */
    static int
buffered(block)
    long block;
{
    register struct buf *bp;

    for (bp = buf_head;  bp != END_OF_CHAIN;  bp = bp->next)
        if (bp->block == block)
            return (1);
    return (0);
}

/*
 * Seek to a specified position in the file.
 * Return 0 if successful, non-zero if can't seek there.
 */
    public int
ch_seek(pos)
    register POSITION pos;
{
    long new_block;

    new_block = pos / BUFSIZ;
    if (!ispipe || new_block == last_piped_block + 1 || buffered(new_block))
    {
        /*
         * Set read pointer.
         */
        ch_block = new_block;
        ch_offset = pos % BUFSIZ;
        return (0);
    }
    return (1);
}

/*
 * Seek to the end of the file.
 */
    public int
ch_end_seek()
{
    if (ispipe)
    {
        /*
         * Do it the slow way: read till end of data.
         */
        while (ch_forw_get() != EOF)
            ;
    } else
    {
        (void) ch_seek((POSITION)(lseek(file, (off_t)0, 2)));
    }
    return (0);
}

/*
 * Return the length of the file, if known.
 */
    public POSITION
ch_length()
{
    if (ispipe)
        return (ch_fsize);
    return ((POSITION)(lseek(file, (off_t)0, 2)));
}

/*
 * Return the current position in the file.
 */
    public POSITION
ch_tell()
{
    return (ch_block * BUFSIZ + ch_offset);
}

/*
 * Get the current char and post-increment the read pointer.
 */
    public int
ch_forw_get()
{
    register int c;

    c = ch_get();
    if (c != EOF && ++ch_offset >= BUFSIZ)
    {
        ch_offset = 0;
        ch_block ++;
    }
    return (c);
}

/*
 * Pre-decrement the read pointer and get the new current char.
 */
    public int
ch_back_get()
{
    register int c;

    if (--ch_offset < 0)
    {
        if (ch_block <= 0 || (ispipe && !buffered(ch_block-1)))
        {
            ch_offset = 0;
            return (EOF);
        }
        ch_offset = BUFSIZ - 1;
        ch_block--;
    }
    c = ch_get();
    return (c);
}

/*
 * Initialize the buffer pool to all empty.
 * Caller suggests that we use want_nbufs buffers.
 */
    public void
ch_init(want_nbufs)
    int want_nbufs;
{
    register struct buf *bp;
    char *calloc();

    if (nbufs < want_nbufs)
    {
        /*
         * We don't have enough buffers.
         * Free what we have (if any) and allocate some new ones.
         */
        if (bufs != NULL)
            free((char *)bufs);
        bufs = (struct buf *) calloc(want_nbufs, sizeof(struct buf));
        nbufs = want_nbufs;
        if (bufs == NULL)
        {
            /*
             * Couldn't get that many.
             * Try for a small default number of buffers.
             */
            char message[80];
            sprintf(message,
              "Cannot allocate %d buffers.  Using %d buffers.",
              nbufs, DEF_NBUFS);
            error(message);
            bufs = (struct buf *) calloc(DEF_NBUFS, sizeof(struct buf));
            nbufs = DEF_NBUFS;
            if (bufs == NULL)
            {
                /*
                 * Couldn't even get the smaller number of bufs.
                 * Something is wrong here, don't continue.
                 */
                sprintf(message,
                "Cannot even allocate %d buffers!  Quitting.\n",
                  DEF_NBUFS);
                error(message);
                quit();
                /*NOTREACHED*/
            }
        }
    }

    /*
     * Initialize the buffers to empty.
     * Set up the circular list.
     */
    for (bp = &bufs[0];  bp < &bufs[nbufs];  bp++)
    {
        bp->next = bp + 1;
        bp->prev = bp - 1;
        bp->block = (long)(-1);
    }
    bufs[0].prev = bufs[nbufs-1].next = END_OF_CHAIN;
    buf_head = &bufs[0];
    buf_tail = &bufs[nbufs-1];
    last_piped_block = -1;
    ch_fsize = NULL_POSITION;
    (void) ch_seek((POSITION)0);
}
SHAR_EOF
echo shar: extracting position.c
cat - << \SHAR_EOF > position.c
/*
 * Routines dealing with the "position" table.
 * This is a table which tells the position (in the input file) of the
 * first char on each currently displayed line.
 *
 * {{ The position table is scrolled by moving all the entries.
 *    Would be better to have a circular table
 *    and just change a couple of pointers. }}
 */

#include "less.h"
#include "position.h"

#define    NPOS    100        /* {{ sc_height must be less than NPOS }} */
static POSITION table[NPOS];    /* The position table */

extern int sc_width, sc_height;

/*
 * Return the position of one of:
 *    the top (first) line on the screen
 *    the second line on the screen
 *    the bottom line on the screen
 *    the line after the bottom line on the screen
 */
    public POSITION
position(where)
    int where;
{
    switch (where)
    {
    case BOTTOM:
        where = sc_height - 2;
        break;
    case BOTTOM_PLUS_ONE:
        where = sc_height - 1;
        break;
    }
    return (table[where]);
}

/*
 * Add a new file position to the bottom of the position table.
 */
    public void
add_forw_pos(pos)
    POSITION pos;
{
    register int i;

    /*
     * Scroll the position table up.
     */
    for (i = 1;  i < sc_height;  i++)
        table[i-1] = table[i];
    table[sc_height - 1] = pos;
}

/*
 * Add a new file position to the top of the position table.
 */
    public void
add_back_pos(pos)
    POSITION pos;
{
    register int i;

    /*
     * Scroll the position table down.
     */
    for (i = sc_height - 1;  i > 0;  i--)
        table[i] = table[i-1];
    table[0] = pos;
}

/*
 * Initialize the position table, done whenever we clear the screen.
 */
    public void
pos_clear()
{
    register int i;

    for (i = 0;  i < sc_height;  i++)
        table[i] = NULL_POSITION;
}

/*
 * See if the byte at a specified position is currently on the screen.
 * Check the position table to see if the position falls within its range.
 * Return the position table entry if found, -1 if not.
 */
    public int
onscreen(pos)
    POSITION pos;
{
    register int i;

    if (pos < table[0])
        return (-1);
    for (i = 1;  i < sc_height;  i++)
        if (pos < table[i])
            return (i-1);
    return (-1);
}
SHAR_EOF
echo shar: extracting input.c
cat - << \SHAR_EOF > input.c
/*
 * High level routines dealing with getting lines of input
 * from the file being viewed.
 *
 * When we speak of "lines" here, we mean PRINTABLE lines;
 * lines processed with respect to the screen width.
 * We use the term "raw line" to refer to lines simply
 * delimited by newlines; not processed with respect to screen width.
 */

#include "less.h"

extern int do_bs;
extern int squeeze;
extern char *line;

/*
 * Get the next line.
 * A "current" position is passed and a "new" position is returned.
 * The current position is the position of the first character of
 * a line.  The new position is the position of the first character
 * of the NEXT line.  The line obtained is the line starting at curr_pos.
 */
    public POSITION
forw_line(curr_pos)
    POSITION curr_pos;
{
    POSITION new_pos;
    register int c;

    if (curr_pos == NULL_POSITION || ch_seek(curr_pos))
        return (NULL_POSITION);

    c = ch_forw_get();
    if (c == EOF)
        return (NULL_POSITION);

    prewind();
    for (;;)
    {
        if (c == '\n' || c == EOF)
        {
            /*
             * End of the line.
             */
            new_pos = ch_tell();
            break;
        }

        /*
         * Append the char to the line and get the next char.
         */
        if (pappend(c))
        {
            /*
             * The char won't fit in the line; the line
             * is too long to print in the screen width.
             * End the line here.
             */
            new_pos = ch_tell() - 1;
            break;
        }
        c = ch_forw_get();
    }
    (void) pappend('\0');

    if (squeeze && *line == '\0')
    {
        /*
         * This line is blank.
         * Skip down to the last contiguous blank line
         * and pretend it is the one which we are returning.
         */
        while ((c = ch_forw_get()) == '\n')
            ;
        if (c != EOF)
            (void) ch_back_get();
        new_pos = ch_tell();
    }

    return (new_pos);
}

/*
 * Get the previous line.
 * A "current" position is passed and a "new" position is returned.
 * The current position is the position of the first character of
 * a line.  The new position is the position of the first character
 * of the PREVIOUS line.  The line obtained is the one starting at new_pos.
 */
    public POSITION
back_line(curr_pos)
    POSITION curr_pos;
{
    POSITION new_pos, begin_new_pos;
    int c;

    if (curr_pos == NULL_POSITION || curr_pos <= (POSITION)0 ||
        ch_seek(curr_pos-1))
        return (NULL_POSITION);

    if (squeeze)
    {
        /*
         * Find out if the "current" line was blank.
         */
        (void) ch_forw_get();    /* Skip the newline */
        c = ch_forw_get();    /* First char of "current" line */
        (void) ch_back_get();    /* Restore our position */
        (void) ch_back_get();

        if (c == '\n')
        {
            /*
             * The "current" line was blank.
             * Skip over any preceeding blank lines,
             * since we skipped them in forw_line().
             */
            while ((c = ch_back_get()) == '\n')
                ;
            if (c == EOF)
                return (NULL_POSITION);
            (void) ch_forw_get();
        }
    }

    /*
     * Scan backwards until we hit the beginning of the line.
     */
    for (;;)
    {
        c = ch_back_get();
        if (c == '\n')
        {
            /*
             * This is the newline ending the previous line.
             * We have hit the beginning of the line.
             */
            new_pos = ch_tell() + 1;
            break;
        }
        if (c == EOF)
        {
            /*
             * We have hit the beginning of the file.
             * This must be the first line in the file.
             * This must, of course, be the beginning of the line.
             */
            new_pos = (POSITION)0;
            break;
        }
    }

    /*
     * Now scan forwards from the beginning of this line.
     * We keep discarding "printable lines" (based on screen width)
     * until we reach the curr_pos.
     *
     * {{ This algorithm is pretty inefficient if the lines
     *    are much longer than the screen width,
     *    but I don't know of any better way. }}
     */
    if (ch_seek(new_pos))
        return (NULL_POSITION);
    loop:
    begin_new_pos = new_pos;
    prewind();

    do
    {
        c = ch_forw_get();
        new_pos++;
        if (c == '\n')
            break;
        if (pappend(c))
        {
            /*
             * Got a full printable line, but we haven't
             * reached our curr_pos yet.  Discard the line
             * and start a new one.
             */
            (void) pappend('\0');
            (void) ch_back_get();
            new_pos--;
            goto loop;
        }
    } while (new_pos < curr_pos);

    (void) pappend('\0');

    return (begin_new_pos);
}
SHAR_EOF
echo shar: extracting output.c
cat - << \SHAR_EOF > output.c
/*
 * High level routines dealing with the output to the screen.
 */

#include "less.h"

extern int sigs;
extern int sc_width, sc_height;
extern int ul_width, ue_width;
extern int so_width, se_width;
extern int tabstop;
extern int twiddle;
extern char *line;
extern char *first_cmd;

/*
 * Display the line which is in the line buffer.
 */
    public void
put_line()
{
    register char *p;
    register int c;
    register int column;
    extern int auto_wrap, ignaw;

    if (sigs)
        /*
         * Don't output if a signal is pending.
         */
        return;

    if (line == NULL)
        line = (twiddle) ? "~" : "";

    column = 0;
    for (p = line;  *p != '\0';  p++)
    {
        switch (c = *p)
        {
        case UL_CHAR:
            ul_enter();
            column += ul_width;
            break;
        case UE_CHAR:
            ul_exit();
            column += ue_width;
            break;
        case '\t':
            do
            {
                putc(' ');
                column++;
            } while ((column % tabstop) != 0);
            break;
        case '\b':
            putbs();
            column--;
            break;
        default:
            if (c & 0200)
            {
                putc('^');
                putc(c & 0177);
                column += 2;
            } else
            {
                putc(c);
                column++;
            }
        }
    }
    if (column < sc_width || !auto_wrap || ignaw)
        putc('\n');
}

/*
 * Is a given character a "control" character?
 * {{ ASCII DEPENDENT }}
 */
    public int
control_char(c)
    int c;
{
    return (c < ' ' || c == '\177');
}

/*
 * Return the printable character used to identify a control character
 * (printed after a carat; e.g. '\3' => "^C").
 * {{ ASCII DEPENDENT }}
 */
    public int
carat_char(c)
    int c;
{
    return ((c == '\177') ? '?' : (c | 0100));
}


static char obuf[1024];
static char *ob = obuf;

/*
 * Flush buffered output.
 */
    public void
flush()
{
    write(1, obuf, ob-obuf);
    ob = obuf;
}

/*
 * Discard buffered output.
 */
    public void
dropout()
{
    ob = obuf;
}

/*
 * Output a character.
 */
    public void
putc(c)
    int c;
{
    if (ob >= &obuf[sizeof(obuf)])
        flush();
    *ob++ = c;
}

/*
 * Output a string.
 */
    public void
puts(s)
    register char *s;
{
    while (*s != '\0')
        putc(*s++);
}

/*
 * Output a message in the lower left corner of the screen
 * and wait for carriage return.
 */

static char return_to_continue[] = "  (press RETURN)";

    public void
error(s)
    char *s;
{
    register int c;
    static char buf[2];

    lower_left();
    clear_eol();
    so_enter();
    puts(s);
    puts(return_to_continue);
    so_exit();

#if ONLY_RETURN
    while ((c = getc()) != '\n' && c != '\r')
        bell();
#else
    c = getc();
    if (c != '\n' && c != '\r' && c != ' ')
    {
        buf[0] = c;
        first_cmd = buf;
    }
#endif

    if (strlen(s) > sc_width)
        repaint();
}

    public int
error_width()
{
    /*
     * Don't use the last position, because some terminals
     * will scroll if you write in the last char of the last line.
     */
    return (sc_width -
        (sizeof(return_to_continue) + so_width + se_width + 1));
}
SHAR_EOF
echo shar: extracting screen.c
cat - << \SHAR_EOF > screen.c
/*
 * Routines which deal with the characteristics of the terminal.
 * Uses termcap to be as terminal-independent as possible.
 *
 * {{ Someday this should be rewritten to use curses. }}
 */

#include "less.h"
#if XENIX
#include <sys/types.h>
#include <sys/ioctl.h>
#endif

#if TERMIO
#include <termio.h>
#else
#include <sgtty.h>
#endif

/*
 * Strings passed to tputs() to do various terminal functions.
 */
static char
    *sc_pad,        /* Pad string */
    *sc_home,        /* Cursor home */
    *sc_addline,        /* Add line, scroll down following lines */
    *sc_lower_left,        /* Cursor to last line, first column */
    *sc_move,        /* General cursor positioning */
    *sc_clear,        /* Clear screen */
    *sc_eol_clear,        /* Clear to end of line */
    *sc_s_in,        /* Enter standout (highlighted) mode */
    *sc_s_out,        /* Exit standout mode */
    *sc_u_in,        /* Enter underline mode */
    *sc_u_out,        /* Exit underline mode */
    *sc_visual_bell,    /* Visual bell (flash screen) sequence */
    *sc_backspace,        /* Backspace cursor */
    *sc_init,        /* Startup terminal initialization */
    *sc_deinit;        /* Exit terminal de-intialization */
static int dumb;
static int hard;

public int auto_wrap;        /* Terminal does \r\n when write past margin */
public int ignaw;        /* Terminal ignores \n immediately after wrap */
public int erase_char, kill_char; /* The user's erase and line-kill chars */
public int sc_width, sc_height;    /* Height & width of screen */
public int ul_width, ue_width;    /* Printing width of underline sequences */
public int so_width, se_width;    /* Printing width of standout sequences */

/*
 * These two variables are sometimes defined in,
 * and needed by, the termcap library.
 * It may be necessary on some systems to declare them extern here.
 */
/*extern*/ short ospeed;    /* Terminal output baud rate */
/*extern*/ char PC;        /* Pad character */

extern int quiet;        /* If VERY_QUIET, use visual bell for bell */
extern int know_dumb;        /* Don't complain about a dumb terminal */
extern int back_scroll;
char *tgetstr();
char *tgoto();

/*
 * Change terminal to "raw mode", or restore to "normal" mode.
 * "Raw mode" means
 *    1. An outstanding read will complete on receipt of a single keystroke.
 *    2. Input is not echoed.
 *    3. On output, \n is mapped to \r\n.
 *    4. \t is NOT be expanded into spaces.
 *    5. Signal-causing characters such as ctrl-C (interrupt),
 *       etc. are NOT disabled.
 * It doesn't matter whether an input \n is mapped to \r, or vice versa.
 */
    public void
raw_mode(on)
    int on;
{
#if TERMIO
    struct termio s;
    static struct termio save_term;

    if (on)
    {
        /*
         * Get terminal modes.
         */
        ioctl(2, TCGETA, &s);

        /*
         * Save modes and set certain variables dependent on modes.
         */
        save_term = s;
        ospeed = s.c_cflag & CBAUD;
        erase_char = s.c_cc[VERASE];
        kill_char = s.c_cc[VKILL];

        /*
         * Set the modes to the way we want them.
         */
        s.c_lflag &= ~(ICANON|ECHO|ECHOE|ECHOK|ECHONL);
        s.c_oflag |=  (OPOST|ONLCR|TAB3);
        s.c_oflag &= ~(OCRNL|ONOCR|ONLRET);
        s.c_cc[VMIN] = 1;
        s.c_cc[VTIME] = 0;
    } else
    {
        /*
         * Restore saved modes.
         */
        s = save_term;
    }
    ioctl(2, TCSETAW, &s);
#else
    struct sgttyb s;
    static struct sgttyb save_term;

    if (on)
    {
        /*
         * Get terminal modes.
         */
        ioctl(2, TIOCGETP, &s);

        /*
         * Save modes and set certain variables dependent on modes.
         */
        save_term = s;
        ospeed = s.sg_ospeed;
        erase_char = s.sg_erase;
        kill_char = s.sg_kill;

        /*
         * Set the modes to the way we want them.
         */
        s.sg_flags |= CBREAK;
        s.sg_flags &= ~(ECHO|XTABS);
    } else
    {
        /*
         * Restore saved modes.
         */
        s = save_term;
    }
    ioctl(2, TIOCSETN, &s);
#endif
}

static int couldnt = 0;

    static void
cannot(s)
    char *s;
{
    if (know_dumb)
        /*
         * He knows he has a dumb terminal, so don't tell him.
         */
        return;

    printf("WARNING: terminal cannot \"%s\"\n", s);
    couldnt = 1;
}

/*
 * Get terminal capabilities via termcap.
 */
    public void
get_term()
{
    char termbuf[1024];
    char *sp;
    static char sbuf[150];

    char *getenv();

    /*
     * Find out what kind of terminal this is.
     */
    if (tgetent(termbuf, getenv("TERM")) <= 0)
        dumb = 1;

    /*
     * Get size of the screen.
     */
    if (dumb || (sc_height = tgetnum("li")) < 0 || tgetflag("hc"))
    {
        /* Oh no, this is a hardcopy terminal. */
        hard = 1;
        sc_height = 24;
    }
    if (dumb || (sc_width = tgetnum("co")) < 0)
        sc_width = 80;

    auto_wrap = tgetflag("am");
    ignaw = tgetflag("xn");

    /*
     * Assumes termcap variable "sg" is the printing width of
     * the standout sequence, the end standout sequence,
     * the underline sequence, and the end underline sequence.
     */
    if ((ul_width = tgetnum("sg")) < 0)
        ul_width = 0;
    so_width = se_width = ue_width = ul_width;

    /*
     * Get various string-valued capabilities.
     */
    sp = sbuf;

    sc_pad = (dumb) ? NULL : tgetstr("pc", &sp);
    if (sc_pad != NULL)
        PC = *sc_pad;

    sc_init = (dumb) ? NULL : tgetstr("ti", &sp);
    if (sc_init == NULL)
        sc_init = "";

    sc_deinit= (dumb) ? NULL : tgetstr("te", &sp);
    if (sc_deinit == NULL)
        sc_deinit = "";

    sc_eol_clear = (dumb) ? NULL : tgetstr("ce", &sp);
    if (hard || sc_eol_clear == NULL || *sc_eol_clear == '\0')
    {
        cannot("clear to end of line");
        sc_eol_clear = "";
    }

    sc_clear = (dumb) ? NULL : tgetstr("cl", &sp);
    if (hard || sc_clear == NULL || *sc_clear == '\0')
    {
        cannot("clear screen");
        sc_clear = "\n\n";
    }

    sc_move = (dumb) ? NULL : tgetstr("cm", &sp);
    if (hard || sc_move == NULL || *sc_move == '\0')
    {
        /*
         * This is not an error here, because we don't
         * always need sc_move.
         * We need it only if we don't have home or lower-left.
         */
        sc_move = "";
    }

    sc_s_in = (dumb) ? NULL : tgetstr("so", &sp);
    if (hard || sc_s_in == NULL)
        sc_s_in = "";

    sc_s_out = (dumb) ? NULL : tgetstr("se", &sp);
    if (hard || sc_s_out == NULL)
        sc_s_out = "";

    sc_u_in = (dumb) ? NULL : tgetstr("us", &sp);
    if (hard || sc_u_in == NULL)
        sc_u_in = sc_s_in;

    sc_u_out = (dumb) ? NULL : tgetstr("ue", &sp);
    if (hard || sc_u_out == NULL)
        sc_u_out = sc_s_out;

    sc_visual_bell = (dumb) ? NULL : tgetstr("vb", &sp);
    if (hard || sc_visual_bell == NULL)
        sc_visual_bell = "";

    sc_home = (dumb) ? NULL : tgetstr("ho", &sp);
    if (hard || sc_home == NULL || *sc_home == '\0')
    {
        if (*sc_move == '\0')
        {
            cannot("home cursor");
            /*
             * This last resort for sc_home is supposed to
             * be an up-arrow suggesting moving to the
             * top of the "virtual screen". (The one in
             * your imagination as you try to use this on
             * a hard copy terminal.)
             */
            sc_home = "|\b^";
        } else
        {
            /*
             * No "home" string,
             * but we can use "move(0,0)".
             */
            strcpy(sp, tgoto(sc_move, 0, 0));
            sc_home = sp;
            sp += strlen(sp) + 1;
        }
    }

    sc_lower_left = (dumb) ? NULL : tgetstr("ll", &sp);
    if (hard || sc_lower_left == NULL || *sc_lower_left == '\0')
    {
        if (*sc_move == '\0')
        {
            cannot("move cursor to lower left of screen");
            sc_lower_left = "\r";
        } else
        {
            /*
             * No "lower-left" string,
             * but we can use "move(0,last-line)".
             */
            strcpy(sp, tgoto(sc_move, 0, sc_height-1));
            sc_lower_left = sp;
            sp += strlen(sp) + 1;
        }
    }

    /*
     * To add a line at top of screen and scroll the display down,
     * we use "al" (add line) or "sr" (scroll reverse).
     */
    if (dumb)
        sc_addline = NULL;
    else if ((sc_addline = tgetstr("al", &sp)) == NULL ||
         *sc_addline == '\0')
        sc_addline = tgetstr("sr", &sp);

    if (hard || sc_addline == NULL || *sc_addline == '\0')
    {
        cannot("scroll backwards");
        sc_addline = "";
        /* Force repaint on any backward movement */
        back_scroll = 0;
    }

    if (dumb || tgetflag("bs"))
        sc_backspace = "\b";
    else
    {
        sc_backspace = tgetstr("bc", &sp);
        if (sc_backspace == NULL || *sc_backspace == '\0')
            sc_backspace = "\b";
    }

    if (couldnt)
        /* Give him time to read all the "cannot" messages. */
        error("");
}


/*
 * Below are the functions which perform all the
 * terminal-specific screen manipulation.
 */


/*
 * Initialize terminal
 */
    public void
init()
{
    tputs(sc_init, sc_height, putc);
}

/*
 * Deinitialize terminal
 */
    public void
deinit()
{
    tputs(sc_deinit, sc_height, putc);
}

/*
 * Home cursor (move to upper left corner of screen).
 */
    public void
home()
{
    tputs(sc_home, 1, putc);
}

/*
 * Add a blank line (called with cursor at home).
 * Should scroll the display down.
 */
    public void
add_line()
{
    tputs(sc_addline, sc_height, putc);
}

/*
 * Move cursor to lower left corner of screen.
 */
    public void
lower_left()
{
    tputs(sc_lower_left, 1, putc);
}

/*
 * Ring the terminal bell.
 */
    public void
bell()
{
    if (quiet == VERY_QUIET)
        vbell();
    else
        putc('\7');
}

/*
 * Output the "visual bell", if there is one.
 */
    public void
vbell()
{
    if (*sc_visual_bell == '\0')
        return;
    tputs(sc_visual_bell, sc_height, putc);
}

/*
 * Clear the screen.
 */
    public void
clear()
{
    tputs(sc_clear, sc_height, putc);
}

/*
 * Clear from the cursor to the end of the cursor's line.
 * {{ This must not move the cursor. }}
 */
    public void
clear_eol()
{
    tputs(sc_eol_clear, 1, putc);
}

/*
 * Begin "standout" (bold, underline, or whatever).
 */
    public void
so_enter()
{
    tputs(sc_s_in, 1, putc);
}

/*
 * End "standout".
 */
    public void
so_exit()
{
    tputs(sc_s_out, 1, putc);
}

/*
 * Begin "underline" (hopefully real underlining,
 * otherwise whatever the terminal provides).
 */
    public void
ul_enter()
{
    tputs(sc_u_in, 1, putc);
}

/*
 * End "underline".
 */
    public void
ul_exit()
{
    tputs(sc_u_out, 1, putc);
}

/*
 * Erase the character to the left of the cursor
 * and move the cursor left.
 */
    public void
backspace()
{
    /*
     * Try to erase the previous character by overstriking with a space.
     */
    tputs(sc_backspace, 1, putc);
    putc(' ');
    tputs(sc_backspace, 1, putc);
}

/*
 * Output a plain backspace, without erasing the previous char.
 */
    public void
putbs()
{
    tputs(sc_backspace, 1, putc);
}
SHAR_EOF
echo shar: extracting prompt.c
cat - << \SHAR_EOF > prompt.c
/*
 * Prompting and other messages.
 * There are three flavors of prompts, SHORT, MEDIUM and LONG,
 * selected by the -m/-M options.
 * A prompt is either a colon or a message composed of various
 * pieces, such as the name of the file being viewed, the percentage
 * into the file, etc.
 */

#include "less.h"
#include "position.h"

extern int pr_type;
extern int ispipe;
extern int hit_eof;
extern int new_file;
extern int sc_width;
extern char current_file[];
extern int ac;
extern char **av;
extern int curr_ac;

static char message[500];

/*
 * Append the name of the current file (to the message buffer).
 */
    static void
ap_filename()
{
    if (!ispipe)
        sprintf(message + strlen(message),
            "%s", current_file);
}

/*
 * Append the "file N of M" message.
 */
    static void
ap_of()
{
    if (ac > 1)
        sprintf(message + strlen(message),
            " (file %d of %d)", curr_ac+1, ac);
}

/*
 * Append the byte offset into the current file.
 */
    static void
ap_byte()
{
    POSITION pos, len;

    pos = position(BOTTOM_PLUS_ONE);
    if (pos != NULL_POSITION)
    {
        sprintf(message + strlen(message),
            " byte %ld", pos);
        len = ch_length();
        if (len > 0)
            sprintf(message + strlen(message),
                "/%ld", len);
    }
}

/*
 * Append the percentage into the current file.
 * If we cannot find the percentage and must_print is true,
 * the use the byte offset.
 */
    static void
ap_percent(must_print)
{
    POSITION pos,len;

    pos = position(BOTTOM_PLUS_ONE);
    len = ch_length();
    if (len > 0 && pos != NULL_POSITION)
        sprintf(message + strlen(message),
            " (%ld%%)", (100 * pos) / len);
    else if (must_print)
        ap_byte();
}

/*
 * Append the end-of-file message.
 */
    static void
ap_eof()
{
    strcat(message, " END");
    if (curr_ac + 1 < ac)
        sprintf(message + strlen(message),
            " - Next: %s", av[curr_ac+1]);
}

/*
 * Return a message suitable for printing by the "=" command.
 */
    public char *
eq_message()
{
    message[0] = '\0';
    ap_filename();
    ap_of();
    ap_byte();
    ap_percent(0);
    /*
     * Truncate to the screen width.
     * {{ This isn't very nice. }}
     */
    message[error_width()] = '\0';
    return (message);
}

/*
 * Return a prompt.
 * This depends on the prompt type (SHORT, MEDIUM, LONG), etc.
 * If we can't come up with an appropriate prompt, return NULL
 * and the caller will prompt with a colon.
 */
    public char *
pr_string()
{
    message[0] = '\0';
    switch (pr_type)
    {
    case PR_SHORT:
        if (new_file)
        {
            ap_filename();
            ap_of();
        }
        if (hit_eof)
            ap_eof();
        break;
    case PR_MEDIUM:
        if (new_file)
        {
            ap_filename();
            ap_of();
        }
        if (hit_eof)
            ap_eof();
        else
            ap_percent(1);
        break;
    case PR_LONG:
        ap_filename();
        if (new_file)
            ap_of();
        ap_byte();
        if (hit_eof)
            ap_eof();
        else
            ap_percent(0);
        break;
    }
    new_file = 0;
    if (message[0] == '\0')
        return (NULL);
    /*
     * Truncate to the screen width.
     * {{ This isn't very nice. }}
     */
    message[sc_width-2] = '\0';
    return (message);
}
SHAR_EOF
echo shar: extracting line.c
cat - << \SHAR_EOF > line.c
/*
 * Routines to manipulate the "line buffer".
 * The line buffer holds a line of output as it is being built
 * in preparation for output to the screen.
 * We keep track of the PRINTABLE length of the line as it is being built.
 */

#include "less.h"

static char linebuf[1024];    /* Buffer which holds the current output line */
static char *curr;        /* Pointer into linebuf */
static int column;        /* Printable length, accounting for
                   backspaces, etc. */
/*
 * A ridiculously complex state machine takes care of backspaces
 * when in BS_UNDERLINE mode.  The complexity arises from the attempt
 * to deal with all cases, especially involving long lines with underlining.
 * There are still some cases which will break it.
 *
 * There are four states:
 *    UL_NORMAL is the normal state (not in underline mode).
 *    UL_YES means we are in underline mode.  We expect to get
 *        either a sequence like "_\bX" or "X\b_" to continue
 *        underline mode, or just some ordinary characters
 *        (no backspaces) to end underline mode.
 *    UL_X means we are one character after UL_YES
 *        (we have gotten the '_' in "_\bX" or the 'X' in "X\b_").
 *    UL_XB means we are one character after UL_X
 *        (we have gotten the backspace in "_\bX" or "X\b_";
 *        we expect one more ordinary character,
 *        which will put us back in state UL_YES).
 */
static int ul_state;        /* Currently in underline mode? */
#define    UL_NORMAL    0    /* Not in underline mode */
#define    UL_YES        1    /* In underline, need next char */
#define    UL_X        2    /* In underline, got char, need \b */
#define    UL_XB        3    /* In underline, got char & \b, need one more */

public char *line;        /* Pointer to the current line.
                   Usually points to linebuf. */

extern int bs_mode;
extern int tabstop;
extern int ul_width, ue_width;
extern int sc_width, sc_height;

/*
 * Rewind the line buffer.
 */
    public void
prewind()
{
    line = curr = linebuf;
    ul_state = UL_NORMAL;
    column = 0;
}

/*
 * Append a character to the line buffer.
 * Expand tabs into spaces, handle underlining.
 * Returns 0 if ok, 1 if couldn't fit in buffer.
 */

#define    NEW_COLUMN(newcol)    if ((newcol) + ((ul_state)?ue_width:0) > sc_width) \
                    return (1); else column = (newcol)

    public int
pappend(c)
    int c;
{
    if (c == '\0')
    {
        /*
         * Terminate underline mode, if necessary.
         * Append a '\0' to the end of the line.
         */
        switch (ul_state)
        {
        case UL_X:
            curr[0] = curr[-1];
            curr[-1] = UE_CHAR;
            curr++;
            break;
        case UL_XB:
        case UL_YES:
            *curr++ = UE_CHAR;
            break;
        }
        ul_state = UL_NORMAL;
        *curr = '\0';
        return (0);
    }

    if (curr > linebuf + sizeof(linebuf) - 12)
        /*
         * Almost out of room in the line buffer.
         * Don't take any chances.
         * {{ Linebuf is supposed to be big enough that this
         *    will never happen, but may need to be made
         *    bigger for wide screens or lots of backspaces. }}
         */
        return (1);

    if (bs_mode == BS_UNDERLINE)
    {
        /*
         * Advance the state machine.
         */
        switch (ul_state)
        {
        case UL_NORMAL:
            if (curr <= linebuf + 1 || curr[-1] != '\b')
                break;
            if (c != '_' && curr[-2] != '_')
            {
                curr -= 2;
                break;
            }

            /*
             * We have either "_\bX" or "X\b_" (including
             * the current char).  Switch into underline mode.
             */
            if (column + ul_width + ue_width + 1 >= sc_width)
                /*
                 * Not enough room left on the screen to
                 * enter and exit underline mode.
                 */
                return (1);

            if (ul_width > 0 &&
                curr > linebuf + 2 && curr[-3] == ' ')
            {
                /*
                 * Special case for magic cookie terminals:
                 * if the previous char was a space, replace
                 * it with the "enter underline" sequence.
                 */
                curr[-3] = UL_CHAR;
                column += ul_width-1;
            } else
            {
                curr[-1] = curr[-2];
                curr[-2] = UL_CHAR;
                column += ul_width;
                curr++;
            }
            /* Fall thru */
        case UL_XB:
            /*
             * Termination of a sequnce "_\bX" or "X\b_".
             */
            if (c == '_')
                c = curr[-2];
            curr -= 2;
            ul_state = UL_YES;
            break;
        case UL_YES:
            if (column + ue_width + 1 >= sc_width)
                /*
                 * We have just barely enough room to
                 * exit underline mode.
                 */
                return (1);
            ul_state = UL_X;
            break;
        case UL_X:
            if (c == '\b')
                ul_state = UL_XB;
            else
            {
                /*
                 * Exit underline mode.
                 * We have to shuffle the chars a bit
                 * to make this work.
                 */
                curr[0] = curr[-1];
                curr[-1] = UE_CHAR;
                column += ue_width;
                if (ul_width > 0 && curr[0] == ' ')
                    /*
                     * Another special case for magic
                     * cookie terminals: if the next
                     * char is a space, replace it
                     * with the "exit underline" sequence.
                     */
                    column--;
                else
                    curr++;
                ul_state = UL_NORMAL;
            }
            break;
        }
    }

    if (c == '\t')
    {
        /*
         * Expand a tab into spaces.
         */
        do
        {
            NEW_COLUMN(column+1);
        } while ((column % tabstop) != 0);
        *curr++ = '\t';
        return (0);
    }

    if (c == '\b')
    {
        if (bs_mode == BS_CONTROL)
        {
            /*
             * Treat backspace as a control char: output "^H".
             */
            NEW_COLUMN(column+2);
            *curr++ = ('H' | 0200);
        } else
        {
            /*
             * Output a real backspace.
             */
            column--;
            *curr++ = '\b';
        }
        return (0);
    }

    if (control_char(c))
    {
        /*
         * Put a "^X" into the buffer.
         * The 0200 bit is used to tell put_line() to prefix
         * the char with a ^.  We don't actually put the ^
         * in the buffer because we sometimes need to move
         * chars around, and such movement might separate
         * the ^ from its following character.
         */
        NEW_COLUMN(column+2);
        *curr++ = (carat_char(c) | 0200);
        return (0);
    }

    /*
     * Ordinary character.  Just put it in the buffer.
     */
    NEW_COLUMN(column+1);
    *curr++ = c;
    return (0);
}

/*
 * Analogous to forw_line(), but deals with "raw lines":
 * lines which are not split for screen width.
 * {{ This is supposed to be more efficient than forw_line(). }}
 */
    public POSITION
forw_raw_line(curr_pos)
    POSITION curr_pos;
{
    register char *p;
    register int c;
    POSITION new_pos;

    if (curr_pos == NULL_POSITION || ch_seek(curr_pos) ||
        (c = ch_forw_get()) == EOF)
        return (NULL_POSITION);

    p = linebuf;

    for (;;)
    {
        if (c == '\n' || c == EOF)
        {
            new_pos = ch_tell();
            break;
        }
        if (p >= &linebuf[sizeof(linebuf)-1])
        {
            /*
             * Overflowed the input buffer.
             * Pretend the line ended here.
             * {{ The line buffer is supposed to be big
             *    enough that this never happens. }}
             */
            new_pos = ch_tell() - 1;
            break;
        }
        *p++ = c;
        c = ch_forw_get();
    }
    *p = '\0';
    line = linebuf;
    return (new_pos);
}

/*
 * Analogous to back_line(), but deals with "raw lines".
 * {{ This is supposed to be more efficient than back_line(). }}
 */
    public POSITION
back_raw_line(curr_pos)
    POSITION curr_pos;
{
    register char *p;
    register int c;
    POSITION new_pos;

    if (curr_pos == NULL_POSITION || curr_pos <= (POSITION)0 ||
        ch_seek(curr_pos-1))
        return (NULL_POSITION);

    p = &linebuf[sizeof(linebuf)];
    *--p = '\0';

    for (;;)
    {
        c = ch_back_get();
        if (c == '\n')
        {
            /*
             * This is the newline ending the previous line.
             * We have hit the beginning of the line.
             */
            new_pos = ch_tell() + 1;
            break;
        }
        if (c == EOF)
        {
            /*
             * We have hit the beginning of the file.
             * This must be the first line in the file.
             * This must, of course, be the beginning of the line.
             */
            new_pos = (POSITION)0;
            break;
        }
        if (p <= linebuf)
        {
            /*
             * Overflowed the input buffer.
             * Pretend the line ended here.
             */
            new_pos = ch_tell() + 1;
            break;
        }
        *--p = c;
    }
    line = p;
    return (new_pos);
}
SHAR_EOF
echo shar: extracting signal.c
cat - << \SHAR_EOF > signal.c
/*
 * Routines dealing with signals.
 *
 * A signal usually merely causes a bit to be set in the "signals" word.
 * At some convenient time, the mainline code checks to see if any
 * signals need processing by calling psignal().
 * An exception is made if we are reading from the keyboard when the
 * signal is received.  Some operating systems will simply call the
 * signal handler and NOT return from the read (with EINTR).
 * To handle this case, we service the interrupt directly from
 * the handler if we are reading from the keyboard.
 */

#include "less.h"
#include <signal.h>
#include <setjmp.h>

/*
 * The type of signal handler functions.
 * Usually int, although it should be void.
 */
typedef    int        HANDLER;

/*
 * "sigs" contains bits indicating signals which need to be processed.
 */
public int sigs;
#define    S_INTERRUPT    01
#ifdef SIGTSTP
#define    S_STOP        02
#endif

extern int reading;
extern char *first_cmd;
extern jmp_buf main_loop;

/*
 * Interrupt signal handler.
 */
    static HANDLER
interrupt()
{
    SIGNAL(SIGINT, interrupt);
    sigs |= S_INTERRUPT;
    if (reading)
        psignals();
}

#ifdef SIGTSTP
/*
 * "Stop" (^Z) signal handler.
 */
    static HANDLER
stop()
{
    SIGNAL(SIGTSTP, stop);
    sigs |= S_STOP;
    if (reading)
        psignals();
}
#endif

/*
 * Set up the signal handlers.
 */
    public void
init_signals()
{
    (void) SIGNAL(SIGINT, interrupt);
#ifdef SIGTSTP
    (void) SIGNAL(SIGTSTP, stop);
#endif
}

/*
 * Process any signals we have recieved.
 * A received signal cause a bit to be set in "sigs".
 */
    public void
psignals()
{
    register int tsignals;

    tsignals = sigs;
    sigs = 0;
    if (tsignals == 0)
        return;

    dropout();        /* Discard any buffered output */

#ifdef SIGTSTP
    if (tsignals & S_STOP)
    {
        /*
         * Clean up the terminal.
         */
#ifdef SIGTTOU
        SIGNAL(SIGTTOU, SIG_IGN);
#endif
        lower_left();
        clear_eol();
        flush();
        raw_mode(0);
#ifdef SIGTTOU
        SIGNAL(SIGTTOU, SIG_DFL);
#endif
        SIGNAL(SIGTSTP, SIG_DFL);
#if SIGSETMASK
        /*
         * This system will not allow us to send a
         * stop signal (SIGTSTP) to ourself
         * while we are in the signal handler, like maybe now.
         * (This can be the case if we are reading; see comment above.)
         * So we ask the silly system for permission to do so.
         */
        sigsetmask(0);
#endif
        kill(getpid(), SIGTSTP);
        /*
         * ... Bye bye. ...
         * Hopefully we'll be back later and resume here...
         * Reset the terminal and arrange to repaint the
         * screen when we get back to the main command loop.
         */
        SIGNAL(SIGTSTP, stop);
        raw_mode(1);
        first_cmd = "r";
        longjmp(main_loop, 1);
    }
#endif
    if (tsignals & S_INTERRUPT)
    {
        bell();
        /*
         * {{ You may wish to replace the bell() with
         *    error("Interrupt"); }}
         */
    }

    longjmp(main_loop, 1);
}

/*
 * Pass the specified command to a shell to be executed.
 * Like plain "system()", but handles resetting terminal modes, etc.
 */
    public void
lsystem(cmd)
    char *cmd;
{
    int inp;

    /*
     * Print the command which is to be executed.
     */
    lower_left();
    clear_eol();
    puts("!");
    puts(cmd);
    puts("\n");

    /*
     * De-initialize the terminal and take out of raw mode.
     */
    deinit();
    flush();
    raw_mode(0);

    /*
     * Restore signals to their defaults.
     */
    SIGNAL(SIGINT, SIG_DFL);
#ifdef SIGTSTP
    SIGNAL(SIGTSTP, SIG_DFL);
#endif
    /*
     * Pass the command to the system to be executed.
     */
    inp = dup(0);
    close(0);
    open("/dev/tty", 0);

    system(cmd);

    close(0);
    dup(inp);
    close(inp);

    /*
     * Reset signals, raw mode, etc.
     */
    init_signals();
    raw_mode(1);
    init();
}
SHAR_EOF
echo shar: extracting help.c
cat - << \SHAR_EOF > help.c
#include  "less.h"

/*
 * Display some help.
 * Help is in two pages.
 */
    static void
help0()
{
    puts("f, SPACE       Forward one screen.\n");
    puts("b              Backward one screen.\n");
    puts("e, j, CR    *  Forward N lines, default 1.\n");
    puts("y, k        *  Backward N lines, default 1.\n");
    puts("d           *  Forward N lines, default 10 or last N to d or u command.\n");
    puts("u           *  Backward N lines, default 10 or last N to d or u command.\n");
    puts("r              Repaint screen.\n");
    puts("g           *  Go to line N, default 1.\n");
    puts("G           *  Like g, but default is last line in file.\n");
    puts("=              Print current file name\n");
    puts("/pattern    *  Search forward for N-th occurence of pattern.\n");
    puts("?pattern    *  Search backward for N-th occurence of pattern.\n");
    puts("n           *  Repeat previous search (for N-th occurence).\n");
    puts("q              Exit.\n");
    error("More help...");
}

    static void
help1()
{
    char message[100];
    extern char all_options[];

    puts("R              Repaint screen, discarding buffered input.\n");
    puts("p, %        *  Position to N percent into the file.\n");
    puts("m<letter>      Mark the current position with <letter>.\n");
    puts("'<letter>      Return to a previously marked position.\n");
    sprintf(message,
         "-X             Toggle a flag (X may be one of \"%s\").\n",
                all_options);
    puts(message);
    puts("E [file]       Examine a new file.\n");
    puts("N              Examine the next file (from the command line).\n");
    puts("P              Examine the previous file (from the command line).\n");
    puts("V              Print version number.\n");
#if SHELL_ESCAPE
    puts("!command       Passes the command to a shell to be executed.\n");
#endif
#if EDITOR
    sprintf(message,
         "v              Edit the current file with $EDITOR (default %s).\n",
                EDIT_PGM);
    puts(message);
#endif
    error("");
}

    public void
help()
{
    register int i;

    for (i = 0;  i < 2;  i++)
    {
        clear();
        puts("Commands marked with * may be preceeded by a number, N.\n\n");

        switch (i)
        {
        case 0:        help0();    break;
        case 1:        help1();    break;
        }
    }
}
SHAR_EOF
echo shar: extracting ttyin.c
cat - << \SHAR_EOF > ttyin.c
/*
 * Routines dealing with getting input from the keyboard (i.e. from the user).
 */

#include "less.h"

/*
 * The boolean "reading" is set true or false according to whether
 * we are currently reading from the keyboard.
 * This information is used by the signal handling stuff in signal.c.
 * {{ There are probably some race conditions here
 *    involving the variable "reading". }}
 */
public int reading;

static int tty;

/*
 * Open keyboard for input.
 * (Just use file descriptor 2.)
 */
    public void
open_getc()
{
    tty = 2;
}

/*
 * Get a character from the keyboard.
 */
    public int
getc()
{
    char c;
    int result;

    reading = 1;
    do
    {
        flush();
        result = read(tty, &c, 1);
    } while (result != 1);
    reading = 0;
    return (c & 0177);
}
SHAR_EOF
echo shar: extracting command.c
cat - << \SHAR_EOF > command.c
/*
 * User-level command processor.
 */

#include "less.h"
#include "position.h"
#include <setjmp.h>

extern jmp_buf main_loop;
extern int erase_char, kill_char;
extern int pr_type;
extern int sigs;
extern int ispipe;
extern int quit_at_eof;
extern int hit_eof;
extern int sc_width, sc_height;
extern char *first_cmd;
extern char version[];
extern char current_file[];
extern char *editor;

static char cmdbuf[90];        /* Buffer for holding a multi-char command */
static char *cp;        /* Pointer into cmdbuf */
static int cmd_col;        /* Current column of the multi-char command */
static char mcc;        /* The multi-char command letter (e.g. '/') */
static char last_mcc;        /* The previous mcc */

/*
 * Reset command buffer (to empty).
 */
cmd_reset()
{
    cp = cmdbuf;
}

/*
 * Backspace in command buffer.
 */
    static int
cmd_erase()
{
    if (cp == cmdbuf)
        /*
         * Backspace past beginning of the string:
         * this usually means abort the command.
         */
        return (1);

    if (control_char(*--cp))
    {
        /*
         * Erase an extra character, for the carat.
         */
        backspace();
        cmd_col--;
    }
    backspace();
    cmd_col--;
    return (0);
}

/*
 * Set up the display to start a new multi-character command.
 */
start_mcc()
{
    lower_left();
    clear_eol();
    putc(mcc);
    cmd_col = 1;
}

/*
 * Process a single character of a multi-character command, such as
 * a number, or the pattern of a search command.
 */
    static int
cmd_char(c)
    int c;
{
    if (c == erase_char)
    {
        if (cmd_erase())
            return (1);
    } else if (c == kill_char)
    {
        /* {{ Could do this faster, but who cares? }} */
        while (cmd_erase() == 0)
            ;
    } else
    {
        /*
         * Append the character to the string,
         * if there is room in the buffer and on the screen.
         */
        if (cp < &cmdbuf[sizeof(cmdbuf)-1] && cmd_col < sc_width-3)
        {
            *cp++ = c;
            if (control_char(c))
            {
                putc('^');
                cmd_col++;
                c = carat_char(c);
            }
            putc(c);
            cmd_col++;
        } else
            bell();
    }
    return (0);
}

/*
 * Return the number currently in the command buffer.
 */
    static int
cmd_int()
{
    *cp = '\0';
    cp = cmdbuf;
    return (atoi(cmdbuf));
}

/*
 * Move the cursor to lower left before executing a command.
 * This looks nicer if the command takes a long time before
 * updating the screen.
 */
    static void
cmd_exec()
{
    lower_left();
    flush();
}

/*
 * Display the appropriate prompt.
 */
    static void
prompt()
{
    register char *p;

    if (first_cmd != NULL && *first_cmd != '\0')
        /*
         * No prompt necessary if commands are from first_cmd
         * rather than from the user.
         */
        return;

    /*
     * Select the proper prompt and display it.
     */
    p = pr_string();
    if (p == NULL)
        putc(':');
    else
    {
        so_enter();
        puts(p);
        so_exit();
    }
}

/*
 * Get command character.
 * The character normally comes from the keyboard,
 * but may come from the "first_cmd" string.
 */
    static int
getcc()
{
    if (first_cmd == NULL)
        return (getc());

    if (*first_cmd == '\0')
    {
        /*
         * Reached end of first_cmd input.
         */
        first_cmd = NULL;
        if (cp > cmdbuf && position(TOP) == NULL_POSITION)
        {
            /*
             * Command is incomplete, so try to complete it.
             * There are only two cases:
             * 1. We have "/string" but no newline.  Add the \n.
             * 2. We have a number but no command.  Treat as #g.
             * (This is all pretty hokey.)
             */
            if (mcc != ':')
                return ('\n');
            else
                return ('g');
        }
        return (getc());
    }
    return (*first_cmd++);
}

/*
 * Main command processor.
 * Accept and execute commands until a quit command, then return.
 */
    public void
commands()
{
    register int c;
    register int n;
    register int scroll = 10;

    mcc = last_mcc = 0;

    setjmp(main_loop);
    for (;;)
    {
        /*
         * Display prompt and accept a character.
         */
        psignals();    /* See if any signals need processing */

        if (quit_at_eof && hit_eof > 1)
            /*
             * After hitting end-of-file for the second time,
             * automatically advance to the next file.
             * If there are no more files, quit.
             */
            next_file(1);

        cmd_reset();
        lower_left();
        clear_eol();
        prompt();
        c = getcc();

    again:
        if (sigs)
            continue;

        if (mcc)
        {
            /*
             * We are in a multi-character command.
             * All chars until newline go into the command buffer.
             * (Note that mcc == ':' is a special case that
             *  means a number is being entered.)
             */
            if (mcc != ':' && (c == '\n' || c == '\r'))
            {
                /*
                 * Execute the command.
                 */
                *cp = '\0';
                cmd_exec();
                if (mcc == 'E')
                {
                    char *p;
                    /*
                     * Ignore leading spaces
                     * in the filename.
                     */
                    for (p = cmdbuf;  *p == ' ';  p++) ;
                    edit(p);
#if SHELL_ESCAPE
                } else if (mcc == '!')
                {
                    lsystem(cmdbuf);
                    error("!done");
                    first_cmd = "r";    /* Repaint */
#endif
                } else
                    search(mcc, cmdbuf, n);
                mcc = 0;
            } else
            {
                if (mcc == ':' && (c < '0' || c > '9') &&
                    c != erase_char && c != kill_char)
                {
                    /*
                     * This is not part of the number
                     * we were entering.  Process
                     * it as a regular character.
                     */
                    mcc = 0;
                    goto again;
                }

                /*
                 * Append the char to the command buffer.
                 */
                if (cmd_char(c))
                {
                    /* Abort the multi-char command. */
                    mcc = 0;
                    continue;
                }
                c = getcc();
                goto again;
            }
        } else switch (c)
        {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            /*
             * First digit of a number.
             */
            mcc = ':';
            start_mcc();
            goto again;

        case 'f':
        case ' ':
        case CONTROL('F'):
            /*
             * Forward one screen.
             */
            n = cmd_int();
            if (n <= 0)
                n = sc_height - 1;
            forward(n, 1);
            break;

        case 'b':
        case CONTROL('B'):
            /*
             * Backward one screen.
             */
            n = cmd_int();
            if (n <= 0)
                n = sc_height - 1;
            backward(n, 1);
            break;

        case 'e':
        case 'j':
        case '\r':
        case '\n':
        case CONTROL('E'):
            /*
             * Forward N (default 1) line.
             */
            n = cmd_int();
            if (n <= 0)
                n = 1;
            forward(n, 0);
            break;

        case 'y':
        case 'k':
        case CONTROL('K'):
        case CONTROL('Y'):
            /*
             * Backward N (default 1) line.
             */
            n = cmd_int();
            if (n <= 0)
                n = 1;
            backward(n, 0);
            break;

        case 'd':
        case CONTROL('D'):
            /*
             * Forward N lines
             * (default same as last 'd' or 'u' command).
             */
            n = cmd_int();
            if (n > 0)
                scroll = n;
            forward(scroll, 0);
            break;

        case 'u':
        case CONTROL('U'):
            /*
             * Forward N lines
             * (default same as last 'd' or 'u' command).
             */
            n = cmd_int();
            if (n > 0)
                scroll = n;
            backward(scroll, 0);
            break;

        case 'R':
            /*
             * Flush buffers, then repaint screen.
             */
            ch_init(0);
            /* Fall thru */
        case 'r':
        case CONTROL('R'):
        case CONTROL('L'):
            /*
             * Repaint screen.
             */
            repaint();
            break;

        case 'g':
            /*
             * Go to line N, default beginning of file.
             */
            n = cmd_int();
            if (n <= 0)
                n = 1;
            cmd_exec();
            jump_back(n);
            break;

        case 'p':
        case '%':
            /*
             * Go to a specified percentage into the file.
             */
            n = cmd_int();
            if (n < 0)
                n = 0;
            if (n > 100)
                n = 100;
            cmd_exec();
            jump_percent(n);
            break;

        case 'G':
            /*
             * Go to line N, default end of file.
             */
            n = cmd_int();
            cmd_exec();
            if (n <= 0)
                jump_forw();
            else
                jump_back(n);
            break;

        case '=':
        case CONTROL('G'):
            /*
             * Print file name, etc.
             */
            error(eq_message());
            break;

        case 'V':
            /*
             * Print version number, without the "@(#)".
             */
            error(version+4);
            break;

        case 'q':
            /*
             * Exit.
             */
            return;

        case '/':
        case '?':
            /*
             * Search for a pattern.
             * Accept chars of the pattern until \n.
             */
            n = cmd_int();
            if (n <= 0)
                n = 1;
            mcc = last_mcc = c;
            start_mcc();
            c = getcc();
            goto again;

        case 'n':
            /*
             * Repeat previous search.
             */
            n = cmd_int();
            if (n <= 0)
                n = 1;
            mcc = last_mcc;
            start_mcc();
            cmd_exec();
            search(mcc, (char *)NULL, n);
            mcc = 0;
            break;

        case 'h':
            /*
             * Help.
             */
            help();
            repaint();
            break;

        case 'E':
            /*
             * Edit a new file.  Get the filename.
             */
            cmd_reset();
            mcc = 'E';
            start_mcc();
            puts("dit: ");    /* This looks nicer */
            cmd_col += 5;
            c = getcc();
            goto again;

#if SHELL_ESCAPE
        case '!':
            /*
             * Shell escape.
             */
            cmd_reset();
            mcc = '!';
            start_mcc();
            c = getcc();
            goto again;
#endif

#if EDITOR
        case 'v':
            if (ispipe)
            {
                error("Cannot edit standard input");
                break;
            }
            sprintf(cmdbuf, "%s %s", editor, current_file);
            lsystem(cmdbuf);
            first_cmd = "R";
            break;
#endif

        case 'N':
            /*
             * Examine next file.
             */
            n = cmd_int();
            if (n <= 0)
                n = 1;
            next_file(n);
            break;

        case 'P':
            /*
             * Examine previous file.
             */
            n = cmd_int();
            if (n <= 0)
                n = 1;
            prev_file(n);
            break;

        case '-':
            /*
             * Toggle a flag setting.
             */
            mcc = '-';
            start_mcc();
            c = getcc();
            mcc = 0;
            if (c == erase_char || c == kill_char)
                break;
            toggle_option(c);
            break;

        case 'm':
            /*
             * Set a mark.
             */
            lower_left();
            clear_eol();
            puts("mark: ");
            c = getcc();
            if (c == erase_char || c == kill_char)
                break;
            setmark(c);
            break;

        case '\'':
            /*
             * Go to a mark.
             */
            lower_left();
            clear_eol();
            puts("goto mark: ");
            c = getcc();
            if (c == erase_char || c == kill_char)
                break;
            gomark(c);
            break;

        default:
            bell();
            break;
        }
    }
}
SHAR_EOF
echo shar: extracting version.c
cat - << \SHAR_EOF > version.c
/*
 *        less
 *    Copyright (c) 1984,1985  Mark Nudelman
 *
 *    This program may be freely used and/or modified,
 *    with the following provisions:
 *    1. This notice and the above copyright notice must remain intact.
 *    2. Neither this program, nor any modification of it,
 *       may not be sold for profit without written consent of the author.
 *
 *    -----------------------------------------------------------------
 *
 *    This program is a paginator similar to "more",
 *    but allows you to move both forward and backward in the file.
 *    Commands are based on "more" and "vi".
 *
 *    ----------------------- CHANGES ---------------------------------
 *
 *        Allowed use on standard input        1/29/84   markn
 *        Added E, N, P commands            2/1/84    markn
 *        Added '=' command, 'stop' signal handling    4/17/84   markn
 *        Added line folding                4/20/84   markn
 *    v2: Fixed '=' command to use BOTTOM_PLUS_ONE,
 *        instead of TOP, added 'p' & 'v' commands    4/27/84   markn
 *    v3: Added -m and -t options, '-' command    5/3/84    markn
 *    v4: Added LESS environment variable        5/3/84    markn
 *    v5: New comments, fixed '-' command slightly    5/3/84    markn
 *    v6: Added -Q, visual bell            5/15/84   markn
 *    v7: Fixed jump_back(n) bug: n should count real
 *        lines, not folded lines.  Also allow number
 *        on G command.                5/24/84   markn
 *    v8: Re-do -q and -Q commands            5/30/84   markn
 *    v9: Added "+<cmd>" argument            9/25/84   markn
 *    v10: Fixed bug in -b<n> argument processing    10/10/84  markn
 *    v11: Made error() ring bell if \n not entered.    10/18/84  markn
 *    -----------------------------------------------------------------
 *    v12: Reorganized signal handling and made
 *         portable to 4.2bsd.            2/13/85   mark
 *    v13: Reword error message for '-' command.    2/16/85   mark
 *    v14: Added -bf and -bp variants of -b.        2/22/85   mark
 *    v15: Miscellaneous changes.            2/25/85   mark
 *    v16: Added -u flag for backspace processing.    3/13/85   mark
 *    v17: Added j and k commands,
 *        changed -t default.            4/13/85   mark
 *    v18: Rewrote signal handling code.        4/20/85   mark
 *    v19: Got rid of "verbose" eq_message().        5/2/85    mark
 *         Made search() scroll in some cases.
 *    v20: Fixed screen.c ioctls for System V.    5/21/85   mark
 *    v21: Fixed some first_cmd bugs.            5/23/85   mark
 *    v22: Added support for no RECOMP nor REGCMP.    5/24/85   mark
 *    v23: Miscellanous changes and prettying up.    5/25/85   mark
 *      v24: Added ti,te terminal init & de-init       6/3/85 Mike Kersenbrock
 *    v25: Added -U flag, standout mode underlining.    6/8/85    mark
 *    v26: Added -M flag.                6/9/85    mark
 *         Use underline termcap (us) if it exists.
 *    v27: Renamed some variables to make unique in    6/15/85   mark
 *         6 chars.  Minor fix to -m.
 *    v28: Fixed right margin bug.            6/28/85   mark
 *    v29: Incorporated M.Rose's changes to signal.c    6/28/85   mark
 *    v30: Fixed stupid bug in argument processing.    6/29/85   mark
 *    v31: Added -p flag, changed repaint algorithm.  7/15/85   mark
 *         Added kludge for magic cookie terminals.
 *    v32: Added cat_file if output not a tty.    7/16/85   mark
 *    v33: Added -e flag and EDITOR.            7/23/85   mark
 *    v34: Added -s flag.                7/26/85   mark
 *    v35: Rewrote option handling; added option.c.    7/27/85   mark
 *    v36: Fixed -e flag to work if not last file.    7/29/85   mark
 *    v37: Added -x flag.                8/10/85   mark
 *    v38: Changed prompting; created prompt.c.    8/19/85   mark
 *    v39: (Not -p) does not initially clear screen.    8/24/85   mark
 *    v40: Added "skipping" indicator in forw().    8/26/85   mark
 *    v41: ONLY_RETURN, control char commands,    9/17/85   mark
 *         faster search, other minor fixes.
 *    v42: Added ++ command line syntax;        9/25/85   mark
 *         ch_fsize for pipes.
 *    v43: Added -h flag, changed prim.c algorithms.    10/15/85  mark
 *    v44: Made END print in all cases of eof;    10/16/85  mark
 *         ignore SIGTTOU after receiving SIGTSTP.
 *    v45: Never print backspaces unless -u.        10/16/85  mark
 *    v46: Backwards scroll in jump_loc.        10/24/85  mark
 *    v47: Fixed bug in edit(): *first_cmd==0        10/30/85  mark
 *    v48: Use TIOCSETN instead of TIOCSETP.        11/16/85  mark
 *         Added marks (m and ' commands).
 *    -----------------------------------------------------------------
 */

char version[] = "@(#) less  version 48";
SHAR_EOF