Typo's.

[minix3.git] / commands / yap / display.c

/* Copyright (c) 1985 Ceriel J.H. Jacobs */

# ifndef lint
static char rcsid[] = "$Header$";
# endif

# define _DISPLAY_

# include "in_all.h"
# include "display.h"
# include "assert.h"
# include "machine.h"
# include "term.h"
# include "output.h"
# include "options.h"
# include "process.h"
# include "getline.h"
# include "main.h"

STATIC char * do_line();

/*
 * Fill n lines of the screen, each with "str".
 */

STATIC VOID
fillscr(n,str) char *str; int n; {

        while (n-- > 0) {
                putline(str);
        }
}

/*
 * Skip "n" screenlines of line "p", and return what's left of it.
 */

STATIC char *
skiplines(p,n) char *p; int n; {

        while (n-- > 0) {
                p = do_line(p,0);
                scr_info.currentpos--;
        }
        return p;
}

/*
 * Redraw screen.
 * "n" = 1 if it is a real redraw, 0 if one page must be displayed.
 * It is also called when yap receives a stop signal.
 */

VOID
redraw(n) int n; {
        register struct scr_info *p = &scr_info;
        register int i;

        i = pagesize;
        if (n && p->currentpos) {
                i = p->currentpos;
        }
        (VOID) display(p->firstline,p->nf,i,1);
}

/*
 * Compute return value for the routines "display" and "scrollf".
 * This return value indicates wether we are at the end of file
 * or at the start, or both.
 * "s" contains that part of the last line that was not displayed.
 */

STATIC int
compretval(s) char *s; {
        register int i;
        register struct scr_info *p = &scr_info;

        i = 0;
        if (!s || (!*s && !getline(p->lastline+1, 1))) {
                i = EOFILE;
        }
        if (p->firstline == 1 && !p->nf) {
                i |= START;
        }
        status = i;
        return i;
}

/*
 * Display nlines, starting at line n, not displaying the first
 * nd screenlines of n.
 * If reallydispl = 0, the actual displaying is not performed,
 * only the computing associated with it is done.
 */

int
display(n,nd,nlines,reallydispl)
  long n; int nd; register int nlines; int reallydispl; {

        register struct scr_info *s = &scr_info;
        register char *p;       /* pointer to line to be displayed */

        if (startcomm)  {       /* No displaying on a command from the
                                 * yap command line. In this case, displaying
                                 * will be done after executing the command,
                                 * by a redraw.
                                 */
                reallydispl = 0;
        }
        if (!n) {
                n = 1L;
                nd = 0;
        }
        if (reallydispl) {      /* move cursor to starting point */
                if (stupid) {
                        putline(currentfile);
                        putline(", line ");
                        prnum(n);
                        nlines--;
                }
                if (cflag) {
                        putline("\r\n");
                }
                else {
                        home();
                        clrscreen();
                }
        }
        /*
         * Now, do computations and display
         */
        s->currentpos = 0;
        s->nf = nd;
        s->head = s->tail;
        s->tail->cnt = 0;
        s->tail->line = n;
        p = skiplines(getline(n,1),nd);
        while (nlines && p) {
                /*
                 * While there is room,
                 * and there is something left to display ...
                 */
                (s->tail->cnt)++;
                nlines--;
                if (*(p = do_line(p,reallydispl)) == '\0') {
                        /*
                         * File-line finished, get next one ...
                         */
                        p = getline(++n,1);
                        if (nlines && p) {
                                s->tail = s->tail->next;
                                s->tail->cnt = 0;
                                s->tail->line = n;
                        }
                }
        }
        if (!stupid) {
                s->currentpos += nlines;
                if (reallydispl) {
                        fillscr(nlines, "~\r\n");
                        fillscr(maxpagesize - s->currentpos, "\r\n");
                }
        }
        return compretval(p);
}

/*
 * Scroll forwards n lines.
 */

