4.3BSD/usr/contrib/jove/screen.c
/*************************************************************************
* This program is copyright (C) 1985, 1986 by Jonathan Payne. It is *
* provided to you without charge for use only on a licensed Unix *
* system. You may copy JOVE provided that this notice is included with *
* the copy. You may not sell copies of this program or versions *
* modified for use on microcomputer systems, unless the copies are *
* included with a Unix system distribution and the source is provided. *
*************************************************************************/
#include "jove.h"
#include "io.h"
#include "ctype.h"
#include "temp.h"
#include "termcap.h"
extern int BufSize;
int OkayAbort,
tabstop = 8;
int (*TTins_line)(),
(*TTdel_line)();
struct scrimage
*DesiredScreen = 0,
*PhysScreen = 0;
struct screenline *Screen = 0, /* the screen (a bunch of screenline) */
*Savelines = 0, /* another bunch (LI of them) */
*Curline = 0; /* current line */
char *cursor, /* offset into current Line */
*cursend;
int CapCol,
CapLine,
i_line,
i_col;
make_scr()
{
register int i;
register struct screenline *ns;
register char *nsp;
#ifdef RESHAPING
/* In case we are RESHAPING the window! */
if (DesiredScreen)
free((char *) DesiredScreen);
if (PhysScreen)
free((char *) PhysScreen);
if (Savelines)
free((char *) Savelines);
if (Screen) {
ns = Screen;
for (i = 0; i < LI; i++)
free((ns++)->s_line);
free((char *) Screen);
}
#endif RESHAPING
DesiredScreen = (struct scrimage *) malloc((unsigned) LI * sizeof (struct scrimage));
PhysScreen = (struct scrimage *) malloc((unsigned) LI * sizeof (struct scrimage));
Savelines = (struct screenline *)
malloc((unsigned) LI * sizeof(struct screenline));
ns = Screen = (struct screenline *)
malloc((unsigned) LI * sizeof(struct screenline));
nsp = (char *) malloc((unsigned)CO * LI);
if (nsp == 0) {
printf("\n\rCannot malloc screen!\n");
finish(1);
}
for (i = 0; i < LI; i++) {
ns->s_line = nsp;
nsp += CO;
ns->s_length = nsp - 1; /* End of Line */
ns++;
}
cl_scr(0);
}
clrline(cp1, cp2)
register char *cp1,
*cp2;
{
while (cp1 <= cp2)
*cp1++ = ' ';
}
#define sputc(c) ((*cursor != (char) (c)) ? dosputc(c) : (cursor++, i_col++))
#define soutputc(c) if (--n <= 0) break; else sputc(c)
cl_eol()
{
if (cursor > cursend)
return;
if (cursor < Curline->s_length) {
if (CE) {
Placur(i_line, i_col);
putpad(CE, 1);
clrline(cursor, Curline->s_length);
} else {
/* Ugh. The slow way for dumb terminals. */
register char *savecp = cursor;
while (cursor <= Curline->s_length)
sputc(' ');
cursor = savecp;
}
Curline->s_length = cursor;
}
}
cl_scr(doit)
{
register int i;
register struct screenline *sp = Screen;
for (i = 0; i < LI; i++, sp++) {
clrline(sp->s_line, sp->s_length);
sp->s_length = sp->s_line;
PhysScreen[i].s_id = 0;
}
if (doit) {
putpad(CL, LI);
CapCol = CapLine = 0;
UpdMesg++;
}
}
#ifdef ID_CHAR
extern int IN_INSmode;
#endif
/* Output one character (if necessary) at the current position */
dosputc(c)
register char c;
{
if (*cursor != c) {
#ifdef ID_CHAR
if (IN_INSmode)
INSmode(0);
#endif
if (i_line != CapLine || i_col != CapCol)
Placur(i_line, i_col);
if (UL && (c & 0177) == '_' && (*cursor & 0177) != ' ')
putstr(" \b"); /* Erase so '_' looks right. */
*cursor++ = c;
putchar(c & 0177);
CapCol++;
i_col++;
} else {
cursor++;
i_col++;
}
}
/* Write `line' at the current position of `cursor'. Stop when we
reach the end of the screen. Aborts if there is a character
waiting. */
swrite(line, inversep, abortable)
register char *line;
register int abortable;
{
register int c;
int col = i_col,
aborted = 0;
register int n = cursend - cursor;
int or_byte = inversep ? 0200 : 0,
thebyte;
if (n <= 0)
return 1;
OkayAbort = 0;
while (c = *line++) {
if (abortable && OkayAbort) {
OkayAbort = NO;
if (InputPending = charp()) {
aborted = 1;
break;
}
}
if (c == '\t') {
int nchars;
nchars = (tabstop - (col % tabstop));
col += nchars;
thebyte = (' ' | or_byte);
while (nchars--)
soutputc(thebyte);
if (n <= 0)
break;
} else if (isctrl(c)) {
thebyte = ('^' | or_byte);
soutputc(thebyte);
thebyte = (((c == '\177') ? '?' : c + '@') | or_byte);
soutputc(thebyte);
col += 2;
} else {
thebyte = (c | or_byte);
soutputc(thebyte);
col++;
}
}
if (n <= 0) {
thebyte = ('!' | or_byte);
sputc(thebyte);
}
if (cursor > Curline->s_length)
Curline->s_length = cursor;
return !aborted;
}
/* This is for writing a buffer line to the screen. This is to
minimize the amount of copying from one buffer to another buffer.
This gets the info directly from the disk buffers. */
BufSwrite(linenum)
{
char *bp;
register int n = cursend - cursor,
col = 0,
c;
int StartCol = DesiredScreen[linenum].s_offset,
visspace = DesiredScreen[linenum].s_window->w_visspace,
aborted = 0;
bp = lcontents(DesiredScreen[linenum].s_lp);
if (*bp) for (;;) {
if (col >= StartCol) {
DesiredScreen[linenum].s_offset = col;
break;
}
c = *bp++ & 0177;
if (c == '\t')
col += (tabstop - (col % tabstop));
else if (isctrl(c))
col += 2;
else
col++;
}
OkayAbort = 0;
while (c = (*bp++ & 0177)) {
if (OkayAbort) {
OkayAbort = NO;
if (InputPending = charp()) {
aborted = 1;
break;
}
}
if (c == '\t') {
int nchars = (tabstop - (col % tabstop));
col += nchars;
if (visspace) {
soutputc('>');
nchars--;
}
while (--nchars >= 0)
soutputc(' ');
if (n <= 0)
break;
} else if (isctrl(c)) {
soutputc('^');
soutputc((c == '\177') ? '?' : c + '@');
col += 2;
} else {
if (visspace && c == ' ')
c = '_';
soutputc(c);
col++;
}
}
if (n <= 0)
sputc('!');
if (cursor > Curline->s_length)
Curline->s_length = cursor;
return !aborted; /* Didn't abort */
}
i_set(nline, ncol)
register int nline,
ncol;
{
Curline = &Screen[nline];
cursor = Curline->s_line + ncol;
cursend = &Curline->s_line[CO - 1];
i_line = nline;
i_col = ncol;
}
/* Insert `num' lines a top, but leave all the lines BELOW `bottom'
alone (at least they won't look any different when we are done).
This changes the screen array AND does the physical changes. */
v_ins_line(num, top, bottom)
{
register int i;
/* Save the screen pointers. */
for(i = 0; i < num && top + i <= bottom; i++)
Savelines[i] = Screen[bottom - i];
/* Num number of bottom lines will be lost.
Copy everything down num number of times. */
for (i = bottom; i > top && i-num >= 0; i--)
Screen[i] = Screen[i - num];
/* Restore the saved ones, making them blank. */
for (i = 0; i < num; i++) {
Screen[top + i] = Savelines[i];
clrline(Screen[top + i].s_line, Screen[top + i].s_length);
Screen[top + i].s_length = Screen[top + i].s_line;
}
(*TTins_line)(top, bottom, num);
}
/* Delete `num' lines starting at `top' leaving the lines below `bottom'
alone. This updates the internal image as well as the physical image. */
v_del_line(num, top, bottom)
{
register int i,
bot;
bot = bottom;
/* Save the lost lines. */
for (i = 0; i < num && top + i <= bottom; i++)
Savelines[i] = Screen[top + i];
/* Copy everything up num number of lines. */
for (i = top; num + i <= bottom; i++)
Screen[i] = Screen[i + num];
/* Restore the lost ones, clearing them. */
for (i = 0; i < num; i++) {
Screen[bottom - i] = Savelines[i];
clrline(Screen[bot].s_line, Screen[bot].s_length);
Screen[bot].s_length = Screen[bot].s_line;
bot--;
}
(*TTdel_line)(top, bottom, num);
}
/* The cursor optimization happens here. You may decide that this
is going too far with cursor optimization, or perhaps it should
limit the amount of checking to when the output speed is slow.
What ever turns you on ... */
private struct cursaddr {
int c_numchars,
(*c_proc)();
};
private char *Cmstr;
private struct cursaddr *HorMin,
*VertMin,
*DirectMin;
private ForMotion(),
ForTab(),
BackMotion(),
RetTab(),
DownMotion(),
UpMotion(),
GoDirect(),
HomeGo(),
BottomUp();
private struct cursaddr WarpHor[] = {
0, ForMotion,
0, ForTab,
0, BackMotion,
0, RetTab
};
private struct cursaddr WarpVert[] = {
0, DownMotion,
0, UpMotion
};
private struct cursaddr WarpDirect[] = {
0, GoDirect,
0, HomeGo,
0, BottomUp
};
#undef FORWARD
#define FORWARD 0 /* Move forward */
#define FORTAB 1 /* Forward using tabs */
#undef BACKWARD
#define BACKWARD 2 /* Move backward */
#define RETFORWARD 3 /* Beginning of line and then tabs */
#define NUMHOR 4
#define DOWN 0 /* Move down */
#define UPMOVE 1 /* Move up */
#define NUMVERT 2
#define DIRECT 0 /* Using CM */
#define HOME 1 /* HOME */
#define LOWER 2 /* Lower Line */
#define NUMDIRECT 3
#define home() Placur(0, 0)
#define LowLine() putpad(LL, 1), CapLine = ILI, CapCol = 0
#define PrintHo() putpad(HO, 1), CapLine = CapCol = 0
int phystab = 8;
private
GoDirect(line, col)
register int line,
col;
{
putpad(Cmstr, 1);
CapLine = line;
CapCol = col;
}
private
RetTab(col)
register int col;
{
putchar('\r');
CapCol = 0;
ForTab(col);
}
private
HomeGo(line, col)
{
PrintHo();
DownMotion(line);
ForTab(col);
}
private
BottomUp(line, col)
register int line,
col;
{
LowLine();
UpMotion(line);
ForTab(col);
}
/* Tries to move forward using tabs (if possible). It tabs to the
closest tabstop which means it may go past 'destcol' and backspace
to it. */
private
ForTab(destcol)
int destcol;
{
register int tabgoal,
ntabs,
tabstp = phystab;
if (TABS && (tabstp > 0)) {
tabgoal = destcol + (tabstp / 2);
tabgoal -= (tabgoal % tabstp);
/* Don't tab to last place or else it is likely to screw up. */
if (tabgoal >= CO)
tabgoal -= tabstp;
ntabs = (tabgoal / tabstp) - (CapCol / tabstp);
while (--ntabs >= 0)
putchar('\t');
CapCol = tabgoal;
}
if (CapCol > destcol)
BackMotion(destcol);
else if (CapCol < destcol)
ForMotion(destcol);
}
private
ForMotion(destcol)
register int destcol;
{
register int nchars = destcol - CapCol;
register char *cp = &Screen[CapLine].s_line[CapCol];
while (--nchars >= 0)
putchar(*cp++ & 0177);
CapCol = destcol;
}
private
BackMotion(destcol)
register int destcol;
{
register int nchars = CapCol - destcol;
if (BC)
while (--nchars >= 0)
putpad(BC, 1);
else
while (--nchars >= 0)
putchar('\b');
CapCol = destcol;
}
private
DownMotion(destline)
register int destline;
{
register int nlines = destline - CapLine;
while (--nlines >= 0)
putchar('\n');
CapLine = destline;
}
private
UpMotion(destline)
register int destline;
{
register int nchars = CapLine - destline;
while (--nchars >= 0)
putpad(UP, 1);
CapLine = destline;
}
#ifdef ID_CHAR
static int EIlen;
#endif
extern int IMlen;
InitCM()
{
HOlen = HO ? strlen(HO) : 1000;
LLlen = LL ? strlen(LL) : 1000;
UPlen = UP ? strlen(UP) : 1000;
#ifdef ID_CHAR
if (EI)
EIlen = strlen(EI);
#endif
}
Placur(line, col)
{
int dline, /* Number of lines to move */
dcol; /* Number of columns to move */
register int best,
i;
register struct cursaddr *cp;
int xtracost = 0; /* Misc addition to cost. */
#define CursMin(which,addrs,max) \
for (best = 0, cp = &addrs[1], i = 1; i < max; i++, cp++) \
if (cp->c_numchars < addrs[best].c_numchars) \
best = i; \
which = &addrs[best];
if (line == CapLine && col == CapCol)
return; /* We are already there. */
dline = line - CapLine;
dcol = col - CapCol;
#ifdef ID_CHAR
if (IN_INSmode && MI)
xtracost = EIlen + IMlen;
/* If we're already in insert mode, it is likely that we will
want to be in insert mode again, after the insert. */
#endif
/* Number of characters to move horizontally for each case.
1: Just move forward by typing the right character on the screen.
2: Print the correct number of back spaces.
3: Try tabbing to the correct place.
4: Try going to the beginning of the line, and then tab. */
if (dcol == 1 || dcol == 0) { /* Most common case. */
HorMin = &WarpHor[FORWARD];
HorMin->c_numchars = dcol + xtracost;
} else {
WarpHor[FORWARD].c_numchars = dcol >= 0 ? dcol + xtracost : 1000;
WarpHor[BACKWARD].c_numchars = dcol < 0 ? -(dcol + xtracost) : 1000;
WarpHor[FORTAB].c_numchars = dcol >= 0 && TABS ?
ForNum(CapCol, col) + xtracost : 1000;
WarpHor[RETFORWARD].c_numchars = (xtracost + 1 + (TABS ? ForNum(0, col) : col));
/* Which is the shortest of the bunch */
CursMin(HorMin, WarpHor, NUMHOR);
}
/* Moving vertically is more simple. */
WarpVert[DOWN].c_numchars = dline >= 0 ? dline : 1000;
WarpVert[UPMOVE].c_numchars = dline < 0 ? ((-dline) * UPlen) : 1000;
/* Which of these is simpler */
CursMin(VertMin, WarpVert, NUMVERT);
/* Homing first and lowering first are considered
direct motions.
Homing first's total is the sum of the cost of homing
and the sum of tabbing (if possible) to the right. */
if (VertMin->c_numchars + HorMin->c_numchars <= 3) {
DirectMin = &WarpDirect[DIRECT]; /* A dummy ... */
DirectMin->c_numchars = 100;
} else {
WarpDirect[DIRECT].c_numchars = CM ?
strlen(Cmstr = tgoto(CM, col, line)) : 1000;
WarpDirect[HOME].c_numchars = HOlen + line +
WarpHor[RETFORWARD].c_numchars;
WarpDirect[LOWER].c_numchars = LLlen + ((ILI - line) * UPlen) +
WarpHor[RETFORWARD].c_numchars;
CursMin(DirectMin, WarpDirect, NUMDIRECT);
}
if (HorMin->c_numchars + VertMin->c_numchars < DirectMin->c_numchars) {
if (line != CapLine)
(*VertMin->c_proc)(line);
if (col != CapCol) {
#ifdef ID_CHAR
if (IN_INSmode) /* We may use real characters ... */
INSmode(0);
#endif
(*HorMin->c_proc)(col);
}
} else {
#ifdef ID_CHAR
if (IN_INSmode && !MI)
INSmode(0);
#endif
(*DirectMin->c_proc)(line, col);
}
}
#define abs(x) ((x) >= 0 ? (x) : -(x))
ForNum(from, to)
register int from;
{
register int tabgoal,
tabstp = phystab;
int numchars = 0;
if (from >= to)
return from - to;
if (TABS && (tabstp > 0)) {
tabgoal = to + (tabstp / 2);
tabgoal -= (tabgoal % tabstp);
if (tabgoal >= CO)
tabgoal -= tabstp;
numchars = (tabgoal / tabstop) - (from / tabstp);
from = tabgoal;
}
return numchars + abs(from - to);
}
#ifdef WIRED_TERMS
BGi_lines(top, bottom, num)
{
printf("\033[%d;%dr\033[%dL\033[r", top + 1, bottom + 1, num);
CapCol = CapLine = 0;
}
SUNi_lines(top, bottom, num)
{
Placur(bottom - num + 1, 0);
printf("\033[%dM", num);
Placur(top, 0);
printf("\033[%dL", num);
}
C100i_lines(top, bottom, num)
{
if (num <= 1) {
GENi_lines(top, bottom, num);
return;
}
printf("\033v%c%c%c%c", ' ', ' ', ' ' + bottom + 1, ' ' + CO);
CapLine = CapCol = 0;
Placur(top, 0);
while (num--)
putpad(AL, ILI - CapLine);
printf("\033v%c%c%c%c", ' ', ' ', ' ' + LI, ' ' + CO);
CapLine = CapCol = 0;
}
#endif WIRED_TERMS
GENi_lines(top, bottom, num)
{
register int i;
if (CS) {
printf(tgoto(CS, bottom, top));
CapCol = CapLine = 0;
Placur(top, 0);
for (i = 0; i < num; i++)
putpad(SR, bottom - top);
printf(tgoto(CS, ILI, 0));
CapCol = CapLine = 0;
} else {
Placur(bottom - num + 1, 0);
if (M_DL && (num > 1)) {
char minibuf[16];
sprintf(minibuf, M_DL, num);
putpad(minibuf, ILI - CapLine);
} else {
for (i = 0; i < num; i++)
putpad(DL, ILI - CapLine);
}
Placur(top, 0);
if (M_AL && (num > 1)) {
char minibuf[16];
sprintf(minibuf, M_AL, num);
putpad(minibuf, ILI - CapLine);
} else {
for (i = 0; i < num; i++)
putpad(AL, ILI - CapLine);
}
}
}
#ifdef WIRED_TERMS
BGd_lines(top, bottom, num)
{
printf("\033[%d;%dr\033[%dM\033[r", top + 1, bottom + 1, num);
CapCol = CapLine = 0;
}
SUNd_lines(top, bottom, num)
{
Placur(top, 0);
printf("\033[%dM", num);
Placur(bottom + 1 - num, 0);
printf("\033[%dL", num);
}
C100d_lines(top, bottom, num)
{
if (num <= 1) {
GENd_lines(top, bottom, num);
return;
}
printf("\033v%c%c%c%c", ' ', ' ', ' ' + bottom + 1, ' ' + CO);
CapLine = CapCol = 0;
Placur(top, 0);
while (num--)
putpad(DL, ILI - CapLine);
printf("\033v%c%c%c%c", ' ', ' ', ' ' + LI, ' ' + CO);
CapLine = CapCol = 0;
}
#endif WIRED_TERMS
GENd_lines(top, bottom, num)
{
register int i;
if (CS) {
printf(tgoto(CS, bottom, top));
CapCol = CapLine = 0;
Placur(bottom, 0);
for (i = 0; i < num; i++)
putpad(SF, bottom - top);
printf(tgoto(CS, ILI, 0));
CapCol = CapLine = 0;
} else {
Placur(top, 0);
if (M_DL && (num > 1)) {
char minibuf[16];
sprintf(minibuf, M_DL, num);
putpad(minibuf, ILI - top);
} else {
for (i = 0; i < num; i++)
putpad(DL, ILI - top);
}
Placur(bottom + 1 - num, 0);
if (M_AL && (num > 1)) {
char minibuf[16];
sprintf(minibuf, M_AL, num);
putpad(minibuf, ILI - CapLine);
} else {
for (i = 0; i < num; i++)
putpad(AL, ILI - CapLine);
}
}
}
struct ID_lookup {
char *ID_name;
int (*I_proc)(); /* proc to insert lines */
int (*D_proc)(); /* proc to delete lines */
} ID_trms[] = {
"generic", GENi_lines, GENd_lines, /* This should stay here */
#ifdef WIRED_TERMS
"sun", SUNi_lines, SUNd_lines,
"bg", BGi_lines, BGd_lines,
"c1", C100i_lines, C100d_lines,
#endif WIRED_TERMS
0, 0, 0
};
IDline_setup(tname)
char *tname;
{
register struct ID_lookup *idp;
for (idp = &ID_trms[1]; idp->ID_name; idp++)
if (strncmp(idp->ID_name, tname, strlen(idp->ID_name)) == 0)
break;
if (idp->ID_name == 0)
idp = &ID_trms[0];
TTins_line = idp->I_proc;
TTdel_line = idp->D_proc;
}