+/* Copyright (c) 1991
+ * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
+ * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
+ * Copyright (c) 1987 Oliver Laumann
+ * All rights reserved. Not derived from licensed software.
+ *
+ * Permission is granted to freely use, copy, modify, and redistribute
+ * this software, provided that no attempt is made to gain profit from it,
+ * the authors are not construed to be liable for any results of using the
+ * software, alterations are clearly marked as such, and this notice is
+ * not modified.
+ *
+ * Noteworthy contributors to screen's design and implementation:
+ * Wayne Davison (davison@borland.com)
+ * Patrick Wolfe (pat@kai.com, kailand!pat)
+ * Bart Schaefer (schaefer@cse.ogi.edu)
+ * Nathan Glasser (nathan@brokaw.lcs.mit.edu)
+ * Larry W. Virden (lwv27%cas.BITNET@CUNYVM.CUNY.Edu)
+ * Howard Chu (hyc@hanauma.jpl.nasa.gov)
+ * Tim MacKenzie (tym@dibbler.cs.monash.edu.au)
+ * Markku Jarvinen (mta@{cc,cs,ee}.tut.fi)
+ * Marc Boucher (marc@CAM.ORG)
+ *
+ ****************************************************************
+ */
+
+#ifndef lint
+ static char rcs_id[] = "$Id: ansi.c,v 1.2 92/02/03 02:27:30 jnweiger Exp $ FAU";
+#endif
+
+#include <stdio.h>
+#include <sys/types.h>
+#ifdef BSDI
+#include <sys/signal.h>
+#endif /* BSDI */
+#include <fcntl.h>
+#include "config.h"
+#include "screen.h"
+#include "ansi.h"
+#include "extern.h"
+#ifndef sun /* we want to know about TIOCGWINSZ. jw. */
+# include <sys/ioctl.h>
+#endif
+
+extern char *getenv(), *tgetstr(), *tgoto();
+#ifndef __STDC__
+extern char *malloc();
+#endif
+
+extern struct win *fore;
+extern int ForeNum;
+extern force_vt, assume_LP;
+extern int BellDisplayed;
+extern int MsgMinWait;
+extern int all_norefresh;
+
+int TermcapROWS, TermcapCOLS; /* defaults that we learned from termcap */
+int default_width, default_height; /* width/height a new window will get */
+
+int maxwidth;
+
+int Z0width, Z1width; /* widths for Z0/Z1 switching */
+
+char display_tty[MAXPATH];
+int screenwidth, screenheight; /* width/height of the screen */
+int screentop, screenbot; /* scrollregion start/end */
+int screenx, screeny; /* cursor position */
+char GlobalAttr; /* current attributes */
+char GlobalCharset; /* current font */
+int insert; /* insert mode */
+int keypad; /* application keypad */
+int flow = 1; /* flow control */
+
+int status; /* status is displayed */
+static int status_lastx, status_lasty;
+
+static int rows, cols; /* window size of the curr window */
+
+int default_flow = -1, wrap = 1, default_monitor = 0;
+int visual_bell = 0, termcapHS, use_hardstatus = 1;
+char *Termcap, *extra_incap, *extra_outcap;
+static int Termcaplen;
+char *blank, *null, *LastMsg;
+char Term[MAXSTR+5]; /* +5: "TERM=" */
+char screenterm[20] = "screen";
+char *Z0, *Z1;
+int ISO2022, HS;
+time_t TimeDisplayed, time();
+
+/*
+ * the termcap routines need this to work
+ */
+short ospeed;
+char *BC;
+char *UP;
+
+static void AddCap __P((char *));
+static void MakeString __P((char *, char *, int, char *));
+static int Special __P((int));
+static void DoESC __P((int, int ));
+static void DoCSI __P((int, int ));
+static void CPutStr __P((char *, int));
+static void SetChar __P(());
+static void StartString __P((enum string_t));
+static void AddChar __P((int ));
+static void PrintChar __P((int ));
+static void PrintFlush __P((void));
+static void KeypadMode __P((int));
+static void DesignateCharset __P((int, int ));
+static void MapCharset __P((int));
+static void SaveCursor __P((void));
+static void RestoreCursor __P((void));
+static void CountChars __P((int));
+static int CalcCost __P((char *));
+static int Rewrite __P((int, int, int, int));
+static void BackSpace __P((void));
+static void Return __P((void));
+static void LineFeed __P((int));
+static void ReverseLineFeed __P((void));
+static void InsertAChar __P((int));
+static void InsertChar __P((int));
+static void DeleteChar __P((int));
+static void DeleteLine __P((int));
+static void InsertLine __P((int));
+static void ScrollUpMap __P((int));
+static void ScrollDownMap __P((int));
+static void Scroll __P((char *, int, int, char *));
+static void ForwardTab __P((void));
+static void BackwardTab __P((void));
+static void ClearScreen __P((void));
+static void ClearFromBOS __P((void));
+static void ClearToEOS __P((void));
+static void ClearLine __P((void));
+static void ClearToEOL __P((void));
+static void ClearFromBOL __P((void));
+static void ClearInLine __P((int, int, int, int ));
+static void CursorRight __P(());
+static void CursorUp __P(());
+static void CursorDown __P(());
+static void CursorLeft __P(());
+static void ASetMode __P((int));
+static void SelectRendition __P((void));
+static void FillWithEs __P((void));
+static void RedisplayLine __P((char *, char *, char *, int, int, int ));
+static void FindAKA __P((void));
+static void SetCurr __P((struct win *));
+static void inpRedisplayLine __P((int, int, int, int));
+static void process_inp_input __P((char **, int *));
+static void AbortInp __P((void));
+static void AKAfin __P((char *, int));
+static void Colonfin __P((char *, int));
+static void RAW_PUTCHAR __P((int));
+static char *e_tgetstr __P((char *, char **));
+static int e_tgetflag __P((char *));
+static int e_tgetnum __P((char *));
+
+
+static char *tbuf, *tentry, *termname;
+static char *tp;
+static char *TI, *TE, *BL, *VB, *CR, *NL, *CL, *IS;
+char *WS; /* used in ResizeScreen() */
+char *CE; /* used in help.c */
+static char *CM, *US, *UE, *SO, *SE, *CD, *DO, *SR, *SF, *AL;
+static char *CS, *DL, *DC, *IC, *IM, *EI, *ND, *KS, *KE;
+static char *MB, *MD, *MH, *MR, *ME, *PO, *PF, *HO;
+static char *TS, *FS, *DS, *VI, *VE, *VS;
+static char *CDC, *CDL, *CAL, *CUP, *CDO, *CLE, *CRI, *CIC;
+static char *attrtab[NATTR];
+static AM, MS, COP;
+int LP;
+/*
+ * Do not confuse S0 (es-zero), E0 (e-zero) with SO (es-oh), PO (pe-oh),
+ * Z0 (z-zero), DO (de-oh)... :-)
+ */
+static char *C0, *S0, *E0;
+static char c0_tab[256];
+/*
+ */
+static screencap = 0;
+char *OldImage, *OldAttr, *OldFont;
+static struct win *curr;
+static display = 1;
+static StrCost;
+static UPcost, DOcost, LEcost, NDcost, CRcost, IMcost, EIcost, NLcost;
+static tcLineLen;
+static StatLen;
+static lp_missing = 0;
+
+int in_ovl;
+int ovl_blockfore;
+void (*ovl_process)();
+void (*ovl_RedisplayLine)();
+int (*ovl_Rewrite)();
+
+static char *KeyCaps[] =
+{
+ "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7", "k8", "k9",
+ "kb", "kd", "kh", "kl", "ko", "kr", "ku",
+ "K1", "K2", "K3", "K4", "K5",
+ "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7", "l8", "l9"
+};
+#define NKEYCAPS ((int)(sizeof(KeyCaps)/sizeof(*KeyCaps)))
+static char *KeyCapsArr[NKEYCAPS];
+
+static char TermcapConst[] = "\\\n\
+\t:DO=\\E[%dB:LE=\\E[%dD:RI=\\E[%dC:UP=\\E[%dA:bs:bt=\\E[Z:\\\n\
+\t:cd=\\E[J:ce=\\E[K:cl=\\E[H\\E[J:cm=\\E[%i%d;%dH:ct=\\E[3g:\\\n\
+\t:do=^J:nd=\\E[C:pt:rc=\\E8:rs=\\Ec:sc=\\E7:st=\\EH:up=\\EM:\\\n\
+\t:le=^H:bl=^G:cr=^M:it#8:ho=\\E[H:nw=\\EE:ta=^I:is=\\E)0:xv:";
+
+void
+InitTermcap()
+{
+ register char *s;
+ int i;
+
+ screencap = 0;
+ if ((s = getenv("SCREENCAP")) != 0)
+ {
+ if ((Termcap = malloc(strlen(s) + 10)) != 0)
+ {
+ sprintf(Termcap, "TERMCAP=%s", s);
+ screencap = 1;
+ }
+ }
+ else
+ Termcap = malloc((unsigned) 1024);
+ Termcaplen = 0;
+ tbuf = malloc((unsigned) 1024);
+ tentry = tp = malloc((unsigned) 1024);
+ if (!(Termcap && tbuf && tentry))
+ Msg_nomem;
+ bzero(tbuf, 1024);
+ if ((termname = getenv("TERM")) == 0)
+ Msg(0, "No TERM in environment.");
+ debug1("InitTermcap: looking for tgetent('%s');\n", termname);
+ if (tgetent(tbuf, termname) != 1)
+ Msg(0, "Cannot find termcap entry for %s.", termname);
+ debug1("got it:\n%s\n",tbuf);
+#ifdef DEBUG
+ if (extra_incap)
+ debug1("Extra incap: %s\n", extra_incap);
+ if (extra_outcap)
+ debug1("Extra outcap: %s\n", extra_outcap);
+#endif
+
+ TermcapCOLS = TermcapROWS = 0;
+ if (s = getenv("COLUMNS"))
+ TermcapCOLS = atoi(s);
+ if (TermcapCOLS <= 0)
+ TermcapCOLS = e_tgetnum("co");
+ if (TermcapCOLS <= 0)
+ TermcapCOLS = 80;
+ if (s = getenv("LINES"))
+ TermcapROWS = atoi(s);
+ if (TermcapROWS <= 0)
+ TermcapROWS = e_tgetnum("li");
+ if (TermcapROWS <= 0)
+ TermcapROWS = 24;
+
+ if (e_tgetflag("hc"))
+ Msg(0, "You can't run screen on a hardcopy terminal.");
+ if (e_tgetflag("os"))
+ Msg(0, "You can't run screen on a terminal that overstrikes.");
+ if (e_tgetflag("ns"))
+ Msg(0, "Terminal must support scrolling.");
+ if (!(CL = e_tgetstr("cl", &tp)))
+ Msg(0, "Clear screen capability required.");
+ if (!(CM = e_tgetstr("cm", &tp)))
+ Msg(0, "Addressable cursor capability required.");
+ if (default_flow < 0)
+ default_flow = e_tgetflag("NF") ? FLOW_NOW * 0 :
+ e_tgetflag("xo") ? FLOW_NOW * 1 :
+ FLOW_AUTOFLAG;
+ AM = e_tgetflag("am");
+ LP = assume_LP || (!extra_incap && !strncmp(termname, "vt", 2))
+ || !AM || e_tgetflag("LP") || e_tgetflag("xv");
+ COP = e_tgetflag("OP");
+ HO = e_tgetstr("ho", &tp);
+ TI = e_tgetstr("ti", &tp);
+ TE = e_tgetstr("te", &tp);
+ if (!(BL = e_tgetstr("bl", &tp)))
+ BL = "\007";
+ VB = e_tgetstr("vb", &tp);
+ if (!(BC = e_tgetstr("bc", &tp)))
+ {
+ if (e_tgetflag("bs"))
+ BC = "\b";
+ else
+ BC = e_tgetstr("le", &tp);
+ }
+ if (!(CR = e_tgetstr("cr", &tp)))
+ CR = "\r";
+ if (!(NL = e_tgetstr("nl", &tp)))
+ NL = "\n";
+ IS = e_tgetstr("is", &tp);
+ MS = 1;
+ if (e_tgetnum("sg") <= 0 && e_tgetnum("ug") <= 0)
+ {
+ MS = e_tgetflag("ms");
+ attrtab[ATTR_DI] = MH = e_tgetstr("mh", &tp); /* Dim */
+ attrtab[ATTR_US] = US = e_tgetstr("us", &tp); /* Underline */
+ attrtab[ATTR_BD] = MD = e_tgetstr("md", &tp); /* Bold */
+ attrtab[ATTR_RV] = MR = e_tgetstr("mr", &tp); /* Reverse */
+ attrtab[ATTR_SO] = SO = e_tgetstr("so", &tp); /* Standout */
+ attrtab[ATTR_BL] = MB = e_tgetstr("mb", &tp); /* Blinking */
+ ME = e_tgetstr("me", &tp);
+ SE = e_tgetstr("se", &tp);
+ UE = e_tgetstr("ue", &tp);
+ /*
+ * Does ME also reverse the effect of SO and/or US? This is not
+ * clearly specified by the termcap manual. Anyway, we should at
+ * least look whether ME and SE/UE are equal:
+ */
+ if (UE && ((SE && strcmp(SE, UE) == 0) || (ME && strcmp(ME, UE) == 0)))
+ UE = 0;
+ if (SE && (ME && strcmp(ME, SE) == 0))
+ SE = 0;
+
+ /* Set up missing entries */
+ s = 0;
+ for (i = NATTR-1; i >= 0; i--)
+ if (attrtab[i])
+ s = attrtab[i];
+ for (i = 0; i < NATTR; i++)
+ {
+ if (attrtab[i] == 0)
+ attrtab[i] = s;
+ else
+ s = attrtab[i];
+ }
+ }
+ else
+ {
+ US = UE = SO = SE = MB = MD = MH = MR = ME = 0;
+ for (i = 0; i < NATTR; i++)
+ attrtab[i] = 0;
+ }
+ CE = e_tgetstr("ce", &tp);
+ CD = e_tgetstr("cd", &tp);
+ if (!(DO = e_tgetstr("do", &tp)))
+ DO = NL;
+ UP = e_tgetstr("up", &tp);
+ ND = e_tgetstr("nd", &tp);
+ SR = e_tgetstr("sr", &tp);
+ if (!(SF = e_tgetstr("sf", &tp)))
+ SF = NL;
+ AL = e_tgetstr("al", &tp);
+ DL = e_tgetstr("dl", &tp);
+ CS = e_tgetstr("cs", &tp);
+ DC = e_tgetstr("dc", &tp);
+ IC = e_tgetstr("ic", &tp);
+ CIC = e_tgetstr("IC", &tp);
+ CDC = e_tgetstr("DC", &tp);
+ CDL = e_tgetstr("DL", &tp);
+ CAL = e_tgetstr("AL", &tp);
+ CUP = e_tgetstr("UP", &tp);
+ CDO = e_tgetstr("DO", &tp);
+ CLE = e_tgetstr("LE", &tp);
+ CRI = e_tgetstr("RI", &tp);
+ IM = e_tgetstr("im", &tp);
+ EI = e_tgetstr("ei", &tp);
+ if (e_tgetflag("in"))
+ IC = IM = 0;
+ if (IC && IC[0] == '\0')
+ IC = 0;
+ if (CIC && CIC[0] == '\0')
+ CIC = 0;
+ if (IM && IM[0] == '\0')
+ IM = 0;
+ if (EI && EI[0] == '\0')
+ EI = 0;
+ if (EI == 0)
+ IM = 0;
+ if (IC && IM && strcmp(IC, IM) == 0)
+ IC = 0;
+ KS = e_tgetstr("ks", &tp);
+ KE = e_tgetstr("ke", &tp);
+ if (KE == 0)
+ KS = 0;
+ ISO2022 = e_tgetflag("G0");
+ if (ISO2022)
+ {
+ if ((S0 = e_tgetstr("S0", &tp)) == NULL)
+#ifdef TERMINFO
+ S0 = "\033(%p1%c";
+#else
+ S0 = "\033(%.";
+#endif
+ if ((E0 = e_tgetstr("E0", &tp)) == NULL)
+ E0 = "\033(B";
+ C0 = e_tgetstr("C0", &tp);
+ }
+ else if ((S0 = e_tgetstr("as", &tp)) != NULL
+ && (E0 = e_tgetstr("ae", &tp)) != NULL)
+ {
+ ISO2022 = 1;
+ C0 = e_tgetstr("ac", &tp);
+ }
+ else
+ {
+ S0 = E0 = "";
+ C0 = "g.h.i'j-k-l-m-n+o~p\"q-r-s_t+u+v+w+x|y<z>";
+ }
+ for (i = 0; i < 256; i++)
+ c0_tab[i] = i;
+ if (C0)
+ for (i = strlen(C0)&~1; i >= 0; i-=2)
+ c0_tab[C0[i]] = C0[i+1];
+ debug1("ISO2022 = %d\n", ISO2022);
+ /* WS changes the window size */
+ WS = e_tgetstr("WS", &tp);
+ VI = e_tgetstr("vi", &tp);
+ VE = e_tgetstr("ve", &tp);
+ VS = e_tgetstr("vs", &tp);
+ PO = e_tgetstr("po", &tp);
+ if (!(PF = e_tgetstr("pf", &tp)))
+ PO = 0;
+ debug2("terminal size is %d, %d (says TERMCAP)\n", TermcapCOLS, TermcapROWS);
+ /* Termcap fields Z0 & Z1 contain width-changing sequences. */
+ if ((Z0 = e_tgetstr("Z0", &tp)) != NULL
+ && (Z1 = e_tgetstr("Z1", &tp)) == NULL)
+ Z0 = NULL;
+
+ Z0width = 132;
+ Z1width = 80;
+
+ CheckScreenSize(0);
+ if ((HS = e_tgetflag("hs")) != 0)
+ {
+ debug("oy! we have a hardware status line, says termcap\n");
+ TS = e_tgetstr("ts", &tp);
+ FS = e_tgetstr("fs", &tp);
+ DS = e_tgetstr("ds", &tp);
+ if ((HS = e_tgetnum("ws")) <= 0)
+ HS = screenwidth;
+ if (!TS || !FS || !DS)
+ HS = 0;
+ }
+ termcapHS = HS;
+ if (!use_hardstatus)
+ HS = 0;
+
+ UPcost = CalcCost(UP);
+ DOcost = CalcCost(DO);
+ NLcost = CalcCost(NL);
+ LEcost = CalcCost(BC);
+ NDcost = CalcCost(ND);
+ CRcost = CalcCost(CR);
+ IMcost = CalcCost(IM);
+ EIcost = CalcCost(EI);
+ for (i = 0; i < NKEYCAPS; i++)
+ KeyCapsArr[i] = e_tgetstr(KeyCaps[i], &tp);
+ MakeTermcap(0);
+}
+
+/*
+ * if the adaptflag is on, we keep the size of this display, else
+ * we may try to restore our old window sizes.
+ */
+void
+InitTerm(adapt)
+int adapt;
+{
+ display = 1;
+ screentop = screenbot = -1;
+ PutStr(IS);
+ PutStr(TI);
+ if (IM && strcmp(IM, EI))
+ PutStr(EI);
+ insert = 0;
+ if (KS && strcmp(KS, KE))
+ PutStr(KE);
+ keypad = 0;
+ PutStr(E0);
+ GlobalCharset = ASCII;
+ ResizeScreen((struct win *)0);
+ ChangeScrollRegion(0, screenheight-1);
+ PutStr(CL);
+ screenx = screeny = 0;
+ fflush(stdout);
+ debug1("we %swant to adapt all our windows to the display\n",
+ (adapt) ? "" : "don't ");
+ /* In case the size was changed by a init sequence */
+ CheckScreenSize((adapt) ? 2 : 0);
+}
+
+void
+FinitTerm()
+{
+ display = 1;
+ InsertMode(0);
+ KeypadMode(0);
+ ResizeScreen((struct win *)0);
+ ChangeScrollRegion(0, screenheight - 1);
+ SaveSetAttr(0, ASCII);
+ screenx = screeny = -1;
+ GotoPos(0, screenheight - 1);
+ PutStr(TE);
+ fflush(stdout);
+ if (Termcap)
+ {
+ Free(Termcap);
+ debug("FinitTerm: old termcap freed\n");
+ }
+ if (tbuf)
+ {
+ Free(tbuf);
+ debug("FinitTerm: old tbuf freed\n");
+ }
+ if (tentry)
+ {
+ Free(tentry);
+ debug("FinitTerm: old tentry freed\n");
+ }
+}
+
+static void AddCap(s)
+char *s;
+{
+ register int n;
+
+ if (tcLineLen + (n = strlen(s)) > 55 && Termcaplen < 1024-4)
+ {
+ strcpy(Termcap + Termcaplen, "\\\n\t:");
+ Termcaplen += 4;
+ tcLineLen = 0;
+ }
+ if (Termcaplen + n < 1024)
+ {
+ strcpy(Termcap + Termcaplen, s);
+ Termcaplen += n;
+ tcLineLen += n;
+ }
+ else
+ Msg(0, "TERMCAP overflow - sorry.");
+}
+
+char *MakeTermcap(aflag)
+int aflag;
+{
+ char buf[1024];
+ register char *p, *cp, ch;
+ int i;
+
+ if (screencap)
+ {
+ sprintf(Term, "TERM=screen");
+ return Termcap;
+ }
+ if (screenterm == 0 || *screenterm == '\0')
+ {
+ debug("MakeTermcap sets screenterm=screen\n");
+ strcpy(screenterm, "screen");
+ }
+ for (;;)
+ {
+ sprintf(Term, "TERM=");
+ p = Term + 5;
+ if (!aflag && strlen(screenterm) + strlen(termname) < MAXSTR-1)
+ {
+ sprintf(p, "%s.%s", screenterm, termname);
+ if (tgetent(buf, p) == 1)
+ break;
+ }
+ if (screenwidth >= 132)
+ {
+ sprintf(p, "%s-w", screenterm);
+ if (tgetent(buf, p) == 1)
+ break;
+ }
+ sprintf(p, "%s", screenterm);
+ if (tgetent(buf, p) == 1)
+ break;
+ sprintf(p, "vt100");
+ break;
+ }
+ tcLineLen = 100; /* Force NL */
+ sprintf(Termcap,
+ "TERMCAP=SC|%s|VT 100/ANSI X3.64 virtual terminal|", p);
+ Termcaplen = strlen(Termcap);
+ if (extra_outcap && *extra_outcap)
+ {
+ for (cp = extra_outcap; p = index(cp, ':'); cp = p)
+ {
+ ch = *++p;
+ *p = '\0';
+ AddCap(cp);
+ *p = ch;
+ }
+ tcLineLen = 100; /* Force NL */
+ }
+ if (Termcaplen + strlen(TermcapConst) < 1024)
+ {
+ strcpy(Termcap + Termcaplen, TermcapConst);
+ Termcaplen += strlen(TermcapConst);
+ }
+ sprintf(buf, "li#%d:co#%d:", screenheight, screenwidth);
+ AddCap(buf);
+ if ((force_vt && !COP) || LP || !AM)
+ AddCap("LP:");
+ else
+ AddCap("am:");
+ if (VB)
+ AddCap("vb=\\E[?5h\\E[?5l:");
+ if (US)
+ {
+ AddCap("us=\\E[4m:");
+ AddCap("ue=\\E[24m:");
+ }
+ if (SO)
+ {
+ AddCap("so=\\E[3m:");
+ AddCap("se=\\E[23m:");
+ }
+ if (MB)
+ AddCap("mb=\\E[5m:");
+ if (MD)
+ AddCap("md=\\E[1m:");
+ if (MH)
+ AddCap("mh=\\E[2m:");
+ if (MR)
+ AddCap("mr=\\E[7m:");
+ if (MB || MD || MH || MR)
+ AddCap("me=\\E[m:ms:");
+ if ((CS && SR) || AL || CAL || aflag)
+ {
+ AddCap("sr=\\EM:");
+ AddCap("al=\\E[L:");
+ AddCap("AL=\\E[%dL:");
+ }
+ else if (SR)
+ AddCap("sr=\\EM:");
+ if (CS || DL || CDL || aflag)
+ {
+ AddCap("dl=\\E[M:");
+ AddCap("DL=\\E[%dM:");
+ }
+ if (CS)
+ AddCap("cs=\\E[%i%d;%dr:");
+ if (DC || CDC || aflag)
+ {
+ AddCap("dc=\\E[P:");
+ AddCap("DC=\\E[%dP:");
+ }
+ if (CIC || IC || IM || aflag)
+ {
+ AddCap("im=\\E[4h:");
+ AddCap("ei=\\E[4l:");
+ AddCap("mi:");
+ AddCap("ic=\\E[@:");
+ AddCap("IC=\\E[%d@:");
+ }
+ if (KS)
+ AddCap("ks=\\E=:");
+ if (KE)
+ AddCap("ke=\\E>:");
+ if (ISO2022)
+ AddCap("G0:");
+ if (PO)
+ {
+ AddCap("po=\\E[5i:");
+ AddCap("pf=\\E[4i:");
+ }
+ if (Z0)
+ {
+ AddCap("Z0=\\E[?3h:");
+ AddCap("Z1=\\E[?3l:");
+ }
+ if (WS)
+ AddCap("WS=\\E[8;%d;%dt:");
+ for (i = 0; i < NKEYCAPS; i++)
+ {
+ if (KeyCapsArr[i] == 0)
+ continue;
+ MakeString(KeyCaps[i], buf, sizeof(buf), KeyCapsArr[i]);
+ AddCap(buf);
+ }
+ return Termcap;
+}
+
+static void MakeString(cap, buf, buflen, s)
+char *cap, *buf;
+int buflen;
+char *s;
+{
+ register char *p, *pmax;
+ register unsigned int c;
+
+ p = buf;
+ pmax = p + buflen - (3+4+2);
+ *p++ = *cap++;
+ *p++ = *cap;
+ *p++ = '=';
+ while ((c = *s++) && (p < pmax))
+ {
+ switch (c)
+ {
+ case '\033':
+ *p++ = '\\';
+ *p++ = 'E';
+ break;
+ case ':':
+ sprintf(p, "\\072");
+ p += 4;
+ break;
+ case '^':
+ case '\\':
+ *p++ = '\\';
+ *p++ = c;
+ break;
+ default:
+ if (c >= 200)
+ {
+ sprintf(p, "\\%03o", c & 0377);
+ p += 4;
+ }
+ else if (c < ' ')
+ {
+ *p++ = '^';
+ *p++ = c + '@';
+ }
+ else
+ *p++ = c;
+ }
+ }
+ *p++ = ':';
+ *p = '\0';
+}
+
+void
+Activate(norefresh)
+int norefresh;
+{
+ debug1("Activate(%d)\n", norefresh);
+ if (display)
+ RemoveStatus();
+ display = fore->active = 1;
+ ResizeScreen(fore);
+ SetCurr(fore);
+ debug3("Fore (%d) has size %dx%d", ForeNum, curr->width, curr->height);
+ debug1("(%d)\n", curr->histheight);
+ ChangeScrollRegion(curr->top, curr->bot);
+ KeypadMode(curr->keypad);
+ SetFlow(curr->flow & FLOW_NOW);
+ if (curr->monitor != MON_OFF)
+ curr->monitor = MON_ON;
+ curr->bell = BELL_OFF;
+ Redisplay(norefresh || all_norefresh);
+}
+
+void
+ResetScreen(p)
+register struct win *p;
+{
+ register int i;
+
+ p->wrap = wrap;
+ p->origin = 0;
+ p->insert = 0;
+ p->vbwait = 0;
+ p->keypad = 0;
+ p->top = 0;
+ p->bot = p->height - 1;
+ p->saved = 0;
+ p->LocalAttr = 0;
+ p->x = p->y = 0;
+ p->state = LIT;
+ p->StringType = NONE;
+ p->ss = 0;
+ p->LocalCharset = G0;
+ bzero(p->tabs, p->width);
+ for (i = 8; i < p->width; i += 8)
+ p->tabs[i] = 1;
+ for (i = G0; i <= G3; i++)
+ p->charsets[i] = ASCII;
+}
+
+void
+WriteString(wp, buf, len)
+struct win *wp;
+char *buf;
+int len;
+{
+ register int c, intermediate = 0;
+
+ if (!len)
+ return;
+ if (wp->logfp != NULL)
+ if ((int)fwrite(buf, len, 1, wp->logfp) < 1)
+ {
+ extern int errno;
+
+ Msg(errno, "Error writing logfile");
+ fclose(wp->logfp);
+ wp->logfp = NULL;
+ }
+ /*
+ * SetCurr() here may prevent output, as it may set display = 0
+ */
+ SetCurr(wp);
+ if (display)
+ {
+ if (!HS)
+ RemoveStatus();
+ }
+ else if (curr->monitor == MON_ON)
+ curr->monitor = MON_FOUND;
+
+ do
+ {
+ c = (unsigned char)*buf++;
+ if (c == '\0' || c == '\177')
+ continue;
+ NextChar:
+ switch (curr->state)
+ {
+ case PRIN:
+ switch (c)
+ {
+ case '\033':
+ curr->state = PRINESC;
+ break;
+ default:
+ PrintChar(c);
+ }
+ break;
+ case PRINESC:
+ switch (c)
+ {
+ case '[':
+ curr->state = PRINCSI;
+ break;
+ default:
+ PrintChar('\033');
+ PrintChar(c);
+ curr->state = PRIN;
+ }
+ break;
+ case PRINCSI:
+ switch (c)
+ {
+ case '4':
+ curr->state = PRIN4;
+ break;
+ default:
+ PrintChar('\033');
+ PrintChar('[');
+ PrintChar(c);
+ curr->state = PRIN;
+ }
+ break;
+ case PRIN4:
+ switch (c)
+ {
+ case 'i':
+ curr->state = LIT;
+ PrintFlush();
+ break;
+ default:
+ PrintChar('\033');
+ PrintChar('[');
+ PrintChar('4');
+ PrintChar(c);
+ curr->state = PRIN;
+ }
+ break;
+ case STRESC:
+ switch (c)
+ {
+ case '\\':
+ curr->state = LIT;
+ *(curr->stringp) = '\0';
+ switch (curr->StringType)
+ {
+ case PM:
+ if (!display)
+ break;
+ MakeStatus(curr->string);
+ if (!HS && status && len > 1)
+ {
+ curr->outlen = len - 1;
+ bcopy(buf, curr->outbuf, curr->outlen);
+ return;
+ }
+ break;
+ case DCS:
+ if (display)
+ printf("%s", curr->string);
+ break;
+ case AKA:
+ if (curr->akapos == 0 && !*curr->string)
+ break;
+ strncpy(curr->cmd + curr->akapos, curr->string, 20);
+ if (!*curr->string)
+ curr->autoaka = curr->y + 1;
+ break;
+ default:
+ break;
+ }
+ break;
+ default:
+ curr->state = ASTR;
+ AddChar('\033');
+ AddChar(c);
+ }
+ break;
+ case ASTR:
+ switch (c)
+ {
+ case '\0':
+ break;
+ case '\033':
+ curr->state = STRESC;
+ break;
+ default:
+ AddChar(c);
+ }
+ break;
+ case ESC:
+ switch (c)
+ {
+ case '[':
+ curr->NumArgs = 0;
+ intermediate = 0;
+ bzero((char *) curr->args, MAXARGS * sizeof(int));
+ curr->state = CSI;
+ break;
+ case ']':
+ StartString(OSC);
+ break;
+ case '_':
+ StartString(APC);
+ break;
+ case 'P':
+ StartString(DCS);
+ break;
+ case '^':
+ StartString(PM);
+ break;
+ case '"':
+ case 'k':
+ StartString(AKA);
+ break;
+ default:
+ if (Special(c))
+ break;
+ if (c >= ' ' && c <= '/')
+ intermediate = intermediate ? -1 : c;
+ else if (c >= '0' && c <= '~')
+ {
+ DoESC(c, intermediate);
+ curr->state = LIT;
+ }
+ else
+ {
+ curr->state = LIT;
+ goto NextChar;
+ }
+ }
+ break;
+ case CSI:
+ switch (c)
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (curr->NumArgs < MAXARGS)
+ {
+ curr->args[curr->NumArgs] =
+ 10 * curr->args[curr->NumArgs] + c - '0';
+ }
+ break;
+ case ';':
+ case ':':
+ curr->NumArgs++;
+ break;
+ default:
+ if (Special(c))
+ break;
+ if (c >= '@' && c <= '~')
+ {
+ curr->NumArgs++;
+ DoCSI(c, intermediate);
+ if (curr->state != PRIN)
+ curr->state = LIT;
+ }
+ else if ((c >= ' ' && c <= '/') || (c >= '<' && c <= '?'))
+ intermediate = intermediate ? -1 : c;
+ else
+ {
+ curr->state = LIT;
+ goto NextChar;
+ }
+ }
+ break;
+ case LIT:
+ default:
+ if (!Special(c))
+ {
+ if (c == '\033')
+ {
+ intermediate = 0;
+ curr->state = ESC;
+ if (display && lp_missing && (CIC || IC || IM))
+ {
+ RedisplayLine(blank, null, null, screenbot,
+ cols - 2, cols - 1);
+ GotoPos(curr->x, curr->y);
+ }
+ if (curr->autoaka < 0)
+ curr->autoaka = 0;
+ }
+ else if (c < ' ')
+ break;
+ else
+ {
+ NewRendition(curr->LocalAttr);
+ NewCharset(curr->charsets[(curr->ss) ? curr->ss :
+ curr->LocalCharset]);
+ if (curr->x < cols - 1)
+ {
+ if (curr->insert)
+ InsertAChar(c);
+ else
+ {
+ if (display)
+ PUTCHAR(c);
+ SetChar(c);
+ }
+ curr->x++;
+ }
+ else if (curr->x == cols - 1)
+ {
+ if (curr->wrap && (LP || !force_vt || COP))
+ {
+ if (display)
+ RAW_PUTCHAR(c);
+ SetChar(c);
+ if (AM && !LP)
+ {
+ curr->x = 0; /* terminal auto-wrapped */
+ LineFeed(0);
+ }
+ else
+ curr->x++;
+ }
+ else
+ {
+ if (display)
+ {
+ if (LP || curr->y != screenbot)
+ {
+ RAW_PUTCHAR(c);
+ GotoPos(curr->x, curr->y);
+ }
+ else
+ CheckLP(c);
+ }
+ SetChar(c);
+ if (curr->wrap)
+ curr->x++;
+ }
+ }
+ else
+ {
+ LineFeed(2); /* cr+lf, handle LP */
+ if (curr->insert)
+ InsertAChar(c);
+ else
+ {
+ if (display)
+ PUTCHAR(c);
+ SetChar(c);
+ }
+ curr->x = 1;
+ }
+ if (curr->ss)
+ {
+ NewCharset(curr->charsets[curr->LocalCharset]);
+ curr->ss = 0;
+ }
+ }
+ }
+ }
+ } while (--len);
+ curr->outlen = 0;
+ if (curr->state == PRIN)
+ PrintFlush();
+}
+
+static int Special(c)
+register int c;
+{
+ switch (c)
+ {
+ case '\b':
+ BackSpace();
+ return 1;
+ case '\r':
+ Return();
+ return 1;
+ case '\n':
+ if (curr->autoaka)
+ FindAKA();
+ LineFeed(1);
+ return 1;
+ case '\007':
+ if (!visual_bell)
+ PutStr(BL);
+ else
+ {
+ if (!VB)
+ curr->bell = BELL_VISUAL;
+ else
+ PutStr(VB);
+ }
+ if (!display)
+ curr->bell = BELL_ON;
+ return 1;
+ case '\t':
+ ForwardTab();
+ return 1;
+ case '\017': /* SI */
+ MapCharset(G0);
+ return 1;
+ case '\016': /* SO */
+ MapCharset(G1);
+ return 1;
+ }
+ return 0;
+}
+
+static void DoESC(c, intermediate)
+int c, intermediate;
+{
+ switch (intermediate)
+ {
+ case 0:
+ switch (c)
+ {
+ case 'E':
+ LineFeed(2);
+ break;
+ case 'D':
+ LineFeed(1);
+ break;
+ case 'M':
+ ReverseLineFeed();
+ break;
+ case 'H':
+ curr->tabs[curr->x] = 1;
+ break;
+ case 'Z': /* jph: Identify as VT100 */
+ Report(curr, "\033[?%d;%dc", 1, 2);
+ break;
+ case '7':
+ SaveCursor();
+ break;
+ case '8':
+ RestoreCursor();
+ break;
+ case 'c':
+ ClearScreen();
+ ResetScreen(curr);
+ NewRendition(0);
+ NewCharset(ASCII);
+ InsertMode(0);
+ KeypadMode(0);
+ ChangeScrollRegion(0, rows-1);
+ break;
+ case '=':
+ KeypadMode(curr->keypad = 1);
+#if !defined(TIOCPKT) || defined(sgi)
+ NewAutoFlow(curr, 0);
+#endif /* !TIOCPKT || sgi */
+ break;
+ case '>':
+ KeypadMode(curr->keypad = 0);
+#if !defined(TIOCPKT) || defined(sgi)
+ NewAutoFlow(curr, 1);
+#endif /* !TIOCPKT || sgi */
+ break;
+ case 'n': /* LS2 */
+ MapCharset(G2);
+ break;
+ case 'o': /* LS3 */
+ MapCharset(G3);
+ break;
+ case 'N': /* SS2 */
+ if (curr->charsets[curr->LocalCharset] != curr->charsets[G2])
+ curr->ss = G2;
+ else
+ curr->ss = 0;
+ break;
+ case 'O': /* SS3 */
+ if (curr->charsets[curr->LocalCharset] != curr->charsets[G3])
+ curr->ss = G3;
+ else
+ curr->ss = 0;
+ break;
+ }
+ break;
+ case '#':
+ switch (c)
+ {
+ case '8':
+ FillWithEs();
+ break;
+ }
+ break;
+ case '(':
+ DesignateCharset(c, G0);
+ break;
+ case ')':
+ DesignateCharset(c, G1);
+ break;
+ case '*':
+ DesignateCharset(c, G2);
+ break;
+ case '+':
+ DesignateCharset(c, G3);
+ break;
+ }
+}
+
+static void DoCSI(c, intermediate)
+int c, intermediate;
+{
+ register int i, a1 = curr->args[0], a2 = curr->args[1];
+
+ if (curr->NumArgs > MAXARGS)
+ curr->NumArgs = MAXARGS;
+ switch (intermediate)
+ {
+ case 0:
+ switch (c)
+ {
+ case 'H':
+ case 'f':
+ if (a1 < 1)
+ a1 = 1;
+ if (curr->origin)
+ a1 += curr->top;
+ if (a1 > rows)
+ a1 = rows;
+ if (a2 < 1)
+ a2 = 1;
+ if (a2 > cols)
+ a2 = cols;
+ GotoPos(--a2, --a1);
+ curr->x = a2;
+ curr->y = a1;
+ if (curr->autoaka)
+ curr->autoaka = a1 + 1;
+ break;
+ case 'J':
+ if (a1 < 0 || a1 > 2)
+ a1 = 0;
+ switch (a1)
+ {
+ case 0:
+ ClearToEOS();
+ break;
+ case 1:
+ ClearFromBOS();
+ break;
+ case 2:
+ ClearScreen();
+ GotoPos(curr->x, curr->y);
+ break;
+ }
+ break;
+ case 'K':
+ if (a1 < 0 || a1 > 2)
+ a1 %= 3;
+ switch (a1)
+ {
+ case 0:
+ ClearToEOL();
+ break;
+ case 1:
+ ClearFromBOL();
+ break;
+ case 2:
+ ClearLine();
+ break;
+ }
+ break;
+ case 'A':
+ CursorUp(a1 ? a1 : 1);
+ break;
+ case 'B':
+ CursorDown(a1 ? a1 : 1);
+ break;
+ case 'C':
+ CursorRight(a1 ? a1 : 1);
+ break;
+ case 'D':
+ CursorLeft(a1 ? a1 : 1);
+ break;
+ case 'm':
+ SelectRendition();
+ break;
+ case 'g':
+ if (a1 == 0)
+ curr->tabs[curr->x] = 0;
+ else if (a1 == 3)
+ bzero(curr->tabs, cols);
+ break;
+ case 'r':
+ if (!a1)
+ a1 = 1;
+ if (!a2)
+ a2 = rows;
+ if (a1 < 1 || a2 > rows || a1 >= a2)
+ break;
+ curr->top = a1 - 1;
+ curr->bot = a2 - 1;
+ ChangeScrollRegion(curr->top, curr->bot);
+ if (curr->origin)
+ {
+ GotoPos(0, curr->top);
+ curr->y = curr->top;
+ curr->x = 0;
+ }
+ else
+ {
+ GotoPos(0, 0);
+ curr->y = curr->x = 0;
+ }
+ break;
+ case 's':
+ SaveCursor();
+ break;
+ case 't':
+ if (a1 != 8)
+ break;
+ a1 = curr->args[2];
+ if (a1 < 1)
+ a1 = curr->width;
+ if (a2 < 1)
+ a2 = curr->height;
+ if (WS == NULL)
+ {
+ a2 = curr->height;
+ if (Z0 == NULL || (a1 != Z0width && a1 != Z1width))
+ a1 = curr->width;
+ }
+ if (a1 == curr->width && a2 == curr->height)
+ break;
+ ChangeWindowSize(curr, a1, a2);
+ SetCurr(curr);
+ if (display)
+ Activate(0);
+ break;
+ case 'u':
+ RestoreCursor();
+ break;
+ case 'I':
+ if (!a1)
+ a1 = 1;
+ while (a1--)
+ ForwardTab();
+ break;
+ case 'Z':
+ if (!a1)
+ a1 = 1;
+ while (a1--)
+ BackwardTab();
+ break;
+ case 'L':
+ InsertLine(a1 ? a1 : 1);
+ break;
+ case 'M':
+ DeleteLine(a1 ? a1 : 1);
+ break;
+ case 'P':
+ DeleteChar(a1 ? a1 : 1);
+ break;
+ case '@':
+ InsertChar(a1 ? a1 : 1);
+ break;
+ case 'h':
+ ASetMode(1);
+ break;
+ case 'l':
+ ASetMode(0);
+ break;
+ case 'i':
+ if (PO && a1 == 5)
+ {
+ curr->stringp = curr->string;
+ curr->state = PRIN;
+ }
+ break;
+ case 'n':
+ if (a1 == 6) /* Report cursor position */
+ Report(curr, "\033[%d;%dR", curr->y + 1, curr->x + 1);
+ break;
+ case 'c': /* Identify as VT100 */
+ Report(curr, "\033[?%d;%dc", 1, 2);
+ break;
+ }
+ break;
+ case '?':
+ debug2("\\E[?%d%c\n",a1,c);
+ if (c != 'h' && c != 'l')
+ break;
+ i = (c == 'h');
+ switch (a1)
+ {
+ case 3:
+ i = (i ? Z0width : Z1width);
+ if ((Z0 || WS) && curr->width != i)
+ {
+ ChangeWindowSize(curr, i, curr->height);
+ SetCurr(curr);
+ if (display)
+ Activate(0);
+ }
+ break;
+ case 5:
+ if (i)
+ curr->vbwait = 1;
+ else
+ {
+ if (curr->vbwait)
+ PutStr(VB);
+ curr->vbwait = 0;
+ }
+ break;
+ case 6:
+ if ((curr->origin = i) != 0)
+ {
+ GotoPos(0, curr->top);
+ curr->y = curr->top;
+ curr->x = 0;
+ }
+ else
+ {
+ GotoPos(0, 0);
+ curr->y = curr->x = 0;
+ }
+ break;
+ case 7:
+ curr->wrap = i;
+ break;
+ case 35:
+ debug1("Cursor %svisible\n", i?"in":"");
+ curr->cursor_invisible = i;
+ break;
+ }
+ break;
+ }
+}
+
+void
+INSERTCHAR(c)
+int c;
+{
+ if (!insert && (IC || CIC))
+ {
+ if (IC)
+ PutStr(IC);
+ else
+ CPutStr(CIC, 1);
+ RAW_PUTCHAR(c);
+ return;
+ }
+ InsertMode(1);
+ if (insert)
+ RAW_PUTCHAR(c);
+ else
+ RefreshLine(screeny, screenx, screenwidth-1);
+}
+
+void
+PUTCHAR(c)
+int c;
+{
+ if (insert)
+ InsertMode(0);
+ RAW_PUTCHAR(c);
+}
+
+/*
+ * RAW_PUTCHAR() is for all text that will be displayed.
+ * NOTE, that charset Nr. 0 has a conversion table, but c1, c2, ... don't.
+ */
+
+static void
+RAW_PUTCHAR(c)
+int c;
+{
+ if (GlobalCharset == '0')
+ putchar(c0_tab[c]);
+ else
+ putchar(c);
+ if (screenx < screenwidth - 1)
+ screenx++;
+ else
+ {
+ screenx++;
+ if ((AM && !LP) || screenx > screenwidth)
+ {
+ screenx -= screenwidth;
+ if (screeny < screenheight-1 && screeny != screenbot)
+ screeny++;
+ }
+ }
+}
+
+void
+PutChar(c)
+int c;
+{
+ /* this PutChar for ESC-sequences only */
+ putchar(c);
+}
+
+void
+PutStr(s)
+char *s;
+{
+ if (display && s)
+ tputs(s, 1, PutChar);
+}
+
+static void CPutStr(s, c)
+char *s;
+int c;
+{
+ if (display && s)
+ tputs(tgoto(s, 0, c), 1, PutChar);
+}
+
+static void SetChar(c)
+register int c;
+{
+ register struct win *p = curr;
+
+ p->image[p->y][p->x] = c;
+ p->attr[p->y][p->x] = p->LocalAttr;
+ p->font[p->y][p->x] = p->charsets[p->ss ? p->ss : p->LocalCharset];
+}
+
+static void StartString(type)
+enum string_t type;
+{
+ curr->StringType = type;
+ curr->stringp = curr->string;
+ curr->state = ASTR;
+}
+
+static void AddChar(c)
+int c;
+{
+ if (curr->stringp >= curr->string + MAXSTR - 1)
+ curr->state = LIT;
+ else
+ *(curr->stringp)++ = c;
+}
+
+static void PrintChar(c)
+int c;
+{
+ if (curr->stringp >= curr->string + MAXSTR - 1)
+ PrintFlush();
+ *(curr->stringp)++ = c;
+}
+
+static void PrintFlush()
+{
+ if (curr->stringp > curr->string)
+ {
+ tputs(PO, 1, PutChar);
+ (void) fflush(stdout);
+ (void) write(1, curr->string, curr->stringp - curr->string);
+ tputs(PF, 1, PutChar);
+ (void) fflush(stdout);
+ curr->stringp = curr->string;
+ }
+}
+
+/* Insert mode is a toggle on some terminals, so we need this hack:
+ */
+void
+InsertMode(on)
+int on;
+{
+ if (display && on != insert && IM)
+ {
+ insert = on;
+ if (insert)
+ PutStr(IM);
+ else
+ PutStr(EI);
+ }
+}
+
+/* ...and maybe keypad application mode is a toggle, too:
+ */
+static void KeypadMode(on)
+int on;
+{
+ if (display && keypad != on && KS)
+ {
+ keypad = on;
+ if (keypad)
+ PutStr(KS);
+ else
+ PutStr(KE);
+ }
+}
+
+void
+NewAutoFlow(win, on)
+struct win *win;
+int on;
+{
+ debug1("NewAutoFlow: %d\n", on);
+ SetCurr(win);
+ if (win->flow & FLOW_AUTOFLAG)
+ win->flow = FLOW_AUTOFLAG | (FLOW_AUTO|FLOW_NOW) * on;
+ else
+ win->flow = (win->flow & ~FLOW_AUTO) | FLOW_AUTO * on;
+ if (display)
+ SetFlow(win->flow & FLOW_NOW);
+}
+
+static void DesignateCharset(c, n)
+int c, n;
+{
+ curr->ss = 0;
+ if (c == 'B')
+ c = ASCII;
+ if (curr->charsets[n] != c)
+ {
+ curr->charsets[n] = c;
+ if (curr->LocalCharset == n)
+ NewCharset(c);
+ }
+}
+
+static void MapCharset(n)
+int n;
+{
+ curr->ss = 0;
+ if (curr->LocalCharset != n)
+ {
+ curr->LocalCharset = n;
+ NewCharset(curr->charsets[n]);
+ }
+}
+
+void
+NewCharset(new)
+int new;
+{
+ if (!display || GlobalCharset == new)
+ return;
+ GlobalCharset = new;
+ if (new == ASCII)
+ PutStr(E0);
+ else
+ CPutStr(S0, new);
+}
+
+static void SaveCursor()
+{
+ curr->saved = 1;
+ curr->Saved_x = curr->x;
+ curr->Saved_y = curr->y;
+ curr->SavedLocalAttr = curr->LocalAttr;
+ curr->SavedLocalCharset = curr->LocalCharset;
+ bcopy((char *) curr->charsets, (char *) curr->SavedCharsets,
+ 4 * sizeof(int));
+}
+
+static void RestoreCursor()
+{
+ if (curr->saved)
+ {
+ GotoPos(curr->Saved_x, curr->Saved_y);
+ curr->x = curr->Saved_x;
+ curr->y = curr->Saved_y;
+ curr->LocalAttr = curr->SavedLocalAttr;
+ NewRendition(curr->LocalAttr);
+ bcopy((char *) curr->SavedCharsets, (char *) curr->charsets,
+ 4 * sizeof(int));
+ curr->LocalCharset = curr->SavedLocalCharset;
+ NewCharset(curr->charsets[curr->LocalCharset]);
+ }
+}
+
+/*ARGSUSED*/
+static void CountChars(c)
+int c;
+{
+ StrCost++;
+}
+
+static int CalcCost(s)
+register char *s;
+{
+ if (s)
+ {
+ StrCost = 0;
+ tputs(s, 1, CountChars);
+ return StrCost;
+ }
+ else
+ return EXPENSIVE;
+}
+
+void
+GotoPos(x2, y2)
+int x2, y2;
+{
+ register int dy, dx, x1, y1;
+ register int costx, costy;
+ register int m;
+ register char *s;
+ int CMcost;
+ enum move_t xm = M_NONE, ym = M_NONE;
+
+ if (!display)
+ return;
+
+ x1 = screenx;
+ y1 = screeny;
+
+ if (x1 == screenwidth)
+ if (LP && AM)
+ x1 = -1; /* don't know how the terminal treats this */
+ else
+ x1--;
+ if (x2 == screenwidth)
+ x2--;
+ dx = x2 - x1;
+ dy = y2 - y1;
+ if (dy == 0 && dx == 0)
+ {
+ return;
+ }
+ if (!MS && GlobalAttr) /* Safe to move in SO mode ? */
+ NewRendition(0);
+ if (y1 < 0 /* don't know the y position */
+ || (y2 > screenbot && y1 <= screenbot) /* have to cross border */
+ || (y2 < screentop && y1 >= screentop)) /* of scrollregion ? */
+ {
+ DoCM:
+ if (HO && !x2 && !y2)
+ PutStr(HO);
+ else
+ PutStr(tgoto(CM, x2, y2));
+ screenx = x2;
+ screeny = y2;
+ return;
+ }
+ /* Calculate CMcost */
+ if (HO && !x2 && !y2)
+ s = HO;
+ else
+ s = tgoto(CM, x2, y2);
+ CMcost = CalcCost(s);
+
+ /* Calculate the cost to move the cursor to the right x position */
+ costx = EXPENSIVE;
+ if (x1 >= 0) /* relativ x positioning only if we know where we are */
+ {
+ if (dx > 0)
+ {
+ if (CRI && (dx > 1 || !ND))
+ {
+ costx = CalcCost(tgoto(CRI, 0, dx));
+ xm = M_CRI;
+ }
+ if ((m = NDcost * dx) < costx)
+ {
+ costx = m;
+ xm = M_RI;
+ }
+ /* Speedup: dx <= Rewrite() */
+ if (dx < costx && (m = Rewrite(y1, x1, x2, 0)) < costx)
+ {
+ costx = m;
+ xm = M_RW;
+ }
+ }
+ else if (dx < 0)
+ {
+ if (CLE && (dx < -1 || !BC))
+ {
+ costx = CalcCost(tgoto(CLE, 0, -dx));
+ xm = M_CLE;
+ }
+ if ((m = -dx * LEcost) < costx)
+ {
+ costx = m;
+ xm = M_LE;
+ }
+ }
+ else
+ costx = 0;
+ }
+ /* Speedup: Rewrite() >= x2 */
+ if (x2 + CRcost < costx && (m = Rewrite(y1, 0, x2, 0) + CRcost) < costx)
+ {
+ costx = m;
+ xm = M_CR;
+ }
+
+ /* Check if it is already cheaper to do CM */
+ if (costx >= CMcost)
+ goto DoCM;
+
+ /* Calculate the cost to move the cursor to the right y position */
+ costy = EXPENSIVE;
+ if (dy > 0)
+ {
+ if (CDO && dy > 1) /* DO & NL are always != 0 */
+ {
+ costy = CalcCost(tgoto(CDO, 0, dy));
+ ym = M_CDO;
+ }
+ if ((m = dy * ((x2 == 0) ? NLcost : DOcost)) < costy)
+ {
+ costy = m;
+ ym = M_DO;
+ }
+ }
+ else if (dy < 0)
+ {
+ if (CUP && (dy < -1 || !UP))
+ {
+ costy = CalcCost(tgoto(CUP, 0, -dy));
+ ym = M_CUP;
+ }
+ if ((m = -dy * UPcost) < costy)
+ {
+ costy = m;
+ ym = M_UP;
+ }
+ }
+ else
+ costy = 0;
+
+ /* Finally check if it is cheaper to do CM */
+ if (costx + costy >= CMcost)
+ goto DoCM;
+
+ switch (xm)
+ {
+ case M_LE:
+ while (dx++ < 0)
+ PutStr(BC);
+ break;
+ case M_CLE:
+ CPutStr(CLE, -dx);
+ break;
+ case M_RI:
+ while (dx-- > 0)
+ PutStr(ND);
+ break;
+ case M_CRI:
+ CPutStr(CRI, dx);
+ break;
+ case M_CR:
+ PutStr(CR);
+ screenx = 0;
+ x1 = 0;
+ /* FALLTHROUGH */
+ case M_RW:
+ if (x1 < x2)
+ (void) Rewrite(y1, x1, x2, 1);
+ break;
+ default:
+ break;
+ }
+ switch (ym)
+ {
+ case M_UP:
+ while (dy++ < 0)
+ PutStr(UP);
+ break;
+ case M_CUP:
+ CPutStr(CUP, -dy);
+ break;
+ case M_DO:
+ s = (x2 == 0) ? NL : DO;
+ while (dy-- > 0)
+ PutStr(s);
+ break;
+ case M_CDO:
+ CPutStr(CDO, dy);
+ break;
+ default:
+ break;
+ }
+ screenx = x2;
+ screeny = y2;
+}
+
+static int
+Rewrite(y, x1, x2, doit)
+int y, x1, x2, doit;
+{
+ register int cost, dx;
+ register char *p, *f, *i;
+
+ if (x1 == x2)
+ return(0);
+ if (in_ovl)
+ {
+ if (ovl_Rewrite == 0)
+ return EXPENSIVE;
+ else
+ return ((*ovl_Rewrite)(y, x1, x2, doit));
+ }
+ dx = x2 - x1;
+ if (doit)
+ {
+ i = curr->image[y] + x1;
+ while (dx-- > 0)
+ PUTCHAR(*i++);
+ return(0);
+ }
+ p = curr->attr[y] + x1;
+ f = curr->font[y] + x1;
+
+ cost = dx = x2 - x1;
+ if (insert)
+ cost += EIcost + IMcost;
+ while(dx-- > 0)
+ {
+ if (*p++ != GlobalAttr || *f++ != GlobalCharset)
+ return EXPENSIVE;
+ }
+ return cost;
+}
+
+static void BackSpace()
+{
+ if (curr->x > 0)
+ {
+ curr->x--;
+ }
+ else if (curr->wrap && curr->y > 0)
+ {
+ curr->x = cols - 1;
+ curr->y--;
+ }
+ if (display)
+ GotoPos(curr->x, curr->y);
+}
+
+static void Return()
+{
+ if (curr->x > 0)
+ {
+ curr->x = 0;
+ if (display)
+ GotoPos(curr->x, curr->y);
+ }
+}
+
+static void LineFeed(out_mode)
+int out_mode;
+{
+ /* out_mode: 0=no-output lf, 1=lf, 2=cr+lf */
+ if (out_mode == 2)
+ curr->x = 0;
+ if (curr->y != curr->bot) /* Don't scroll */
+ {
+ if (curr->y < rows-1)
+ curr->y++;
+ if (out_mode && display)
+ GotoPos(curr->x, curr->y);
+ return;
+ }
+ ScrollUpMap(1);
+ if (curr->autoaka > 1)
+ curr->autoaka--;
+ if (out_mode && display)
+ {
+ ScrollRegion(curr->top, curr->bot, 1);
+ GotoPos(curr->x, curr->y);
+ }
+}
+
+static void ReverseLineFeed()
+{
+ if (curr->y == curr->top)
+ {
+ ScrollDownMap(1);
+ if (!display)
+ return;
+ ScrollRegion(curr->top, curr->bot, -1);
+ GotoPos(curr->x, curr->y);
+ }
+ else if (curr->y > 0)
+ CursorUp(1);
+}
+
+static void InsertAChar(c)
+int c;
+{
+ register int y = curr->y, x = curr->x;
+
+ if (x == cols)
+ x--;
+ bcopy(curr->image[y], OldImage, cols);
+ bcopy(curr->attr[y], OldAttr, cols);
+ bcopy(curr->font[y], OldFont, cols);
+ bcopy(curr->image[y] + x, curr->image[y] + x + 1, cols - x - 1);
+ bcopy(curr->attr[y] + x, curr->attr[y] + x + 1, cols - x - 1);
+ bcopy(curr->font[y] + x, curr->font[y] + x + 1, cols - x - 1);
+ SetChar(c);
+ if (!display)
+ return;
+ if (CIC || IC || IM)
+ {
+ InsertMode(curr->insert);
+ INSERTCHAR(c);
+ if (y == screenbot)
+ lp_missing = 0;
+ }
+ else
+ {
+ RedisplayLine(OldImage, OldAttr, OldFont, y, x, cols - 1);
+ GotoPos(++x, y);
+ }
+}
+
+static void InsertChar(n)
+int n;
+{
+ register int i, y = curr->y, x = curr->x;
+
+ if (n <= 0)
+ return;
+ /*
+ * The termcap manual states that only one of IM and IC is
+ * to be defined unless the terminal needs both sequences.
+ * We don't like this because we think that there may be cases
+ * where it is preferable to send IC instead of IM/EI.
+ * The hack is to ignore the IC sequence if we are already
+ * in insert mode, so that programs which follow the termcap
+ * guidelines still work. (I don't believe that there are
+ * terminals which need IC in the insert mode. Why switch to
+ * insert mode if you must send IC before every character ?)
+ */
+ if (curr->insert)
+ return;
+ if (x == cols)
+ --x;
+ bcopy(curr->image[y], OldImage, cols);
+ bcopy(curr->attr[y], OldAttr, cols);
+ bcopy(curr->font[y], OldFont, cols);
+ if (n > cols - x)
+ n = cols - x;
+ bcopy(curr->image[y] + x, curr->image[y] + x + n, cols - x - n);
+ bcopy(curr->attr[y] + x, curr->attr[y] + x + n, cols - x - n);
+ bcopy(curr->font[y] + x, curr->font[y] + x + n, cols - x - n);
+ ClearInLine(0, y, x, x + n - 1);
+ if (!display)
+ return;
+ if (IC || CIC || IM)
+ {
+ if (y == screenbot)
+ lp_missing = 0;
+ if (!insert)
+ {
+ if (n == 1 && IC)
+ {
+ PutStr(IC);
+ return;
+ }
+ if (CIC)
+ {
+ CPutStr(CIC, n);
+ return;
+ }
+ }
+ InsertMode(1);
+ for (i = n; i--; )
+ INSERTCHAR(' ');
+ GotoPos(x, y);
+ }
+ else
+ {
+ RedisplayLine(OldImage, OldAttr, OldFont, y, x, cols - 1);
+ GotoPos(x, y);
+ }
+}
+
+static void DeleteChar(n)
+int n;
+{
+ register int i, y = curr->y, x = curr->x;
+
+ if (x == cols)
+ --x;
+ bcopy(curr->image[y], OldImage, cols);
+ bcopy(curr->attr[y], OldAttr, cols);
+ bcopy(curr->font[y], OldFont, cols);
+ if (n > cols - x)
+ n = cols - x;
+ bcopy(curr->image[y] + x + n, curr->image[y] + x, cols - x - n);
+ bcopy(curr->attr[y] + x + n, curr->attr[y] + x, cols - x - n);
+ bcopy(curr->font[y] + x + n, curr->font[y] + x, cols - x - n);
+ ClearInLine(0, y, cols - n, cols - 1);
+ if (!display)
+ return;
+ if (CDC && !(n == 1 && DC))
+ {
+ CPutStr(CDC, n);
+ if (lp_missing && y == screenbot)
+ {
+ FixLP(cols - 1 - n, y);
+ GotoPos(x, y);
+ }
+ }
+ else if (DC)
+ {
+ for (i = n; i; i--)
+ PutStr(DC);
+ if (lp_missing && y == screenbot)
+ {
+ FixLP(cols - 1 - n, y);
+ GotoPos(x, y);
+ }
+ }
+ else
+ {
+ RedisplayLine(OldImage, OldAttr, OldFont, y, x, cols - 1);
+ GotoPos(x, y);
+ }
+}
+
+static void DeleteLine(n)
+int n;
+{
+ register int old = curr->top;
+
+ if (curr->y < curr->top || curr->y > curr->bot)
+ return;
+ if (n > curr->bot - curr->y + 1)
+ n = curr->bot - curr->y + 1;
+ curr->top = curr->y;
+ ScrollUpMap(n);
+ curr->top = old;
+ if (!display)
+ return;
+ ScrollRegion(curr->y, curr->bot, n);
+ GotoPos(curr->x, curr->y);
+}
+
+static void InsertLine(n)
+int n;
+{
+ register int old = curr->top;
+
+ if (curr->y < curr->top || curr->y > curr->bot)
+ return;
+ if (n > curr->bot - curr->y + 1)
+ n = curr->bot - curr->y + 1;
+ curr->top = curr->y;
+ ScrollDownMap(n);
+ curr->top = old;
+ if (!display)
+ return;
+ ScrollRegion(curr->y, curr->bot, -n);
+ GotoPos(curr->x, curr->y);
+}
+
+void
+ScrollRegion(ys, ye, n)
+int ys, ye, n;
+{
+ int i;
+ int up;
+ int oldtop, oldbot;
+ int alok, dlok, aldlfaster;
+ int missy = 0;
+
+ if (n == 0)
+ return;
+ if (ys == 0 && ye == screenheight-1 &&
+ (n >= screenheight || -n >= screenheight))
+ {
+ PutStr(CL);
+ screeny = screenx = 0;
+ lp_missing = 0;
+ return;
+ }
+
+ if (lp_missing)
+ {
+ if (screenbot>ye || screenbot<ys)
+ missy = screenbot;
+ else
+ {
+ missy = screenbot - n;
+ if (missy>ye || missy<ys)
+ lp_missing = 0;
+ }
+ }
+
+ up = 1;
+ if (n < 0)
+ {
+ up = 0;
+ n = -n;
+ }
+ if (n >= ye-ys+1)
+ n = ye-ys+1;
+
+ oldtop = screentop;
+ oldbot = screenbot;
+ if (screenbot != ye)
+ ChangeScrollRegion(ys, ye);
+ alok = (AL || CAL || (ye == screenbot && up));
+ dlok = (DL || CDL || (ye == screenbot && !up));
+ if (screentop != ys && !(alok && dlok))
+ ChangeScrollRegion(ys, ye);
+
+ if (lp_missing &&
+ (oldbot != screenbot ||
+ (oldbot == screenbot && up && screentop == ys && screenbot == ye)))
+ {
+ /* Can't use FixLP */
+ GotoPos(screenwidth-1, oldbot);
+ SaveSetAttr(curr->attr[missy][screenwidth-1], curr->font[missy][screenwidth-1]);
+ PUTCHAR(curr->image[missy][screenwidth-1]);
+ RestoreAttr();
+ lp_missing = 0;
+ if (oldbot == screenbot) /* have scrolled */
+ {
+ if (--n == 0)
+ {
+ ChangeScrollRegion(oldtop, oldbot);
+ return;
+ }
+ }
+ }
+
+ aldlfaster = (n > 1 && ye == screenbot && ((up && CDL) || (!up && CAL)));
+
+ if ((up || SR) && screentop == ys && screenbot == ye && !aldlfaster)
+ {
+ if (up)
+ {
+ GotoPos(0, ye);
+ while (n-- > 0)
+ PutStr(NL); /* was SF, I think NL is faster */
+ }
+ else
+ {
+ GotoPos(0, ys);
+ while (n-- > 0)
+ PutStr(SR);
+ }
+ }
+ else if (alok && dlok)
+ {
+ if (up || ye != screenbot)
+ {
+ GotoPos(0, up ? ys : ye+1-n);
+ if (CDL && !(n == 1 && DL))
+ CPutStr(CDL, n);
+ else
+ for(i=n; i--; )
+ PutStr(DL);
+ }
+ if (!up || ye != screenbot)
+ {
+ GotoPos(0, up ? ye+1-n : ys);
+ if (CAL && !(n == 1 && AL))
+ CPutStr(CAL, n);
+ else
+ for(i=n; i--; )
+ PutStr(AL);
+ }
+ }
+ else
+ {
+ Redisplay(0);
+ return;
+ }
+ if (lp_missing && missy != screenbot)
+ FixLP(screenwidth-1, missy);
+ ChangeScrollRegion(oldtop, oldbot);
+ if (lp_missing && missy != screenbot)
+ FixLP(screenwidth-1, missy);
+}
+
+static void ScrollUpMap(n)
+int n;
+{
+ char tmp[256 * sizeof(char *)];
+ register int ii, i, cnt1, cnt2;
+ register char **ppi, **ppa, **ppf;
+
+ i = curr->top + n;
+ cnt1 = n * sizeof(char *);
+ cnt2 = (curr->bot - i + 1) * sizeof(char *);
+ ppi = curr->image + i;
+ ppa = curr->attr + i;
+ ppf = curr->font + i;
+ for(ii = curr->top; ii < i; ii++)
+ AddLineToHist(curr, &curr->image[ii], &curr->attr[ii], &curr->font[ii]);
+ for (i = n; i; --i)
+ {
+ bclear(*--ppi, cols);
+ bzero(*--ppa, cols);
+ bzero(*--ppf, cols);
+ }
+ Scroll((char *) ppi, cnt1, cnt2, tmp);
+ Scroll((char *) ppa, cnt1, cnt2, tmp);
+ Scroll((char *) ppf, cnt1, cnt2, tmp);
+}
+
+static void ScrollDownMap(n)
+int n;
+{
+ char tmp[256 * sizeof(char *)];
+ register int i, cnt1, cnt2;
+ register char **ppi, **ppa, **ppf;
+
+ i = curr->top;
+ cnt1 = (curr->bot - i - n + 1) * sizeof(char *);
+ cnt2 = n * sizeof(char *);
+ Scroll((char *) (ppi = curr->image + i), cnt1, cnt2, tmp);
+ Scroll((char *) (ppa = curr->attr + i), cnt1, cnt2, tmp);
+ Scroll((char *) (ppf = curr->font + i), cnt1, cnt2, tmp);
+ for (i = n; i; --i)
+ {
+ bclear(*ppi++, cols);
+ bzero(*ppa++, cols);
+ bzero(*ppf++, cols);
+ }
+}
+
+static void Scroll(cp, cnt1, cnt2, tmp)
+char *cp, *tmp;
+int cnt1, cnt2;
+{
+ if (!cnt1 || !cnt2)
+ return;
+ if (cnt1 <= cnt2)
+ {
+ bcopy(cp, tmp, cnt1);
+ bcopy(cp + cnt1, cp, cnt2);
+ bcopy(tmp, cp + cnt2, cnt1);
+ }
+ else
+ {
+ bcopy(cp + cnt1, tmp, cnt2);
+ bcopy(cp, cp + cnt2, cnt1);
+ bcopy(tmp, cp, cnt2);
+ }
+}
+
+static void ForwardTab()
+{
+ register int x = curr->x;
+
+ if (x == cols)
+ {
+ LineFeed(2);
+ x = 0;
+ }
+ if (curr->tabs[x] && x < cols - 1)
+ x++;
+ while (x < cols - 1 && !curr->tabs[x])
+ x++;
+ GotoPos(x, curr->y);
+ curr->x = x;
+}
+
+static void BackwardTab()
+{
+ register int x = curr->x;
+
+ if (curr->tabs[x] && x > 0)
+ x--;
+ while (x > 0 && !curr->tabs[x])
+ x--;
+ GotoPos(x, curr->y);
+ curr->x = x;
+}
+
+static void ClearScreen()
+{
+ register int i;
+ register char **ppi = curr->image, **ppa = curr->attr, **ppf = curr->font;
+
+ for (i = 0; i < rows; ++i)
+ {
+ AddLineToHist(curr, ppi, ppa, ppf);
+ bclear(*ppi++, cols);
+ bzero(*ppa++, cols);
+ bzero(*ppf++, cols);
+ }
+ if (display)
+ {
+ PutStr(CL);
+ screenx = screeny = 0;
+ lp_missing = 0;
+ }
+}
+
+static void ClearFromBOS()
+{
+ register int n, y = curr->y, x = curr->x;
+
+ for (n = 0; n < y; ++n)
+ ClearInLine(1, n, 0, cols - 1);
+ ClearInLine(1, y, 0, x);
+ GotoPos(x, y);
+ RestoreAttr();
+}
+
+static void ClearToEOS()
+{
+ register int n, y = curr->y, x = curr->x;
+
+ if (!y && !x)
+ {
+ ClearScreen();
+ return;
+ }
+ if (display && CD)
+ {
+ PutStr(CD);
+ lp_missing = 0;
+ }
+ ClearInLine(!CD, y, x, cols - 1);
+ for (n = y + 1; n < rows; n++)
+ ClearInLine(!CD, n, 0, cols - 1);
+ GotoPos(x, y);
+ RestoreAttr();
+}
+
+static void ClearLine()
+{
+ register int y = curr->y, x = curr->x;
+
+ ClearInLine(1, y, 0, cols - 1);
+ GotoPos(x, y);
+ RestoreAttr();
+}
+
+static void ClearToEOL()
+{
+ register int y = curr->y, x = curr->x;
+
+ ClearInLine(1, y, x, cols - 1);
+ GotoPos(x, y);
+ RestoreAttr();
+}
+
+static void ClearFromBOL()
+{
+ register int y = curr->y, x = curr->x;
+
+ ClearInLine(1, y, 0, x);
+ GotoPos(x, y);
+ RestoreAttr();
+}
+
+static void ClearInLine(displ, y, x1, x2)
+int displ, y, x1, x2;
+{
+ register int n;
+
+ if (x1 == cols)
+ x1--;
+ if (x2 == cols)
+ x2--;
+ if ((n = x2 - x1 + 1) != 0)
+ {
+ if (displ && display)
+ {
+ if (x2 == cols - 1 && CE)
+ {
+ GotoPos(x1, y);
+ PutStr(CE);
+ if (y == screenbot)
+ lp_missing = 0;
+ }
+ else
+ DisplayLine(curr->image[y], curr->attr[y], curr->font[y],
+ blank, null, null, y, x1, x2);
+ }
+ if (curr)
+ {
+ bclear(curr->image[y] + x1, n);
+ bzero(curr->attr[y] + x1, n);
+ bzero(curr->font[y] + x1, n);
+ }
+ }
+}
+
+static void CursorRight(n)
+register int n;
+{
+ register int x = curr->x;
+
+ if (x == cols)
+ {
+ LineFeed(2);
+ x = 0;
+ }
+ if ((curr->x += n) >= cols)
+ curr->x = cols - 1;
+ GotoPos(curr->x, curr->y);
+}
+
+static void CursorUp(n)
+register int n;
+{
+ if (curr->y < curr->top) /* if above scrolling rgn, */
+ {
+ if ((curr->y -= n) < 0) /* ignore its limits */
+ curr->y = 0;
+ }
+ else
+ if ((curr->y -= n) < curr->top)
+ curr->y = curr->top;
+ GotoPos(curr->x, curr->y);
+}
+
+static void CursorDown(n)
+register int n;
+{
+ if (curr->y > curr->bot) /* if below scrolling rgn, */
+ {
+ if ((curr->y += n) > rows - 1) /* ignore its limits */
+ curr->y = rows - 1;
+ }
+ else
+ if ((curr->y += n) > curr->bot)
+ curr->y = curr->bot;
+ GotoPos(curr->x, curr->y);
+}
+
+static void CursorLeft(n)
+register int n;
+{
+ if ((curr->x -= n) < 0)
+ curr->x = 0;
+ GotoPos(curr->x, curr->y);
+}
+
+static void ASetMode(on)
+int on;
+{
+ register int i;
+
+ for (i = 0; i < curr->NumArgs; ++i)
+ {
+ switch (curr->args[i])
+ {
+ case 4:
+ curr->insert = on;
+ InsertMode(on);
+ break;
+ }
+ }
+}
+
+static void SelectRendition()
+{
+ register int i = 0, a = curr->LocalAttr;
+
+ do
+ {
+ switch (curr->args[i])
+ {
+ case 0:
+ a = 0;
+ break;
+ case 1:
+ a |= A_BD;
+ break;
+ case 2:
+ a |= A_DI;
+ break;
+ case 3:
+ a |= A_SO;
+ break;
+ case 4:
+ a |= A_US;
+ break;
+ case 5:
+ a |= A_BL;
+ break;
+ case 7:
+ a |= A_RV;
+ break;
+ case 22:
+ a &= ~(A_BD | A_SO | A_DI);
+ break;
+ case 23:
+ a &= ~A_SO;
+ break;
+ case 24:
+ a &= ~A_US;
+ break;
+ case 25:
+ a &= ~A_BL;
+ break;
+ case 27:
+ a &= ~A_RV;
+ break;
+ }
+ } while (++i < curr->NumArgs);
+ NewRendition(curr->LocalAttr = a);
+}
+
+void
+NewRendition(new)
+register int new;
+{
+ register int i, old = GlobalAttr;
+
+ if (!display || old == new)
+ return;
+ GlobalAttr = new;
+ for (i = 1; i <= A_MAX; i <<= 1)
+ {
+ if ((old & i) && !(new & i))
+ {
+ PutStr(UE);
+ PutStr(SE);
+ PutStr(ME);
+ if (new & A_DI)
+ PutStr(attrtab[ATTR_DI]);
+ if (new & A_US)
+ PutStr(attrtab[ATTR_US]);
+ if (new & A_BD)
+ PutStr(attrtab[ATTR_BD]);
+ if (new & A_RV)
+ PutStr(attrtab[ATTR_RV]);
+ if (new & A_SO)
+ PutStr(attrtab[ATTR_SO]);
+ if (new & A_BL)
+ PutStr(attrtab[ATTR_BL]);
+ return;
+ }
+ }
+ if ((new & A_DI) && !(old & A_DI))
+ PutStr(attrtab[ATTR_DI]);
+ if ((new & A_US) && !(old & A_US))
+ PutStr(attrtab[ATTR_US]);
+ if ((new & A_BD) && !(old & A_BD))
+ PutStr(attrtab[ATTR_BD]);
+ if ((new & A_RV) && !(old & A_RV))
+ PutStr(attrtab[ATTR_RV]);
+ if ((new & A_SO) && !(old & A_SO))
+ PutStr(attrtab[ATTR_SO]);
+ if ((new & A_BL) && !(old & A_BL))
+ PutStr(attrtab[ATTR_BL]);
+}
+
+void
+SaveSetAttr(newattr, newcharset)
+int newattr, newcharset;
+{
+ NewRendition(newattr);
+ NewCharset(newcharset);
+}
+
+void
+RestoreAttr()
+{
+ NewRendition(curr->LocalAttr);
+ NewCharset(curr->charsets[curr->LocalCharset]);
+}
+
+static void FillWithEs()
+{
+ register int i;
+ register char *p, *ep;
+
+ curr->y = curr->x = 0;
+ for (i = 0; i < rows; ++i)
+ {
+ bzero(curr->attr[i], cols);
+ bzero(curr->font[i], cols);
+ p = curr->image[i];
+ ep = p + cols;
+ while (p < ep)
+ *p++ = 'E';
+ }
+ if (display)
+ Redisplay(0);
+}
+
+/*
+ * if cur_only, we only redisplay current line, as a full refresh is
+ * too expensive.
+ */
+void Redisplay(cur_only)
+int cur_only;
+{
+ register int i, stop;
+
+ PutStr(CL);
+ screenx = screeny = 0;
+ lp_missing = 0;
+ stop = rows; i = 0;
+ if (cur_only)
+ {
+ i = stop = curr->y;
+ stop++;
+ }
+ for (; i < stop; ++i)
+ {
+ if (in_ovl)
+ (*ovl_RedisplayLine)(i, 0, cols - 1, 1);
+ else
+ DisplayLine(blank, null, null, curr->image[i], curr->attr[i],
+ curr->font[i], i, 0, cols - 1);
+ }
+ if (!in_ovl)
+ {
+ GotoPos(curr->x, curr->y);
+ NewRendition(curr->LocalAttr);
+ NewCharset(curr->charsets[curr->LocalCharset]);
+ }
+}
+
+void
+DisplayLine(os, oa, of, s, as, fs, y, from, to)
+int from, to, y;
+register char *os, *oa, *of, *s, *as, *fs;
+{
+ register int x;
+ int last2flag = 0, delete_lp = 0;
+
+ if (!LP && y == screenbot && to == cols - 1)
+ if (lp_missing
+ || s[to] != os[to] || as[to] != oa[to] || of[to] != fs[to])
+ {
+ if ((IC || IM) && (from < to || !in_ovl))
+ {
+ if ((to -= 2) < from - 1)
+ from--;
+ last2flag = 1;
+ lp_missing = 0;
+ }
+ else
+ {
+ to--;
+ delete_lp = (CE || DC || CDC);
+ lp_missing = (s[to] != ' ' || as[to] || fs[to]);
+ }
+ }
+ else
+ to--;
+ for (x = from; x <= to; ++x)
+ {
+ if (s[x] == os[x] && as[x] == oa[x] && of[x] == fs[x])
+ continue;
+ GotoPos(x, y);
+ NewRendition(as[x]);
+ NewCharset(fs[x]);
+ PUTCHAR(s[x]);
+ }
+ if (last2flag)
+ {
+ GotoPos(x, y);
+ NewRendition(as[x + 1]);
+ NewCharset(fs[x + 1]);
+ PUTCHAR(s[x + 1]);
+ GotoPos(x, y);
+ NewRendition(as[x]);
+ NewCharset(fs[x]);
+ INSERTCHAR(s[x]);
+ }
+ else if (delete_lp)
+ {
+ if (DC)
+ PutStr(DC);
+ else if (CDC)
+ CPutStr(CDC, 1);
+ else if (CE)
+ PutStr(CE);
+ }
+}
+
+void
+RefreshLine(y, from, to)
+int y, from, to;
+{
+ char *oi = null;
+
+ if (CE && to == screenwidth-1)
+ {
+ GotoPos(from, y);
+ PutStr(CE);
+ oi = blank;
+ }
+ if (in_ovl)
+ (*ovl_RedisplayLine)(y, from, to, (oi == blank));
+ else
+ DisplayLine(oi, null, null, curr->image[y], curr->attr[y],
+ curr->font[y], y, from, to);
+}
+
+static void RedisplayLine(os, oa, of, y, from, to)
+int from, to, y;
+char *os, *oa, *of;
+{
+ DisplayLine(os, oa, of, curr->image[y], curr->attr[y],
+ curr->font[y], y, from, to);
+ NewRendition(curr->LocalAttr);
+ NewCharset(curr->charsets[curr->LocalCharset]);
+}
+
+void
+FixLP(x2, y2)
+register int x2, y2;
+{
+ register struct win *p = curr;
+
+ GotoPos(x2, y2);
+ SaveSetAttr(p->attr[y2][x2], p->font[y2][x2]);
+ PUTCHAR(p->image[y2][x2]);
+ RestoreAttr();
+ lp_missing = 0;
+}
+
+void
+CheckLP(n_ch)
+char n_ch;
+{
+ register int y = screenbot, x = cols - 1;
+ register char n_at, n_fo, o_ch, o_at, o_fo;
+
+ o_ch = curr->image[y][x];
+ o_at = curr->attr[y][x];
+ o_fo = curr->font[y][x];
+
+ n_at = curr->LocalAttr;
+ n_fo = curr->charsets[curr->LocalCharset];
+
+ lp_missing = 0;
+ if (n_ch == o_ch && n_at == o_at && n_fo == o_fo)
+ {
+ return;
+ }
+ if (n_ch != ' ' || n_at || n_fo)
+ lp_missing = 1;
+ if (o_ch != ' ' || o_at || o_fo)
+ {
+ if (DC)
+ PutStr(DC);
+ else if (CDC)
+ CPutStr(CDC, 1);
+ else if (CE)
+ PutStr(CE);
+ else
+ lp_missing = 1;
+ }
+}
+
+static void FindAKA()
+{
+ register char *cp, *line, ch;
+ register struct win *wp = curr;
+ register int len = strlen(wp->cmd);
+ int y;
+
+ y = (wp->autoaka > 0 && wp->autoaka <= wp->height) ? wp->autoaka - 1 : wp->y;
+ cols = wp->width;
+ try_line:
+ cp = line = wp->image[y];
+ if (wp->autoaka > 0 && (ch = *wp->cmd) != '\0')
+ {
+ for (;;)
+ {
+ if ((cp = index(cp, ch)) != NULL
+ && !strncmp(cp, wp->cmd, len))
+ break;
+ if (!cp || ++cp - line >= cols - len)
+ {
+ if (++y == wp->autoaka && y < rows)
+ goto try_line;
+ return;
+ }
+ }
+ cp += len;
+ }
+ for (len = cols - (cp - line); len && *cp == ' '; len--, cp++)
+ ;
+ if (len)
+ {
+ if (wp->autoaka > 0 && (*cp == '!' || *cp == '%' || *cp == '^'))
+ wp->autoaka = -1;
+ else
+ wp->autoaka = 0;
+ line = wp->cmd + wp->akapos;
+ while (len && *cp != ' ')
+ {
+ if ((*line++ = *cp++) == '/')
+ line = wp->cmd + wp->akapos;
+ len--;
+ }
+ *line = '\0';
+ }
+ else
+ wp->autoaka = 0;
+}
+
+
+/* We dont use HS status line with Input.
+ * If we would use it, then we should check e_tgetflag("es") if
+ * we are allowed to use esc sequences there.
+ * For now, we hope that Goto(,,STATLINE,0) brings us in the bottom
+ * line. jw.
+ */
+
+static char inpbuf[101];
+static int inplen;
+static int inpmaxlen;
+static char *inpstring;
+static int inpstringlen;
+static void (*inpfinfunc)();
+
+void
+Input(istr, len, finfunc)
+char *istr;
+int len;
+void (*finfunc)();
+{
+ int maxlen;
+
+ inpstring = istr;
+ inpstringlen = strlen(istr);
+ if (len > 100)
+ len = 100;
+ maxlen = screenwidth - inpstringlen;
+ if (!LP && STATLINE == screenbot)
+ maxlen--;
+ if (len > maxlen)
+ len = maxlen;
+ if (len < 2)
+ {
+ Msg(0, "Width too small");
+ return;
+ }
+ inpmaxlen = len;
+ inpfinfunc = finfunc;
+ InitOverlayPage(process_inp_input, inpRedisplayLine, (int (*)())0, 1);
+ inplen = 0;
+ GotoPos(0, STATLINE);
+ if (CE)
+ PutStr(CE);
+ else
+ {
+ DisplayLine(curr->image[screeny], curr->attr[screeny],
+ curr->font[screeny],
+ blank, null, null, screeny, 0, cols - 1);
+ }
+ inpRedisplayLine(STATLINE, 0, inpstringlen - 1, 0);
+ GotoPos(inpstringlen, STATLINE);
+}
+
+static void
+process_inp_input(ppbuf, plen)
+char **ppbuf;
+int *plen;
+{
+ int len, x;
+ char *pbuf;
+ char ch;
+
+ if (ppbuf == 0)
+ {
+ AbortInp();
+ return;
+ }
+ x = inpstringlen+inplen;
+ len = *plen;
+ pbuf = *ppbuf;
+ while (len)
+ {
+ ch = *pbuf++;
+ len--;
+ if (ch >= ' ' && ch <= '~' && inplen < inpmaxlen)
+ {
+ inpbuf[inplen++] = ch;
+ GotoPos(x, STATLINE);
+ SaveSetAttr(A_SO, ASCII);
+ PUTCHAR(ch);
+ x++;
+ }
+ else if ((ch == '\b' || ch == 0177) && inplen > 0)
+ {
+ inplen--;
+ x--;
+ GotoPos(x, STATLINE);
+ SaveSetAttr(0, ASCII);
+ PUTCHAR(' ');
+ GotoPos(x, STATLINE);
+ }
+ else if (ch == '\004' || ch == '\003' || ch == '\000' || ch == '\n' || ch == '\r')
+ {
+ if (ch != '\n' && ch != '\r')
+ inplen = 0;
+ inpbuf[inplen] = 0;
+ AbortInp(); /* redisplays... */
+ (*inpfinfunc)(inpbuf, inplen);
+ break;
+ }
+ }
+ *ppbuf = pbuf;
+ *plen = len;
+}
+
+static void
+AbortInp()
+{
+ in_ovl = 0; /* So we can use RefreshLine() */
+ RefreshLine(STATLINE, 0, screenwidth-1);
+ ExitOverlayPage();
+}
+
+static void
+inpRedisplayLine(y, xs, xe, isblank)
+int y, xs, xe, isblank;
+{
+ int q, r, s, l, v;
+
+ if (y != STATLINE)
+ return;
+ inpbuf[inplen] = 0;
+ GotoPos(xs,y);
+ q = xs;
+ v = xe - xs + 1;
+ s = 0;
+ r = inpstringlen;
+ if (v > 0 && q < r)
+ {
+ SaveSetAttr(A_SO, ASCII);
+ l = v;
+ if (l > r-q)
+ l = r-q;
+ printf("%-*.*s", l, l, inpstring + q - s);
+ q += l;
+ v -= l;
+ }
+ s = r;
+ r += inplen;
+ if (v > 0 && q < r)
+ {
+ SaveSetAttr(A_SO, ASCII);
+ l = v;
+ if (l > r-q)
+ l = r-q;
+ printf("%-*.*s", l, l, inpbuf + q - s);
+ q += l;
+ v -= l;
+ }
+ s = r;
+ r = screenwidth;
+ if (!isblank && v > 0 && q < r)
+ {
+ SaveSetAttr(0, ASCII);
+ l = v;
+ if (l > r-q)
+ l = r-q;
+ printf("%-*.*s", l, l, "");
+ q += l;
+ }
+ SetLastPos(q, y);
+}
+
+static void
+AKAfin(buf, len)
+char *buf;
+int len;
+{
+ if (len)
+ {
+ strcpy(curr->cmd + curr->akapos, buf);
+ }
+}
+
+void
+InputAKA()
+{
+ void Input(), AKAfin();
+
+ Input("Set window's a.k.a. to: ", 20, AKAfin);
+}
+
+static void
+Colonfin(buf, len)
+char *buf;
+int len;
+{
+ if (len)
+ RcLine(buf);
+}
+
+void
+InputColon()
+{
+ void Input(), Colonfin();
+
+ Input(":", 100, Colonfin);
+}
+
+void
+MakeBlankLine(p, n)
+register char *p;
+register int n;
+{
+ while (n--)
+ *p++ = ' ';
+}
+
+void
+MakeStatus(msg)
+char *msg;
+{
+ register char *s, *t;
+ register int max, ti;
+
+ SetCurr(fore);
+ display = 1;
+ if (!(max = HS))
+ {
+ max = !LP ? cols - 1 : cols;
+ }
+ if (status)
+ {
+ if (!BellDisplayed)
+ {
+ ti = time((time_t *) 0) - TimeDisplayed;
+ if (ti < MsgMinWait)
+ sleep(MsgMinWait - ti);
+ }
+ RemoveStatus();
+ }
+ for (s = t = msg; *s && t - msg < max; ++s)
+ if (*s == BELL)
+ PutStr(BL);
+ else if (*s >= ' ' && *s <= '~')
+ *t++ = *s;
+ *t = '\0';
+ if (t > msg)
+ {
+ strncpy(LastMsg, msg, maxwidth);
+ status = 1;
+ status_lastx = screenx;
+ status_lasty = screeny;
+ StatLen = t - msg;
+ if (!HS)
+ {
+ GotoPos(0, STATLINE);
+ SaveSetAttr(A_SO, ASCII);
+ InsertMode(0);
+ printf("%s", msg);
+ screenx = -1;
+ }
+ else
+ {
+ debug("HS:");
+ SaveSetAttr(0, ASCII);
+ InsertMode(0);
+ CPutStr(TS, 0);
+ printf("%s", msg);
+ PutStr(FS);
+ }
+ (void) fflush(stdout);
+ (void) time(&TimeDisplayed);
+ }
+}
+
+void
+RemoveStatus()
+{
+ if (!status)
+ return;
+ status = 0;
+ BellDisplayed = 0;
+ SetCurr(fore);
+ display = 1;
+ if (!HS)
+ {
+ GotoPos(0, STATLINE);
+ if (in_ovl)
+ (*ovl_RedisplayLine)(STATLINE, 0, StatLen - 1, 0);
+ else
+ RedisplayLine(null, null, null, STATLINE, 0, StatLen - 1);
+ GotoPos(status_lastx, status_lasty);
+ }
+ else
+ {
+ SaveSetAttr(0, ASCII);
+ PutStr(DS);
+ }
+}
+
+void
+ClearDisplay()
+{
+ PutStr(CL);
+ screeny = screenx = 0;
+ fflush(stdout);
+}
+
+static void SetCurr(wp)
+struct win *wp;
+{
+ curr = wp;
+ cols = curr->width;
+ rows = curr->height;
+ display = curr->active;
+}
+
+void
+InitOverlayPage(pro, red, rewrite, blockfore)
+void (*pro)();
+void (*red)();
+int (*rewrite)();
+int blockfore;
+{
+ RemoveStatus();
+ SetOvlCurr();
+ ChangeScrollRegion(0, screenheight - 1);
+ SetFlow(1);
+ ovl_process = pro;
+ ovl_RedisplayLine = red;
+ ovl_Rewrite = rewrite;
+ ovl_blockfore = blockfore;
+ curr->active = 0;
+ in_ovl = 1;
+}
+
+void
+ExitOverlayPage()
+{
+ ChangeScrollRegion(curr->top, curr->bot);
+ GotoPos(curr->x, curr->y);
+ RestoreAttr();
+ SetFlow(curr->flow & FLOW_NOW);
+ curr->active = 1;
+ in_ovl = 0;
+}
+
+void
+SetOvlCurr()
+{
+ SetCurr(fore);
+ SaveSetAttr(0, ASCII);
+ InsertMode(0);
+ display = 1;
+}
+
+void
+SetLastPos(x,y)
+int x,y;
+{
+ screenx = x;
+ screeny = y;
+}
+
+void
+WSresize(width, height)
+int width, height;
+{
+ debug2("(display=%d:WSresize says:'%s'\n", display, tgoto(WS, width, height));
+ PutStr(tgoto(WS, width, height));
+}
+
+void
+ChangeScrollRegion(top, bot)
+int top, bot;
+{
+ if (display == 0)
+ return;
+ if (CS == 0)
+ {
+ screentop = 0;
+ screenbot = screenheight - 1;
+ return;
+ }
+ if (top == screentop && bot == screenbot)
+ return;
+ debug2("ChangeScrollRegion: (%d - %d)\n", top, bot);
+ PutStr(tgoto(CS, bot, top));
+ screentop = top;
+ screenbot = bot;
+ screeny = screenx = -1; /* Just in case... */
+}
+
+
+void AddLineToHist(wp, pi, pa, pf)
+struct win *wp;
+char **pi, **pa, **pf;
+{
+ register char *q;
+
+ if (wp->histheight == 0)
+ return;
+ q = *pi; *pi = wp->ihist[wp->histidx]; wp->ihist[wp->histidx] = q;
+ q = *pa; *pa = wp->ahist[wp->histidx]; wp->ahist[wp->histidx] = q;
+ q = *pf; *pf = wp->fhist[wp->histidx]; wp->fhist[wp->histidx] = q;
+ if (++wp->histidx >= wp->histheight)
+ wp->histidx = 0;
+}
+
+
+/*
+ *
+ * Termcap routines that use our extra_incap
+ *
+ */
+
+/* findcap:
+ * cap = capability we are looking for
+ * tepp = pointer to bufferpointer
+ * n = size of buffer (0 = infinity)
+ */
+
+char *
+findcap(cap, tepp, n)
+char *cap;
+char **tepp;
+int n;
+{
+ char *tep;
+ char c, *p, *cp;
+ int mode; /* mode: 0=LIT 1=^ 2=\x 3,4,5=\nnn */
+ int num = 0, capl;
+
+ if (!extra_incap)
+ return (0);
+ tep = *tepp;
+ capl = strlen(cap);
+ cp = 0;
+ mode = 0;
+ for (p = extra_incap; *p; )
+ {
+ if (strncmp(p, cap, capl) == 0)
+ {
+ p+=capl;
+ c = *p;
+ if (c && c != ':' && c != '@')
+ p++;
+ if (c == 0 || c == '@' || c == '=' || c == ':' || c == '#')
+ cp = tep;
+ }
+ while (c = *p)
+ {
+ p++;
+ if (mode == 0)
+ {
+ if (c == ':')
+ break;
+ if (c == '^')
+ mode = 1;
+ if (c == '\\')
+ mode = 2;
+ }
+ else if (mode == 1)
+ {
+ c = c & 0x1f;
+ mode = 0;
+ }
+ else if (mode == 2)
+ {
+ switch(c)
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ mode = 3;
+ num = 0;
+ break;
+ case 'E':
+ c = 27;
+ break;
+ case 'n':
+ c = '\n';
+ break;
+ case 'r':
+ c = '\r';
+ break;
+ case 't':
+ c = '\t';
+ break;
+ case 'b':
+ c = '\b';
+ break;
+ case 'f':
+ c = '\f';
+ break;
+ }
+ if (mode == 2)
+ mode = 0;
+ }
+ if (mode > 2)
+ {
+ num = num * 8 + (c - '0');
+ if (mode++ == 5 || (*p < '0' || *p > '9'))
+ {
+ c = num;
+ mode = 0;
+ }
+ }
+ if (mode)
+ continue;
+
+ if (cp && n != 1)
+ {
+ *cp++ = c;
+ n--;
+ }
+ }
+ if (cp)
+ {
+ *cp++ = 0;
+ *tepp = cp;
+ debug2("'%s' found in extra_incap -> %s\n", cap, tep);
+ return(tep);
+ }
+ }
+ return(0);
+}
+
+static char *
+e_tgetstr(cap, tepp)
+char *cap;
+char **tepp;
+{
+ char *tep;
+ if (tep = findcap(cap, tepp, 0))
+ return((*tep == '@') ? 0 : tep);
+ return (tgetstr(cap, tepp));
+}
+
+static int
+e_tgetflag(cap)
+char *cap;
+{
+ char buf[2], *bufp;
+ char *tep;
+ bufp = buf;
+ if (tep = findcap(cap, &bufp, 2))
+ return((*tep == '@') ? 0 : 1);
+ return (tgetflag(cap));
+}
+
+static int
+e_tgetnum(cap)
+char *cap;
+{
+ char buf[20], *bufp;
+ char *tep, c;
+ int res, base = 10;
+
+ bufp = buf;
+ if (tep = findcap(cap, &bufp, 20))
+ {
+ c = *tep;
+ if (c == '@')
+ return(-1);
+ if (c == '0')
+ base = 8;
+ res = 0;
+ while ((c = *tep++) >= '0' && c <= '9')
+ res = res * base + (c - '0');
+ return(res);
+ }
+ return (tgetnum(cap));
+}
projects / unix-history / commitdiff