int
scrollf(n,reallydispl) int n; int reallydispl; {

        register struct scr_info *s = &scr_info;
        register char *p;
        register long ll;
        register int i;

        /*
         * First, find out how many screenlines of the last line were already
         * on the screen, and possibly above it.
         */

        if (n <= 0 || (status & EOFILE)) return status;
        if (startcomm) reallydispl = 0;
        /*
         * Find out where to begin displaying
         */
        i = s->tail->cnt;
        if ((ll = s->lastline) == s->firstline) i += s->nf;
        p = skiplines(getline(ll, 1), i);
        /*
         * Now, place the cursor at the first free line
         */
        if (reallydispl && !stupid) {
                clrbline();
                mgoto(s->currentpos);
        }
        /*
         * Now display lines, keeping track of which lines are on the screen.
         */
        while (n-- > 0) {       /* There are still rows to be displayed */
                if (!*p) {      /* End of line, get next one */
                        if (!(p = getline(++ll, 1))) {
                                /*
                                 * No lines left. At end of file
                                 */
                                break;
                        }
                        s->tail = s->tail->next;
                        s->tail->cnt = 0;
                        s->tail->line = ll;
                }
                if (s->currentpos >= maxpagesize) {
                        /*
                         * No room, delete first screen-line
                         */
                        s->currentpos--;
                        s->nf++;
                        if (--(s->head->cnt) == 0) {
                                /*
                                 * The first file-line on the screen is wiped
                                 * out completely; update administration
                                 * accordingly.
                                 */
                                s->nf = 0;
                                s->head = s->head->next;
                                assert(s->head->cnt > 0);
                        }
                }
                s->tail->cnt++;
                p = do_line(p, reallydispl);
        }
        return compretval(p);
}

/*
 * Scroll back n lines
 */

int
scrollb(n, reallydispl) int n, reallydispl; {

        register struct scr_info *s = &scr_info;
        register char *p;       /* Holds string to be displayed */
        register int i;
        register int count;
        register long ln;       /* a line number */
        register int nodispl;
        int cannotscroll;       /* stupid or no insert-line */

        /*
         * First, find out where to start
         */
        if ((count = n) <= 0 || (status & START)) return status;
        if (startcomm) reallydispl = 0;
        cannotscroll = stupid || (!*AL && !*SR);
        ln = s->firstline;
        nodispl = s->nf;
        while (count) { /* While scrolling back ... */
                if (i = nodispl) {
                        /*
                         * There were screen-lines of s->firstline that were not
                         * displayed.
                         * We can use them now, but only "count" of them.
                         */
                        if (i > count) i = count;
                        s->currentpos += i;
                        nodispl -= i;
                        count -= i;
                }
                else {  /* Get previous line */
                        if (ln == 1) break; /* isn't there ... */
                        p = getline(--ln, 1);
                        /*
                         * Make it the first line of the screen and compute
                         * how many screenlines it takes. These lines are not
                         * displayed, but nodispl is set to this count, so
                         * that it will be nonzero next time around
                         */
                        nodispl = 0;
                        do {    /* Find out how many screenlines */
                                nodispl++;
                                p = skiplines(p, 1);
                        } while (*p);
                }
        }
        n -= count;
        if ((i = s->currentpos) > maxpagesize) i = maxpagesize;
        if (reallydispl && hardcopy) i = n;
        /*
         * Now that we know where to start, we can use "display" to do the
         * rest of the computing for us, and maybe even the displaying ...
         */
        i = display(ln,
                    nodispl,
                    i,
                    reallydispl && cannotscroll);
        if (cannotscroll || !reallydispl) {
                /*
                 * Yes, "display" did the displaying, or we did'nt have to
                 * display at all.
                 * I like it, but the user obviously does not.
                 * Let him buy another (smarter) terminal ...
                 */
                return i;
        }
        /*
         * Now, all we have to do is the displaying. And we are dealing with
         * a smart terminal (it can insert lines or scroll back).
         */
        home();
        /*
         * Insert lines all at once
         */
        for (i = n; i; i--) {
                if (DB && *CE) {
                        /*
                         * Grumble..., terminal retains lines below, so we have
                         * to clear the lines that we push off the screen
                         */
                        clrbline();
                        home();
                }
                if (*SR) {
                        scrollreverse();
                }
                else {
# ifdef VT100_PATCH
                        insert_line(0);
# else
                        insert_line();
# endif
                }
        }
        p = skiplines(getline(ln = s->firstline, 1), s->nf);
        for (i = 0; i < n; i++) {
                p = do_line(p,1);
                s->currentpos--;
                if (!*p) {
                        p = getline(++ln, 1);
                }
        }
        return count;
}

/*
 * Process a line.
 * If reallydispl > 0 then display it.
 */

