summaryrefslogtreecommitdiff
path: root/Src/Zle/zle_refresh.c
diff options
context:
space:
mode:
Diffstat (limited to 'Src/Zle/zle_refresh.c')
-rw-r--r--Src/Zle/zle_refresh.c1116
1 files changed, 1116 insertions, 0 deletions
diff --git a/Src/Zle/zle_refresh.c b/Src/Zle/zle_refresh.c
new file mode 100644
index 000000000..4621b5124
--- /dev/null
+++ b/Src/Zle/zle_refresh.c
@@ -0,0 +1,1116 @@
+/*
+ * zle_refresh.c - screen update
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1992-1997 Paul Falstad
+ * All rights reserved.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and to distribute modified versions of this software for any
+ * purpose, provided that the above copyright notice and the following
+ * two paragraphs appear in all copies of this software.
+ *
+ * In no event shall Paul Falstad or the Zsh Development Group be liable
+ * to any party for direct, indirect, special, incidental, or consequential
+ * damages arising out of the use of this software and its documentation,
+ * even if Paul Falstad and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Paul Falstad and the Zsh Development Group specifically disclaim any
+ * warranties, including, but not limited to, the implied warranties of
+ * merchantability and fitness for a particular purpose. The software
+ * provided hereunder is on an "as is" basis, and Paul Falstad and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#include "zle.mdh"
+#include "zle_refresh.pro"
+
+/* Expanded prompts */
+
+/**/
+char *lpptbuf, *rpptbuf;
+
+/* Text attributes after displaying prompts */
+
+/**/
+unsigned pmpt_attr, rpmpt_attr;
+
+/* number of lines displayed */
+
+/**/
+int nlnct;
+
+/* Most lines of the buffer we've shown at once with the current list *
+ * showing. == 0 if there is no list. == -1 if a new list has just *
+ * been put on the screen. == -2 if refresh() needs to put up a new *
+ * list. */
+
+/**/
+int showinglist;
+
+/* Non-zero if ALWAYS_LAST_PROMPT has been used, meaning that the *
+ * screen below the buffer display should not be cleared by *
+ * refresh(), but should be by trashzle(). */
+
+/**/
+int clearflag;
+
+#ifdef HAVE_SELECT
+/* cost of last update */
+/**/
+int cost;
+
+# define SELECT_ADD_COST(X) cost += X
+# define zputc(a, b) putc(a, b), cost++
+# define zwrite(a, b, c, d) fwrite(a, b, c, d), cost += (b * c)
+#else
+# define SELECT_ADD_COST(X)
+# define zputc(a, b) putc(a, b)
+# define zwrite(a, b, c, d) fwrite(a, b, c, d)
+#endif
+
+/* Oct/Nov 94: <mason> some code savagely redesigned to fix several bugs -
+ refreshline() & tc_rightcurs() majorly rewritten; refresh() fixed -
+ I've put my fingers into just about every routine in here -
+ any queries about updates to mason@werple.net.au */
+
+static char **nbuf = NULL, /* new video buffer line-by-line char array */
+ **obuf = NULL; /* old video buffer line-by-line char array */
+static int more_start, /* more text before start of screen? */
+ more_end, /* more stuff after end of screen? */
+ lppth, /* lines taken up by the prompt */
+ olnct, /* previous number of lines */
+ ovln, /* previous video cursor position line */
+ pptw, rpw, /* prompt widths on screen */
+ rppth, /* right prompt height */
+ vcs, vln, /* video cursor position column & line */
+ vmaxln, /* video maximum number of lines */
+ winw, winh, rwinh, /* window width & height */
+ winpos; /* singlelinezle: line's position in window */
+
+/**/
+void
+resetvideo(void)
+{
+ int ln;
+ static int lwinw = -1, lwinh = -1; /* last window width & height */
+
+ genprompts();
+ winw = columns; /* terminal width */
+ if (termflags & TERM_SHORT)
+ winh = 1;
+ else
+ winh = (lines < 2) ? 24 : lines;
+ rwinh = lines; /* keep the real number of lines */
+ winpos = vln = vmaxln = 0;
+ if (lwinw != winw || lwinh != winh) {
+ if (nbuf) {
+ for (ln = 0; ln != lwinh; ln++) {
+ zfree(nbuf[ln], lwinw + 2);
+ zfree(obuf[ln], lwinw + 2);
+ }
+ free(nbuf);
+ free(obuf);
+ }
+ nbuf = (char **)zcalloc((winh + 1) * sizeof(char *));
+ obuf = (char **)zcalloc((winh + 1) * sizeof(char *));
+ nbuf[0] = (char *)zalloc(winw + 2);
+ obuf[0] = (char *)zalloc(winw + 2);
+
+ lwinw = winw;
+ lwinh = winh;
+ }
+ for (ln = 0; ln != winh + 1; ln++) {
+ if (nbuf[ln])
+ *nbuf[ln] = '\0';
+ if (obuf[ln])
+ *obuf[ln] = '\0';
+ }
+
+ if (pptw) {
+ memset(nbuf[0], ' ', pptw);
+ memset(obuf[0], ' ', pptw);
+ nbuf[0][pptw] = obuf[0][pptw] = '\0';
+ }
+
+ vcs = pptw;
+ olnct = nlnct = 0;
+ if (showinglist > 0)
+ showinglist = -2;
+}
+
+/*
+ * Nov 96: <mason> changed to single line scroll
+ */
+
+/**/
+static void
+scrollwindow(int tline)
+{
+ int t0;
+ char *s;
+
+ s = nbuf[tline];
+ for (t0 = tline; t0 < winh - 1; t0++)
+ nbuf[t0] = nbuf[t0 + 1];
+ nbuf[winh - 1] = s;
+ if (!tline)
+ more_start = 1;
+ return;
+}
+
+/* this is the messy part. */
+/* this define belongs where it's used!!! */
+
+#define nextline \
+{ \
+ *s = '\0'; \
+ if (ln != winh - 1) \
+ ln++; \
+ else { \
+ if (!canscroll) { \
+ if (nvln != -1 && nvln != winh - 1 \
+ && (numscrolls != onumscrolls - 1 \
+ || nvln <= winh / 2)) \
+ break; \
+ numscrolls++; \
+ canscroll = winh / 2; \
+ } \
+ canscroll--; \
+ scrollwindow(0); \
+ if (nvln != -1) \
+ nvln--; \
+ } \
+ if (!nbuf[ln]) \
+ nbuf[ln] = (char *)zalloc(winw + 2); \
+ s = (unsigned char *)nbuf[ln]; \
+ sen = s + winw; \
+}
+
+#define snextline \
+{ \
+ *s = '\0'; \
+ if (ln != winh - 1) \
+ ln++; \
+ else \
+ if (tosln < 3) { \
+ more_status = 1; \
+ scrollwindow(tosln + 1); \
+ } else if (tosln - 1 <= nvln) { \
+ scrollwindow(0); \
+ if (nvln) \
+ nvln--, tosln--; \
+ } else { \
+ tosln--; \
+ scrollwindow(tosln); \
+ } \
+ if (!nbuf[ln]) \
+ nbuf[ln] = (char *)zalloc(winw + 2); \
+ s = (unsigned char *)nbuf[ln]; \
+ sen = s + winw; \
+}
+
+static int cleareol, /* clear to end-of-line (if can't cleareod) */
+ clearf, /* alwayslastprompt used immediately before */
+ put_rpmpt, /* whether we should display right-prompt */
+ oput_rpmpt, /* whether displayed right-prompt last time */
+ oxtabs, /* oxtabs - tabs expand to spaces if set */
+ numscrolls, onumscrolls;
+
+/**/
+void
+refresh(void)
+{
+ static int inlist; /* avoiding recursion */
+ int canscroll = 0, /* number of lines we are allowed to scroll */
+ ln = 0, /* current line we're working on */
+ more_status = 0, /* more stuff in status line */
+ nvcs = 0, nvln = -1, /* video cursor column and line */
+ t0 = -1, /* tmp */
+ tosln = 0; /* tmp in statusline stuff */
+ unsigned char *s, /* pointer into the video buffer */
+ *t, /* pointer into the real buffer */
+ *sen, /* pointer to end of the video buffer (eol) */
+ *scs; /* pointer to cursor position in real buffer */
+ char **qbuf; /* tmp */
+
+ /* If this is called from listmatches() (indirectly via trashzle()), and *
+ * that was called from the end of refresh(), then we don't need to do *
+ * anything. All this `inlist' code is actually unnecessary, but it *
+ * improves speed a little in a common case. */
+ if (inlist)
+ return;
+
+#ifdef HAVE_SELECT
+ cost = 0; /* reset */
+#endif
+
+/* Nov 96: <mason> I haven't checked how complete this is. sgtty stuff may
+ or may not work */
+ oxtabs = ((SGTTYFLAG & SGTABTYPE) == SGTABTYPE);
+
+ cleareol = 0; /* unset */
+ more_start = more_end = 0; /* unset */
+ if (isset(SINGLELINEZLE) || lines < 3
+ || (termflags & (TERM_NOUP | TERM_BAD | TERM_UNKNOWN)))
+ termflags |= TERM_SHORT;
+ else
+ termflags &= ~TERM_SHORT;
+ if (resetneeded) {
+ onumscrolls = 0;
+ setterm();
+#ifdef TIOCGWINSZ
+ if (winchanged) {
+ moveto(0, 0);
+ t0 = olnct; /* this is to clear extra lines even when */
+ winchanged = 0; /* the terminal cannot TCCLEAREOD */
+ }
+#endif
+ resetvideo();
+ resetneeded = 0; /* unset */
+ oput_rpmpt = 0; /* no right-prompt currently on screen */
+
+ /* we probably should only have explicitly set attributes */
+ tsetcap(TCALLATTRSOFF, 0);
+ tsetcap(TCSTANDOUTEND, 0);
+ tsetcap(TCUNDERLINEEND, 0);
+
+ if (!clearflag)
+ if (tccan(TCCLEAREOD))
+ tcout(TCCLEAREOD);
+ else
+ cleareol = 1; /* request: clear to end of line */
+ if (t0 > -1)
+ olnct = t0;
+ if (termflags & TERM_SHORT)
+ vcs = 0;
+ else if (!clearflag && lpptbuf[0])
+ zputs(lpptbuf, shout);
+ if (clearflag) {
+ zputc('\r', shout);
+ vcs = 0;
+ moveto(0, pptw);
+ }
+ fflush(shout);
+ clearf = clearflag;
+ } else if (winw != columns || rwinh != lines)
+ resetvideo();
+
+/* now winw equals columns and winh equals lines
+ width comparisons can be made with winw, height comparisons with winh */
+
+ if (termflags & TERM_SHORT) {
+ singlerefresh();
+ return;
+ }
+
+ if (cs < 0) {
+#ifdef DEBUG
+ fprintf(stderr, "BUG: negative cursor position\n");
+ fflush(stderr);
+#endif
+ cs = 0;
+ }
+ scs = line + cs;
+ numscrolls = 0;
+
+/* first, we generate the video line buffers so we know what to put on
+ the screen - also determine final cursor position (nvln, nvcs) */
+
+ /* Deemed necessary by PWS 1995/05/15 due to kill-line problems */
+ if (!*nbuf)
+ *nbuf = (char *)zalloc(winw + 2);
+
+ s = (unsigned char *)(nbuf[ln = 0] + pptw);
+ t = line;
+ sen = (unsigned char *)(*nbuf + winw);
+ for (; t < line+ll; t++) {
+ if (t == scs) /* if cursor is here, remember it */
+ nvcs = s - (unsigned char *)(nbuf[nvln = ln]);
+
+ if (*t == '\n') { /* newline */
+ nbuf[ln][winw + 1] = '\0'; /* text not wrapped */
+ nextline
+ } else if (*t == '\t') { /* tab */
+ t0 = (char *)s - nbuf[ln];
+ if ((t0 | 7) + 1 >= winw) {
+ nbuf[ln][winw + 1] = '\n'; /* text wrapped */
+ nextline
+ } else
+ do
+ *s++ = ' ';
+ while ((++t0) & 7);
+ } else if (icntrl(*t)) { /* other control character */
+ *s++ = '^';
+ if (s == sen) {
+ nbuf[ln][winw + 1] = '\n'; /* text wrapped */
+ nextline
+ }
+ *s++ = (*t == 127) ? '?' : (*t | '@');
+ } else /* normal character */
+ *s++ = *t;
+ if (s == sen) {
+ nbuf[ln][winw + 1] = '\n'; /* text wrapped */
+ nextline
+ }
+ }
+
+/* if we're really on the next line, don't fake it; do everything properly */
+ if (t == scs && (nvcs = s - (unsigned char *)(nbuf[nvln = ln])) == winw) {
+ nbuf[ln][winw + 1] = '\n'; /* text wrapped */
+ switch ('\0') { /* a sad hack to make the break */
+ case '\0': /* in nextline work */
+ nextline
+ }
+ *s = '\0';
+ nvcs = 0;
+ nvln++;
+ }
+
+ if (t != line + ll)
+ more_end = 1;
+
+ if (statusline) {
+ tosln = ln + 1;
+ if (ln == winh - 1) {
+ if (nvln > 0) {
+ scrollwindow(0);
+ nvln--;
+ }
+ tosln--;
+ }
+ nbuf[ln][winw + 1] = '\0'; /* text not wrapped */
+ snextline
+ t = (unsigned char *)statusline;
+ for (; t < (unsigned char *)statusline + statusll; t++) {
+ if (icntrl(*t)) { /* simplified processing in the status line */
+ *s++ = '^';
+ if (s == sen) {
+ nbuf[ln][winw + 1] = '\n'; /* text wrapped */
+ snextline
+ }
+ *s++ = (*t == 127) ? '?' : (*t | '@');
+ } else
+ *s++ = *t;
+ if (s == sen) {
+ nbuf[ln][winw + 1] = '\n'; /* text wrapped */
+ snextline
+ }
+ }
+ }
+
+/* insert <.... at end of last line if there is more text past end of screen */
+ if (more_end) {
+ if (!statusline)
+ tosln = winh;
+ strncpy(nbuf[tosln - 1] + winw - 7, " <.... ", 7);
+ nbuf[tosln - 1][winw] = nbuf[tosln - 1][winw + 1] = '\0';
+ }
+
+/* insert <....> at end of first status line if status is too big */
+ if (more_status) {
+ strncpy(nbuf[tosln] + winw - 8, " <....> ", 8);
+ nbuf[tosln][winw] = nbuf[tosln][winw + 1] = '\0';
+ }
+
+ *s = '\0';
+ nlnct = ln + 1;
+ for (ln = nlnct; ln < winh; ln++)
+ zfree(nbuf[ln], winw + 2), nbuf[ln] = NULL;
+
+/* determine whether the right-prompt exists and can fit on the screen */
+ if (!more_start)
+ put_rpmpt = rppth == 1 && rpptbuf[0] && !strchr(rpptbuf, '\t') &&
+ (int)strlen(nbuf[0]) + rpw < winw - 1;
+ else {
+/* insert >.... on first line if there is more text before start of screen */
+ memset(nbuf[0], ' ', pptw);
+ t0 = winw - pptw;
+ t0 = t0 > 5 ? 5 : t0;
+ strncpy(nbuf[0] + pptw, ">....", t0);
+ memset(nbuf[0] + pptw + t0, ' ', winw - t0 - pptw);
+ nbuf[0][winw] = nbuf[0][winw + 1] = '\0';
+ }
+
+ for (ln = 0; !clearf && (ln < nlnct); ln++) {
+ /* if we have more lines than last time, clear the newly-used lines */
+ if (ln >= olnct)
+ cleareol = 1;
+
+ /* if old line and new line are different,
+ see if we can insert/delete a line to speed up update */
+
+ if (ln < olnct - 1 && !(hasam && vcs == winw) &&
+ nbuf[ln] && obuf[ln] &&
+ strncmp(nbuf[ln], obuf[ln], 16)) {
+ if (tccan(TCDELLINE) && obuf[ln + 1] && obuf[ln + 1][0] &&
+ nbuf[ln] && !strncmp(nbuf[ln], obuf[ln + 1], 16)) {
+ moveto(ln, 0);
+ tcout(TCDELLINE);
+ zfree(obuf[ln], winw + 2);
+ for (t0 = ln; t0 != olnct; t0++)
+ obuf[t0] = obuf[t0 + 1];
+ obuf[--olnct] = NULL;
+ }
+ /* don't try to insert a line if olnct = vmaxln (vmaxln is the number
+ of lines that have been displayed by this routine) so that we don't
+ go off the end of the screen. */
+
+ else if (tccan(TCINSLINE) && olnct < vmaxln && nbuf[ln + 1] &&
+ obuf[ln] && !strncmp(nbuf[ln + 1], obuf[ln], 16)) {
+ moveto(ln, 0);
+ tcout(TCINSLINE);
+ for (t0 = olnct; t0 != ln; t0--)
+ obuf[t0] = obuf[t0 - 1];
+ obuf[ln] = NULL;
+ olnct++;
+ }
+ }
+
+ /* update the single line */
+ refreshline(ln);
+
+ /* output the right-prompt if appropriate */
+ if (put_rpmpt && !ln && !oput_rpmpt) {
+ moveto(0, winw - 1 - rpw);
+ zputs(rpptbuf, shout);
+ vcs = winw - 1;
+ /* reset character attributes to that set by the main prompt */
+ txtchange = pmpt_attr;
+ if (txtchangeisset(TXTNOBOLDFACE) && (rpmpt_attr & TXTBOLDFACE))
+ tsetcap(TCALLATTRSOFF, 0);
+ if (txtchangeisset(TXTNOSTANDOUT) && (rpmpt_attr & TXTSTANDOUT))
+ tsetcap(TCSTANDOUTEND, 0);
+ if (txtchangeisset(TXTNOUNDERLINE) && (rpmpt_attr & TXTUNDERLINE))
+ tsetcap(TCUNDERLINEEND, 0);
+ if (txtchangeisset(TXTBOLDFACE) && (rpmpt_attr & TXTNOBOLDFACE))
+ tsetcap(TCBOLDFACEBEG, 0);
+ if (txtchangeisset(TXTSTANDOUT) && (rpmpt_attr & TXTNOSTANDOUT))
+ tsetcap(TCSTANDOUTBEG, 0);
+ if (txtchangeisset(TXTUNDERLINE) && (rpmpt_attr & TXTNOUNDERLINE))
+ tsetcap(TCUNDERLINEBEG, 0);
+ }
+ }
+
+/* if old buffer had extra lines, set them to be cleared and refresh them
+individually */
+
+ if (olnct > nlnct) {
+ cleareol = 1;
+ for (ln = nlnct; ln < olnct; ln++)
+ refreshline(ln);
+ }
+
+/* reset character attributes */
+ if (clearf && postedit) {
+ if ((txtchange = pmpt_attr ? pmpt_attr : rpmpt_attr)) {
+ if (txtchangeisset(TXTNOBOLDFACE))
+ tsetcap(TCALLATTRSOFF, 0);
+ if (txtchangeisset(TXTNOSTANDOUT))
+ tsetcap(TCSTANDOUTEND, 0);
+ if (txtchangeisset(TXTNOUNDERLINE))
+ tsetcap(TCUNDERLINEEND, 0);
+ if (txtchangeisset(TXTBOLDFACE))
+ tsetcap(TCBOLDFACEBEG, 0);
+ if (txtchangeisset(TXTSTANDOUT))
+ tsetcap(TCSTANDOUTBEG, 0);
+ if (txtchangeisset(TXTUNDERLINE))
+ tsetcap(TCUNDERLINEBEG, 0);
+ }
+ }
+ clearf = 0;
+
+/* move to the new cursor position */
+ moveto(nvln, nvcs);
+
+/* swap old and new buffers - better than freeing/allocating every time */
+ qbuf = nbuf;
+ nbuf = obuf;
+ obuf = qbuf;
+/* store current values so we can use them next time */
+ ovln = nvln;
+ olnct = nlnct;
+ oput_rpmpt = put_rpmpt;
+ onumscrolls = numscrolls;
+ if (nlnct > vmaxln)
+ vmaxln = nlnct;
+ fflush(shout); /* make sure everything is written out */
+
+ /* if we have a new list showing, note it; if part of the list has been
+ overwritten, redisplay it. */
+ if (showinglist == -2 || (showinglist > 0 && showinglist < nlnct)) {
+ inlist = 1;
+ listmatches();
+ inlist = 0;
+ refresh();
+ }
+ if (showinglist == -1)
+ showinglist = nlnct;
+}
+
+#define tcinscost(X) (tccan(TCMULTINS) ? tclen[TCMULTINS] : (X)*tclen[TCINS])
+#define tcdelcost(X) (tccan(TCMULTDEL) ? tclen[TCMULTDEL] : (X)*tclen[TCDEL])
+#define tc_delchars(X) (void) tcmultout(TCDEL, TCMULTDEL, (X))
+#define tc_inschars(X) (void) tcmultout(TCINS, TCMULTINS, (X))
+#define tc_upcurs(X) (void) tcmultout(TCUP, TCMULTUP, (X))
+#define tc_leftcurs(X) (void) tcmultout(TCLEFT, TCMULTLEFT, (X))
+
+/* refresh one line, using whatever speed-up tricks are provided by the tty */
+
+/**/
+static void
+refreshline(int ln)
+{
+ char *nl, *ol, *p1; /* line buffer pointers */
+ int ccs = 0, /* temporary count for cursor position */
+ char_ins = 0, /* number of characters inserted/deleted */
+ col_cleareol, /* clear to end-of-line from this column */
+ i, j, /* tmp */
+ ins_last, /* insert pushed last character off line */
+ nllen, ollen, /* new and old line buffer lengths */
+ rnllen; /* real new line buffer length */
+
+/* 0: setup */
+ nl = nbuf[ln];
+ rnllen = nllen = nl ? strlen(nl) : 0;
+ ol = obuf[ln] ? obuf[ln] : "";
+ ollen = strlen(ol);
+
+/* optimisation: can easily happen for clearing old lines. If the terminal has
+ the capability, then this is the easiest way to skip unnecessary stuff */
+ if (cleareol && !nllen && !(hasam && ln < nlnct - 1)
+ && tccan(TCCLEAREOL)) {
+ moveto(ln, 0);
+ tcout(TCCLEAREOL);
+ return;
+ }
+
+/* 1: pad out the new buffer with spaces to contain _all_ of the characters
+ which need to be written. do this now to allow some pre-processing */
+
+ if (cleareol /* request to clear to end of line */
+ || !nllen /* no line buffer given */
+ || (ln == 0 && (put_rpmpt != oput_rpmpt))) { /* prompt changed */
+ p1 = halloc(winw + 2);
+ if (nllen)
+ strncpy(p1, nl, nllen);
+ memset(p1 + nllen, ' ', winw - nllen);
+ p1[winw] = '\0';
+ p1[winw + 1] = (nllen < winw) ? '\0' : nl[winw + 1];
+ if (ln && nbuf[ln])
+ memcpy(nl, p1, winw + 2); /* next time obuf will be up-to-date */
+ else
+ nl = p1; /* don't keep the padding for prompt line */
+ nllen = winw;
+ } else if (ollen > nllen) { /* make new line at least as long as old */
+ p1 = halloc(ollen + 1);
+ strncpy(p1, nl, nllen);
+ memset(p1 + nllen, ' ', ollen - nllen);
+ p1[ollen] = '\0';
+ nl = p1;
+ nllen = ollen;
+ }
+
+/* 2: see if we can clear to end-of-line, and if it's faster, work out where
+ to do it from - we can normally only do so if there's no right-prompt.
+ With automatic margins, we shouldn't do it if there is another line, in
+ case it messes up cut and paste. */
+
+ if (hasam && ln < nlnct - 1 && rnllen == winw)
+ col_cleareol = -2; /* clearing eol would be evil so don't */
+ else {
+ col_cleareol = -1;
+ if (tccan(TCCLEAREOL) && (nllen == winw || put_rpmpt != oput_rpmpt)) {
+ for (i = nllen; i && nl[i - 1] == ' '; i--);
+ for (j = ollen; j && ol[j - 1] == ' '; j--);
+ if ((j > i + tclen[TCCLEAREOL]) /* new buf has enough spaces */
+ || (nllen == winw && nl[winw - 1] == ' '))
+ col_cleareol = i;
+ }
+ }
+
+/* 2b: first a new trick for automargin niceness - good for cut and paste */
+
+ if (hasam && vcs == winw) {
+ if (nbuf[vln] && nbuf[vln][vcs + 1] == '\n') {
+ vln++, vcs = 1;
+ if (nbuf[vln] && *nbuf[vln])
+ zputc(*nbuf[vln], shout);
+ else
+ zputc(' ', shout); /* I don't think this should happen */
+ if (ln == vln) { /* better safe than sorry */
+ nl++;
+ if (*ol)
+ ol++;
+ ccs = 1;
+ } /* else hmmm... I wonder what happened */
+ } else {
+ vln++, vcs = 0;
+ zputc('\n', shout);
+ }
+ }
+ ins_last = 0;
+
+/* 2c: if we're on the first line, start checking at the end of the prompt;
+ we shouldn't be doing anything within the prompt */
+
+ if (ln == 0 && pptw) {
+ i = pptw - ccs;
+ j = strlen(ol);
+ nl += i;
+ ol += (i > j ? j : i); /* if ol is too short, point it to '\0' */
+ ccs = pptw;
+ }
+
+/* 3: main display loop - write out the buffer using whatever tricks we can */
+
+ for (;;) {
+ if (*nl && *ol && nl[1] == ol[1]) /* skip only if second chars match */
+ /* skip past all matching characters */
+ for (; *nl && (*nl == *ol); nl++, ol++, ccs++) ;
+
+ if (!*nl) {
+ if (ccs == winw && hasam && char_ins > 0 && ins_last
+ && vcs != winw) {
+ nl--; /* we can assume we can go back here */
+ moveto(ln, winw - 1);
+ zputc(*nl, shout);
+ vcs++;
+ return; /* write last character in line */
+ }
+ if ((char_ins <= 0) || (ccs >= winw)) /* written everything */
+ return;
+ if (tccan(TCCLEAREOL) && (char_ins >= tclen[TCCLEAREOL])
+ && col_cleareol != -2)
+ /* we've got junk on the right yet to clear */
+ col_cleareol = 0; /* force a clear to end of line */
+ }
+
+ moveto(ln, ccs); /* move to where we do all output from */
+
+ /* if we can finish quickly, do so */
+ if ((col_cleareol >= 0) && (ccs >= col_cleareol)) {
+ tcout(TCCLEAREOL);
+ return;
+ }
+
+ /* we've written out the new but yet to clear rubbish due to inserts */
+ if (!*nl) {
+ i = (winw - ccs < char_ins) ? (winw - ccs) : char_ins;
+ if (tccan(TCDEL) && (tcdelcost(i) <= i + 1))
+ tc_delchars(i);
+ else {
+ vcs += i;
+ while (i-- > 0)
+ zputc(' ', shout);
+ }
+ return;
+ }
+
+ /* if we've reached the end of the old buffer, then there are few tricks
+ we can do, so we just dump out what we must and clear if we can */
+ if (!*ol) {
+ i = (col_cleareol >= 0) ? col_cleareol : nllen;
+ i -= vcs;
+ zwrite(nl, i, 1, shout);
+ vcs += i;
+ if (col_cleareol >= 0)
+ tcout(TCCLEAREOL);
+ return;
+ }
+
+ /* inserting & deleting chars: we can if there's no right-prompt */
+ if ((ln || !put_rpmpt || !oput_rpmpt)
+ && (nl[1] && ol[1] && nl[1] != ol[1])) {
+
+ /* deleting characters - see if we can find a match series that
+ makes it cheaper to delete intermediate characters
+ eg. oldline: hifoobar \ hopefully cheaper here to delete two
+ newline: foobar / characters, then we have six matches */
+ if (tccan(TCDEL)) {
+ for (i = 1; *(ol + i); i++)
+ if (tcdelcost(i) < pfxlen(ol + i, nl)) {
+ tc_delchars(i);
+ ol += i;
+ char_ins -= i;
+ i = 0;
+ break;
+ }
+ if (!i)
+ continue;
+ }
+ /* inserting characters - characters pushed off the right should be
+ annihilated, but we don't do this if we're on the last line lest
+ undesired scrolling occurs due to `illegal' characters on screen */
+
+ if (tccan(TCINS) && (vln != lines - 1)) { /* not on last line */
+ for (i = 1; *(nl + i); i++)
+ if (tcinscost(i) < pfxlen(nl + i, ol)) {
+ tc_inschars(i);
+ zwrite(nl, i, 1, shout);
+ nl += i;
+ char_ins += i;
+ ccs = (vcs += i);
+ /* if we've pushed off the right, truncate oldline */
+ for (i = 0; *(ol + i) && i < winw - ccs; i++);
+ if (i == winw - ccs) {
+ *(ol + i) = '\0';
+ ins_last = 1;
+ }
+ i = 0;
+ break;
+ }
+ if (!i)
+ continue;
+ }
+ }
+ /* we can't do any fancy tricks, so just dump the single character
+ and keep on trying */
+ zputc(*nl, shout);
+ nl++, ol++;
+ ccs++, vcs++;
+ }
+}
+
+/* move the cursor to line ln (relative to the prompt line),
+ absolute column cl; update vln, vcs - video line and column */
+
+/**/
+void
+moveto(int ln, int cl)
+{
+ int c;
+
+ if (vcs == winw) {
+ vln++, vcs = 0;
+ if (!hasam) {
+ zputc('\r', shout);
+ zputc('\n', shout);
+ } else {
+ if ((vln < nlnct) && nbuf[vln] && *nbuf[vln])
+ c = *nbuf[vln];
+ else
+ c = ' ';
+ zputc(c, shout);
+ zputc('\r', shout);
+ if ((vln < olnct) && obuf[vln] && *obuf[vln])
+ *obuf[vln] = c;
+ }
+ }
+
+ if (ln == vln && cl == vcs)
+ return;
+
+/* move up */
+ if (ln < vln) {
+ tc_upcurs(vln - ln);
+ vln = ln;
+ }
+/* move down; if we might go off the end of the screen, use newlines
+ instead of TCDOWN */
+
+ while (ln > vln) {
+ if (vln < vmaxln - 1)
+ if (ln > vmaxln - 1) {
+ if (tc_downcurs(vmaxln - 1 - vln))
+ vcs = 0;
+ vln = vmaxln - 1;
+ } else {
+ if (tc_downcurs(ln - vln))
+ vcs = 0;
+ vln = ln;
+ continue;
+ }
+ zputc('\r', shout), vcs = 0; /* safety precaution */
+ while (ln > vln) {
+ zputc('\n', shout);
+ vln++;
+ }
+ }
+
+ if (cl == vcs)
+ return;
+
+/* choose cheapest movements for ttys without multiple movement capabilities -
+ do this now because it's easier (to code) */
+ if (cl <= vcs / 2) {
+ zputc('\r', shout);
+ vcs = 0;
+ }
+ if (vcs < cl)
+ tc_rightcurs(cl);
+ else if (vcs > cl)
+ tc_leftcurs(vcs - cl);
+ vcs = cl;
+}
+
+/**/
+int
+tcmultout(int cap, int multcap, int ct)
+{
+ if (tccan(multcap) && (!tccan(cap) || tclen[multcap] <= tclen[cap] * ct)) {
+ tcoutarg(multcap, ct);
+ return 1;
+ } else if (tccan(cap)) {
+ while (ct--)
+ tcout(cap);
+ return 1;
+ }
+ return 0;
+}
+
+/**/
+static void
+tc_rightcurs(int cl)
+{
+ int ct, /* number of characters to move across */
+ i = vcs, /* cursor position after initial movements */
+ j;
+ char *t;
+
+ ct = cl - vcs;
+
+/* do a multright if we can - it's the most reliable */
+ if (tccan(TCMULTRIGHT)) {
+ tcoutarg(TCMULTRIGHT, ct);
+ return;
+ }
+
+/* try tabs if tabs are non destructive and multright is not possible */
+ if (!oxtabs && tccan(TCNEXTTAB) && ((vcs | 7) < cl)) {
+ i = (vcs | 7) + 1;
+ tcout(TCNEXTTAB);
+ for ( ; i + 8 <= cl; i += 8)
+ tcout(TCNEXTTAB);
+ if ((ct = cl - i) == 0) /* number of chars still to move across */
+ return;
+ }
+
+/* otherwise _carefully_ write the contents of the video buffer.
+ if we're anywhere in the prompt, goto the left column and write the whole
+ prompt out unless ztrlen(lpptbuf) == pptw : we can cheat then */
+ if (vln == 0 && i < pptw) {
+ if (strlen(lpptbuf) == pptw)
+ fputs(lpptbuf + i, shout);
+ else if (tccan(TCRIGHT) && (tclen[TCRIGHT] * ct <= ztrlen(lpptbuf)))
+ /* it is cheaper to send TCRIGHT than reprint the whole prompt */
+ for (ct = pptw - i; ct--; )
+ tcout(TCRIGHT);
+ else {
+ if (i != 0)
+ zputc('\r', shout);
+ tc_upcurs(lppth - 1);
+ zputs(lpptbuf, shout);
+ }
+ i = pptw;
+ ct = cl - i;
+ }
+
+ if (nbuf[vln]) {
+ for (j = 0, t = nbuf[vln]; *t && (j < i); j++, t++);
+ if (j == i)
+ for ( ; *t && ct; ct--, t++)
+ zputc(*t, shout);
+ }
+ while (ct--)
+ zputc(' ', shout); /* not my fault your terminal can't go right */
+}
+
+/**/
+static int
+tc_downcurs(int ct)
+{
+ int ret = 0;
+
+ if (ct && !tcmultout(TCDOWN, TCMULTDOWN, ct)) {
+ while (ct--)
+ zputc('\n', shout);
+ zputc('\r', shout), ret = -1;
+ }
+ return ret;
+}
+
+/**/
+void
+tcout(int cap)
+{
+ tputs(tcstr[cap], 1, putshout);
+ SELECT_ADD_COST(tclen[cap]);
+}
+
+/**/
+static void
+tcoutarg(int cap, int arg)
+{
+ char *result;
+
+ result = tgoto(tcstr[cap], arg, arg);
+ tputs(result, 1, putshout);
+ SELECT_ADD_COST(strlen(result));
+}
+
+/**/
+void
+clearscreen(void)
+{
+ tcout(TCCLEARSCREEN);
+ resetneeded = 1;
+ clearflag = 0;
+}
+
+/**/
+void
+redisplay(void)
+{
+ moveto(0, 0);
+ zputc('\r', shout); /* extra care */
+ tc_upcurs(lppth - 1);
+ resetneeded = 1;
+ clearflag = 0;
+}
+
+/**/
+static void
+singlerefresh(void)
+{
+ char *vbuf, *vp, /* video buffer and pointer */
+ **qbuf, /* tmp */
+ *refreshop = *obuf; /* pointer to old video buffer */
+ int t0, /* tmp */
+ vsiz, /* size of new video buffer */
+ nvcs = 0; /* new video cursor column */
+
+ nlnct = 1;
+/* generate the new line buffer completely */
+ for (vsiz = 1 + pptw, t0 = 0; t0 != ll; t0++, vsiz++)
+ if (line[t0] == '\t')
+ vsiz = (vsiz | 7) + 1;
+ else if (icntrl(line[t0]))
+ vsiz++;
+ vbuf = (char *)zalloc(vsiz);
+
+ if (cs < 0) {
+#ifdef DEBUG
+ fprintf(stderr, "BUG: negative cursor position\n");
+ fflush(stderr);
+#endif
+ cs = 0;
+ }
+
+ memcpy(vbuf, strchr(lpptbuf, 0) - pptw, pptw); /* only use last part of prompt */
+ vbuf[pptw] = '\0';
+ vp = vbuf + pptw;
+
+ for (t0 = 0; t0 != ll; t0++) {
+ if (line[t0] == '\t')
+ for (*vp++ = ' '; (vp - vbuf) & 7; )
+ *vp++ = ' ';
+ else if (line[t0] == '\n') {
+ *vp++ = '\\';
+ *vp++ = 'n';
+ } else if (line[t0] == 0x7f) {
+ *vp++ = '^';
+ *vp++ = '?';
+ } else if (icntrl(line[t0])) {
+ *vp++ = '^';
+ *vp++ = line[t0] | '@';
+ } else
+ *vp++ = line[t0];
+ if (t0 == cs)
+ nvcs = vp - vbuf - 1;
+ }
+ if (t0 == cs)
+ nvcs = vp - vbuf;
+ *vp = '\0';
+
+/* determine which part of the new line buffer we want for the display */
+ if ((winpos && nvcs < winpos + 1) || (nvcs > winpos + winw - 2)) {
+ if ((winpos = nvcs - ((winw - hasam) / 2)) < 0)
+ winpos = 0;
+ }
+ if (winpos)
+ vbuf[winpos] = '<'; /* line continues to the left */
+ if ((int)strlen(vbuf + winpos) > (winw - hasam)) {
+ vbuf[winpos + winw - hasam - 1] = '>'; /* line continues to right */
+ vbuf[winpos + winw - hasam] = '\0';
+ }
+ strcpy(nbuf[0], vbuf + winpos);
+ zfree(vbuf, vsiz);
+ nvcs -= winpos;
+
+/* display the `visable' portion of the line buffer */
+ for (t0 = 0, vp = *nbuf;;) {
+ /* skip past all matching characters */
+ for (; *vp && *vp == *refreshop; t0++, vp++, refreshop++) ;
+
+ if (!*vp && !*refreshop)
+ break;
+
+ singmoveto(t0); /* move to where we do all output from */
+
+ if (!*refreshop) {
+ if ((t0 = strlen(vp)))
+ zwrite(vp, t0, 1, shout);
+ vcs += t0;
+ break;
+ }
+ if (!*vp) {
+ if (tccan(TCCLEAREOL))
+ tcout(TCCLEAREOL);
+ else
+ for (; *refreshop++; vcs++)
+ zputc(' ', shout);
+ break;
+ }
+ zputc(*vp, shout);
+ vcs++, t0++;
+ vp++, refreshop++;
+ }
+/* move to the new cursor position */
+ singmoveto(nvcs);
+
+ qbuf = nbuf;
+ nbuf = obuf;
+ obuf = qbuf;
+ fflush(shout); /* make sure everything is written out */
+}
+
+/**/
+static void
+singmoveto(int pos)
+{
+ if (pos == vcs)
+ return;
+ if (pos <= vcs / 2) {
+ zputc('\r', shout);
+ vcs = 0;
+ }
+ if (pos < vcs) {
+ tc_leftcurs(vcs - pos);
+ vcs = pos;
+ }
+ if (pos > vcs) {
+ if (tcmultout(TCRIGHT, TCMULTRIGHT, pos - vcs))
+ vcs = pos;
+ else
+ while (pos > vcs) {
+ zputc(nbuf[0][vcs], shout);
+ vcs++;
+ }
+ }
+}
+
+/* recheck size of prompts */
+
+/**/
+static void
+genprompts(void)
+{
+ countprompt(lpptbuf, &pptw, &lppth);
+ countprompt(rpptbuf, &rpw, &rppth);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-08 10:06:59 +0000