STATIC char *
do_line(str, reallydispl) register char *str; int reallydispl; {

        char buf[1024];
        register char *p = buf;
        register int pos = COLS;
        register int c;
        register int c1;
        register int do_ul = 0, do_hl = 0;
        int lastmode = 0, lasthlmode = 0;
        int c2;

        while (*str && pos > 0) {
                if (*str < ' ' && (c1 = match(str,&c2,sppat)) > 0) {
                        /*
                         * We found a string that matches, and thus must be
                         * echoed literally
                         */
                        if ((pos - c2) <= 0) {
                                /*
                                 * It did not fit
                                 */
                                break;
                        }
                        pos -= c2;
                        str += c1;
                        if (reallydispl) {
                                c = *str;
                                *p = *str = 0;
                                cputline(p = buf);
                                putline(str - c1);
                                *str = c;
                        }
                        continue;
                }
                c = *str++;
                do_hl = 0;
                if (*str == '\b' && *(str+1) != 0
                                        && (c != '_' || *(str+2) == '\b')) {
                        while (*str == '\b' && *(str+1) != 0) {
                                str++;
                                c = *str++;
                                do_hl = 1;
                        }
                }
                do_ul = 1;
                /*
                 * Find underline sequences ...
                 */
                if (c == '_' && *str == '\b') {
                        str++;
                        c = *str++;
                }
                else {
                        if (*str == '\b' && *(str+1) == '_') {
                                str += 2;
                        }
                        else    do_ul = 0;
                }
                if (reallydispl && do_hl != lasthlmode) {
                        *p = 0;
                        cputline(p = buf);
                        if (do_hl) bold();
                        else end_bold();
                }
                lasthlmode = do_hl;
                if (reallydispl && do_ul != lastmode) {
                        *p = 0;
                        cputline(p = buf);
                        if (do_ul) underline();
                        else end_underline();
                }
                lastmode = do_ul;
                *p++ = c;
                if (c >= ' ' && c < 0177) {
                        pos--;
                        if (reallydispl && do_ul && *UC && pos > 0) {
                                /*
                                 * Underlining apparently is done one
                                 * character at a time.
                                 */
                                *p = 0;
                                cputline(p = buf);
                                backspace();
                                underchar();
                        }
                        continue;
                }
                if (c == '\t') {
                        p--;
                        c1 = 8 - ((COLS - pos) & 07);
                        /*
                         * Actually, if COLS is a multiple of 8, this can be
                         * simplified to
                         *     c1 = pos & 07;
                         * But of course, we don't know that for sure.
                         */
                        if (pos - c1 < 0) break;
                        pos -= c1;
                        if (reallydispl) {
                                if (expandtabs) {
                                        /*
                                         * Expand tabs. We cannot let the
                                         * kernel take care of this
                                         * for two reasons:
                                         * 1. There can be tabs in cursor
                                         *    addressing strings,
                                         * 2. We probably do it better.
                                         */
                                        while (c1-- > 0) {
                                                *p++ = ' ';
                                        }
                                }
                                else {
                                        *p = 0;
                                        cputline(p = buf);
                                        givetab();
                                }
                        }
                        continue;
                }
                /*
                 * Now we have a control character, which takes two positions
                 */
                if (pos <= 1) {
                        p--;
                        break;
                }
                pos -= 2;
        }
        if (reallydispl) {
                *p = 0;
                cputline(buf);
                if (pos > 0 || (pos <= 0 && (!AM || XN))) {
                        putline("\r\n");
                }
                /*
                 * The next should be here! I.e. it may not be before printing
                 * the newline. This has to do with XN. We don't know exactly
                 * WHEN the terminal will stop ignoring the newline.
                 * I have for example a terminal (Ampex a230) that will
                 * continue to ignore the newline after a clear to end of line
                 * sequence, but not after an end_underline sequence.
                 */
                if (do_ul) {
                        end_underline();
                }
                if (do_hl) {
                        standend();
                }
        }
        scr_info.currentpos++;
        return str;
}

/* ARGSUSED */
int
setmark(cnt) long cnt; {        /* Set a mark on the current page */
        register struct scr_info *p = &scr_info;

        p->savfirst = p->firstline;
        p->savnf = p->nf;
}

/* ARGSUSED */
int
tomark(cnt) long cnt; {         /* Go to the mark */
        register struct scr_info *p = &scr_info;

        (VOID) display(p->savfirst,p->savnf,pagesize,1);
}

/* ARGSUSED */
int
exgmark(cnt) long cnt; {        /* Exchange mark and current page */
        register struct scr_info *p = &scr_info;
        register long svfirst;
        register int svnf;

        svfirst = p->firstline;
        svnf = p->nf;
        tomark(0L);
        p->savfirst = svfirst;
        p->savnf = svnf;
}

VOID
d_clean() {                     /* Clean up */
        register struct scr_info *p = &scr_info;

        p->savnf = 0;
        p->savfirst = 0;
        p->head = p->tail;
        p->head->line = 0;
        p->currentpos = 0;
}