/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
static char rcsid[] = "$Header: vtrm.c,v 1.3 85/08/30 10:11:04 timo Exp $";

/* History:
 *	21-aug-85 GvR	added support for AL and DL (parametrized al and dl).
 *	The Epoch tk	created and modified.
 */

/*
 * Virtual TeRMinal package.
 *
 * This package uses termcap to determine the terminal capabilities.
 *
 * The lines and columns of our virtual terminal are numbered 
 *	y = {0...lines-1} from top to bottom, and
 *	x = {0...cols-1} from left to right,
 * respectively.
 *
 * The Visible Procedures in this package are:
 *
 * trmstart(&lines, &cols, &flags)
 * 	Obligatory initialization call (sets tty modes etc.),
 * 	Returns the height and width of the screen to the integers
 * 	whose addresses are passed as parameters, and a flag that
 *	describes some capabilities.
 *	Function return value: Yes if all went well, No if the terminal
 *	is not supported.  An error message has already been displayed.
 *
 * trmundefined()
 *	Sets internal representation of screen and attributes to undefined.
 *	This is necessary for a hard redraw, which would get optimised to
 *	oblivion,
 *
 * trmsense(&y, &x)
 *	Returns the cursor position through its parameters
 *	after a possible manual change by the user.
 *
 * trmputdata(yfirst, ylast, indent, data)
 * 	Fill lines {yfirst..ylast} with data, after skipping the initial
 *	'indent' positions. It is assumed that these positions do not contain
 *	anything dangerous (like standout cookies or null characters).
 *
 * trmscrollup(yfirst, ylast, by)
 * 	Shift lines {yfirst..ylast} up by lines (down |by| if by < 0).
 *
 * trmsync(y, x)
 * 	Call to output data to the terminal and set cursor position.
 *
 * trmbell()
 *	Send a (possibly visible) bell, immediately (flushing stdout).
 *
 * trmend()
 * 	Obligatory termination call (resets tty modes etc.).
 *
 * You may call these as one or more cycles of:
 * 	+ trmstart
 * 	+    zero or more times any of the other routines
 * 	+ trmend
 * To catch interrupts and the like, you may call trmend even in the middle
 * of trmstart.
 */


/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Includes and data definitions.                                           */
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#include <stdio.h>
#include <setjmp.h>
#ifndef TERMIO
#include <sgtty.h>
#else
#include <termio.h>
#endif TERMIO
#include <signal.h>
#include <ctype.h> 		/* for isprint() */

#include "vtrm.h"

#ifdef lint
#define VOID (void)
#else
#define VOID
#endif

#define Forward
#define Visible
#define Hidden static
#define Procedure

typedef short intlet;
typedef char *string;
typedef char bool;
#define Yes ((bool) 1)
#define No  ((bool) 0)

#define Min(a,b) ((a) <= (b) ? (a) : (b))

/* tty modes */
#ifndef TERMIO
/* v7/BSD tty control */
Hidden struct sgttyb oldtty, newtty;
/* to enable type ahead for abled persons on systems that provide this: */
#ifdef TIOCSETN
#define stty(fd,bp) VOID ioctl(fd, TIOCSETN, bp)
#endif
#else
/* AT&T tty control */
Hidden struct termio oldtty, newtty;
#define gtty(fd,bp) ioctl(fd, TCGETA, bp)
#define stty(fd,bp) VOID ioctl(fd, TCSETAW, bp)
#endif TERMIO
Hidden bool know_ttys = No;

/* visible data for termcap */
char PC;
char *BC;
char *UP;
short ospeed;

Forward int outchar(); 		/* procedure for termcap's tputs */
#define Putstr(str)	tputs((str), 1, outchar)
extern char *tgoto();

/* termcap terminal capabilities */

Hidden int lines;
Hidden int cols;

Hidden bool has_am; 		/* has automatic margins */
Hidden bool has_da; 		/* display may be retained above screen */
Hidden bool has_db; 		/* display may be retained below screen */
Hidden bool has_in; 		/* not save to have null chars on the screen */
Hidden bool has_mi; 		/* move safely in insert (and delete?) mode */
Hidden bool has_ms; 		/* move safely in standout mode */
Hidden bool has_xs;		/* standout not erased by overwriting */

Hidden char *al_str; 		/* add new blank line */
Hidden char *par_al_str;	/* parametrized al (AL) */
Hidden char *cd_str; 		/* clear to end of display */
Hidden char *ce_str; 		/* clear to end of line */
Hidden char *cl_str; 		/* cursor home and clear screen */
Hidden char *cm_str; 		/* cursor motion */
Hidden char *cr_str; 		/* carriage return */
Hidden char *cs_str; 		/* change scrolling region */
Hidden char *dc_str; 		/* delete character */
Hidden char *dl_str; 		/* delete line */
Hidden char *par_dl_str;	/* parametrized dl (DL) */
Hidden char *do_str; 		/* cursor down one line */
Hidden char *dm_str; 		/* enter delete mode */
Hidden char *ed_str; 		/* end delete mode */
Hidden char *ei_str; 		/* end insert mode */
Hidden char *ho_str;		/* cursor home */
Hidden char *ic_str; 		/* insert character (iff necessary, maybe pad) */
Hidden char *im_str; 		/* enter insert mode */
Hidden char *le_str; 		/* cursor left */
Hidden char *nd_str; 		/* cursor right (non-destructive space) */
Hidden char *se_str; 		/* end standout mode */
Hidden char *sf_str; 		/* scroll text up (from bottom of region) */
Hidden char *so_str; 		/* begin standout mode */
Hidden char *sr_str; 		/* scroll text down (from top of region) */
Hidden char *te_str; 		/* end termcap */
Hidden char *ti_str; 		/* start termcap */
Hidden char *up_str; 		/* cursor up */
Hidden char *vb_str; 		/* visible bell */
Hidden char *ve_str; 		/* make cursor visible again */
Hidden char *vi_str; 		/* make cursor invisible */

/* sense cursor position, addition to termcap */
Hidden char *cp_str; 		/* format of returned Cursor Position string */
Hidden char *sp_str; 		/* Sense cursor Position from terminal */

/* terminal status */

/* calling order of Visible Procs */
Hidden bool started = No;

/* to exports the capabilities mentioned in vtrm.h: */
Hidden int flags = 0;

/* cost for impossible operations */
#define Infinity 9999
	/* Allow for adding Infinity+Infinity within range */
	/* (Range is assumed at least 2**15 - 1) */

/* The following for all sorts of undefined things (except for UNKNOWN char) */
#define Undefined (-1)

/* current mode of putting char's */
#define Normal	0
#define Insert	1
#define	Delete	2
Hidden short mode = Normal;

/* current standout mode */
#define Off	0
#define On	0200
Hidden short so_mode = Off;

/* masks for char's and intlet's */
#define NULCHAR	'\000'
#define CHAR	0177
#define SOBIT	On
#define SOCHAR	0377
/* if (has_xs) record cookies placed on screen in extra bit */
/* type of cookie is determined by the SO bit */
#define XSBIT	0400
#define SOCOOK	0600
#define COOKBITS SOCOOK
#define UNKNOWN	1
#define NOCOOK	UNKNOWN

/* current cursor position */
Hidden intlet cur_y = Undefined, cur_x = Undefined;

/* "line[y][x]" holds the char on the terminal, with the SOBIT and XSBIT.
 * the SOBIT tells whether the character is standing out, the XSBIT whether
 * there is a cookie on the screen at this position.
 * In particular a standend-cookie may be recorded AFTER the line
 * (just in case some trmputdata will write after that position).
 * "lenline[y]" holds the length of the line.
 * Unknown chars will be 1, so the optimising compare in putline will fail.
 * (Partially) empty lines are distinghuished by "lenline[y] < cols".
 */
Hidden intlet **line = 0, *lenline = 0;

/* Clear the screen initially iff only memory cursor addressing available */
Hidden bool mustclear = No;

/* Make the cursor invisible when trmsync() tries to move outside the screen */
Hidden bool no_cursor = No;

/* Optimise cursor motion */
Hidden int abs_cost; 		/* cost of absolute cursor motion */
Hidden int cr_cost; 		/* cost of carriage return */
Hidden int do_cost; 		/* cost of down */
Hidden int le_cost; 		/* cost of left */
Hidden int nd_cost; 		/* cost of right */
Hidden int up_cost; 		/* cost of up */

/* Optimise trailing match in put_line, iff the terminal can insert and delete
 * characters; the cost per n characters will be:
 * 	n * MultiplyFactor + OverHead
 */
Hidden int ins_mf, ins_oh, del_mf, del_oh;
Hidden int ed_cost, ei_cost; 		/* used in move() */

/* The type of scrolling possible determines which routines get used;
 * these may be:
 * (1) with addline and deleteline (termcap: al_str & dl_str);
 * (2) with a settable scrolling region, like VT100 (cs_str, sr_str, sf_str);
 * (3) no scrolling available. (NOT YET IMPLEMENTED)
 */
Hidden Procedure (*scr_up)();
Hidden Procedure (*scr_down)();
Forward Procedure scr1up();
Forward Procedure scr1down();
Forward Procedure scr2up();
Forward Procedure scr2down();
/*Forward Procedure scr3up(); */
/*Forward Procedure scr3down(); */

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Starting, Ending and (fatal) Error.                                      */
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

/* 
 * Initialization call.
 * Determine terminal capabilities from termcap.
 * Set up tty modes.
 * Start up terminal and internal administration.
 * Return Yes if succeeded, No if trouble (e.g., bad terminal type).
 */
Visible int
trmstart(plines, pcols, pflags)
int *plines;
int *pcols;
int *pflags;
{
#ifdef TRACE
fprintf(stderr, "\ttrmstart(&li, &co, &fl);\n");
#endif
	if (started)
		trmerr("trmstart called twice in succession");
	if (!gettermcaps())
		return No;
	if (!setttymode())
		return No;
	start_trm();

	*plines = lines;
	*pcols = cols;
	*pflags = flags;
	
	started = Yes;
	return Yes;
}

/*
 * Termination call.
 * Reset tty modes, etc.
 * Beware that it might be called by a catched interrupt even in the middle
 * of trmstart()!
 */
Visible Procedure
trmend()
{
#ifdef TRACE
fprintf(stderr, "\ttrmend();\n");
#endif
	set_mode(Normal);
	if (so_mode != Off)
		standend();
	Putstr(te_str);
	VOID fflush(stdout);
	resetttymode();

	started = No;
}

/*
 * Set all internal statuses to undefined, especially the contents of
 * the screen, so a hard redraw will not be optimised to heaven.
 */
Visible Procedure
trmundefined()
{
	register int y, x;
#ifdef TRACE
fprintf(stderr, "\ttrmundefined();\n");
#endif

	cur_y = cur_x = Undefined;
	mode = so_mode = Undefined;
	
	for (y = 0; y < lines; y++) {
		for (x = 0; x <= cols; x++)
			line[y][x] = 1; /* impossible char, no so bits */
		lenline[y] = cols;
	}
}

/* 
 * Give an error message, and abort.
 * The abort can be catched by the calling process.
 */
Hidden Procedure
trmerr(mess)
string mess;
{
	trmreset();
	fprintf(stderr,
		"*** System error in screen output module:\n*** %s\n", mess);
	VOID fflush(stderr);
	abort();
}

/*
 * Give an error message and reset the tty modes (but don't abort).
 */
Hidden Procedure trmmess(mess)
string mess;
{
	trmreset();
	fprintf(stderr, "*** Fatal error: %s\n", mess);
	VOID fflush(stderr);
}

/*
 * Complain about a missing terminal feature.  Otherwise like trmmess.
 */
Hidden Procedure
trmsorry(mess)
string mess;
{
    trmreset();
    fprintf(stderr, (
#ifdef BED
      "*** Sorry, this terminal isn't powerful enough to run the B editor.\n"
#else
      "*** Sorry, this terminal isn't powerful emough.\n"
#endif
    ));
    fprintf(stderr, "*** The problem is: %s.\n", mess);
#ifdef BED
    fprintf(stderr,
      "*** (You might try 'b -e' to use a standard editor instead.)\n");
#endif
    VOID fflush(stderr);
}

/*
 * Prepare for giving a (more or less fatal) error message.
 */
Hidden Procedure
trmreset()
{
	if (started) {
		move(lines-1, 0);
		clear_lines(lines-1, lines-1);
	}
	VOID fflush(stdout);
	resetttymode();
}

Hidden Procedure
check_started(m)
char *m;
{
	char s[80];
	
	if (!started) {
		VOID sprintf(s, "%s called outside trmstart/trmend", m);
		trmerr(s);
	}
}

int ccc;

/*ARGSUSED*/
Hidden Procedure
countchar(ch)
char ch;
{
	ccc++;
}

Hidden int
strcost(str)
char *str;
{
	if (str == NULL)
		return Infinity;
	return str0cost(str);
}

Hidden int
str0cost(str)
char *str;
{
	ccc = 0;
	tputs(str, 1, countchar);
	return ccc;
}

Hidden int
gettermcaps() 			/* get terminal capabilities from termcap
				 * and related static properties
				 */
{
	string trmname;
	char tc_buf[1024];
	static char strbuf[1024];
	char *area = strbuf;
	char *xPC;
	char *getenv();
	int tgetent();
	int tgetnum();
	int tgetflag();
	char *tgetstr();
	int sg;
	static bool tc_initialized = No;
#ifdef TIOCGWINSZ
	struct winsize win;
#endif
	
	if (tc_initialized)
		return Yes;
	
	if ((trmname=getenv("TERM")) == NULL) {
		trmmess("terminal type not exported in $TERM variable");
		return No;
	}
	if (tgetent(tc_buf, trmname) != 1) {
		trmmess("unknown terminal type in $TERM envariable");
		return No;
	}
	
	if (tgetflag("hc")) {
		trmsorry("can't use a hardcopy terminal");
		return No;
	}

	BC = tgetstr("le", &area);
	if (BC == NULL)
		BC = tgetstr("bc", &area);
	if (BC == NULL)
		if (tgetflag("bs"))
			BC="\b";
		else {
			trmsorry("no LEFT cursor motion");
			return No;
		}
	UP = tgetstr("up", &area);
	if (UP == NULL) {
		trmsorry("no UP cursor motion");
		return No;
	}
	xPC = tgetstr("pc", &area);
	PC = (xPC != NULL? xPC[0] : NULCHAR);

	ho_str = tgetstr("ho", &area);
	do_str = tgetstr("do", &area);
	nd_str = tgetstr("nd", &area);
	cm_str = tgetstr("cm", &area);
	if (cm_str == NULL) {
		cm_str = tgetstr("CM", &area);
		if (cm_str == NULL) {
			if (ho_str == NULL || do_str == NULL || nd_str == NULL) {
				trmsorry("no absolute cursor motion");
				return No;
			}
		}
		else
			mustclear = Yes;
	}

	al_str = tgetstr("al", &area);
	dl_str = tgetstr("dl", &area);
	par_al_str = tgetstr("AL", &area);
	par_dl_str = tgetstr("DL", &area);
	if (al_str && dl_str) {
		scr_up = scr1up;
		scr_down = scr1down;
		flags |= CAN_SCROLL;
	}
	else {
		cs_str = tgetstr("cs", &area);
		sf_str = tgetstr("sf", &area);
		if (sf_str == NULL)
			sf_str = "\n";
		sr_str = tgetstr("sr", &area);
		if (cs_str && sr_str) {
			scr_up = scr2up;
			scr_down = scr2down;
			flags |= CAN_SCROLL;
		}
		else {
			trmsorry("can't scroll");
			return No;
		}
	}
		
	lines = tgetnum("li");
	cols = tgetnum("co");
#ifdef TIOCGWINSZ
	if (ioctl (0, TIOCGWINSZ, &win) == 0) {
		if (win.ws_col)
			cols = win.ws_col;
		if (win.ws_row)
			lines = win.ws_row;
	}
#endif
	if (lines == -1) lines = 24;
	if (cols == -1) cols = 80;
	
	has_am = tgetflag("am");
	has_db = tgetflag("db");
	has_in = tgetflag("in");
	has_mi = tgetflag("mi");
	has_ms = tgetflag("ms");
	has_xs = tgetflag("xs");
	if ((sg=tgetnum("sg")) == 0)
		has_xs = Yes;
	else if (sg > 0) {
		trmsorry("video attributes take up space on the screen");
		return No;
	}
	
	cd_str = tgetstr("cd", &area);
	ce_str = tgetstr("ce", &area);
	if (!ce_str) {
		trmsorry("can't clear to end of line");
		return No;
	}
	cl_str = tgetstr("cl", &area);
	cr_str = tgetstr("cr", &area);
	if (cr_str == NULL) cr_str = "\r";
	dc_str = tgetstr("dc", &area);
	dm_str = tgetstr("dm", &area);
	if (do_str == NULL) do_str = tgetstr("nl", &area);
	if (do_str == NULL) do_str = "\n";
	ed_str = tgetstr("ed", &area);
	ei_str = tgetstr("ei", &area);
	ic_str = tgetstr("ic", &area);
	im_str = tgetstr("im", &area);
	le_str = BC;
	se_str = tgetstr("se", &area);
	so_str = tgetstr("so", &area);
	te_str = tgetstr("te", &area);
	ti_str = tgetstr("ti", &area);
	up_str = UP;
	vb_str = tgetstr("vb", &area);
	if (vb_str == NULL) 	/* then we will do with the audible bell */
		vb_str = "\007";
	ve_str = tgetstr("ve", &area);
	vi_str = tgetstr("vi", &area);
	
	/* cursor sensing (non standard) */
	cp_str = tgetstr("cp", &area);
	sp_str = tgetstr("sp", &area);
	if (cp_str != NULL && sp_str != NULL)
		flags |= CAN_SENSE;

	if (so_str != NULL && se_str != NULL)
		flags |= HAS_STANDOUT;

	/* calculate costs of local and absolute cursor motions */
	if (cm_str == NULL)
		abs_cost = Infinity;
	else
		abs_cost = strcost(tgoto(cm_str, 0, 0));
	cr_cost = strcost(cr_str);
	do_cost = strcost(do_str);
	le_cost = strcost(le_str);
	nd_cost = strcost(nd_str);
	up_cost = strcost(up_str);

	/* cost of leaving insert or delete mode, used in move() */
	ei_cost = str0cost(ei_str);
	ed_cost = str0cost(ed_str);
	
	/* calculate insert and delete cost multiply_factor and overhead */
	if (((im_str && ei_str) || ic_str) && dc_str) {
		flags |= CAN_OPTIMISE;
		ins_mf = 1 + str0cost(ic_str);
		ins_oh = str0cost(im_str) + ei_cost;
		del_mf = str0cost(dc_str);
		del_oh = str0cost(dm_str) + ed_cost;
	}
		
	tc_initialized = Yes;
	return Yes;
}

Hidden int
setttymode()
{
	if (!know_ttys) {
		if (gtty(1, &oldtty) != 0 || gtty(1, &newtty) != 0) {
			trmmess("can't get tty modes (output not a terminal)");
			return No;
		}
#ifndef TERMIO
		ospeed = oldtty.sg_ospeed;
#ifdef PWB
		newtty.sg_flags = (newtty.sg_flags & ~ECHO & ~CRMOD & ~XTABS)
				  | RAW;
#else PWB
		newtty.sg_flags = (newtty.sg_flags & ~ECHO & ~CRMOD & ~XTABS)
				  | CBREAK;
#endif PWB
#else TERMIO
		ospeed= oldtty.c_lflag & CBAUD;
		newtty.c_iflag &= ~ICRNL; /* No CR->NL mapping on input */
		newtty.c_oflag &= ~ONLCR; /* NL doesn't output CR */
		newtty.c_lflag &= ~(ICANON|ECHO); /* No line editing, no echo */
		newtty.c_cc[VMIN]= 3; /* wait for 3 characters */
		newtty.c_cc[VTIME]= 1; /* or 0.1 sec. */
#endif TERMIO
		know_ttys = Yes;
	}
	stty(1, &newtty);
	return Yes;
}

Hidden Procedure
resetttymode()
{
	if (know_ttys)
		stty(1, &oldtty);
}

Hidden char*
lalloc(size)
unsigned size;
{
	char *l;
	char *malloc();
	
	l = malloc(size);
	if (l == NULL)
		trmerr("not enough memory for screen buffer");
	return l;
}

Hidden Procedure
start_trm()
{
	register int y;
	
	if (line == 0) {
		line = (intlet**) lalloc((unsigned) lines * sizeof(intlet*));
		for (y = 0; y < lines; y++)
			line[y] = (intlet*) lalloc((unsigned) ((cols+1)*sizeof(intlet)));
	}
	if (lenline == 0)
		lenline = (intlet*) lalloc((unsigned) lines * sizeof(intlet));

	
	trmundefined();
	
	Putstr(ti_str);
	if (cs_str)
		Putstr(tgoto(cs_str, lines-1, 0));
	if (mustclear)
		clear_lines(0, lines-1);
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Sensing and moving the cursor.                                           */
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

/*
 * Sense the current (y, x) cursor position, after a possible manual
 * change by the user with local cursor motions.
 * If the terminal cannot be asked for the current cursor position,
 * or if the string returned by the terminal is garbled,
 * the position is made Undefined.
 */
Visible Procedure
trmsense(py, px)
	int *py;
	int *px;
{
	bool getpos();

#ifdef TRACE
fprintf(stderr, "\ttrmsense(&yy, &xx);\n");
#endif
	check_started("trmsense");

	*py = *px = Undefined;
	set_mode(Normal);
	if (so_mode != Off)
		standend();
	
	if (flags&CAN_SENSE && getpos(py, px)) {
		if (*py < 0 || lines <= *py || *px < 0 || cols <= *px)
			*py = *px = Undefined;
	}
	cur_y = *py;
	cur_x = *px;
}

Hidden bool
getpos(py, px)
int *py, *px;
{
	char *format = cp_str;
	int fc; 		/* current format character */
	int ic; 		/* current input character */
	int num;
	int on_y = 1;
	bool incr_orig = No;
	int i, ni;

	Putstr(sp_str);
	VOID fflush(stdout);

	while (fc = *format++) {
		if (fc != '%') {
			if (getchar() != fc)
				return No;
		}
		else {
			switch (fc = *format++) {
			case '%':
				if (getchar() != '%')
					return No;
				continue;
			case 'r':
				on_y = 1 - on_y;
				continue;
			case 'i':
				incr_orig = Yes;
				continue;
			case 'd':
				ic = getchar();
				if (!isdigit(ic))
					return No;
				num = ic - '0';
				while (isdigit(ic=getchar()))
					num = 10*num + ic - '0';
				VOID ungetc(ic, stdin);
				break;
			case '2':
			case '3':
				ni = fc - '0';
		    		num = 0;
				for (i=0; i<ni; i++) {
					ic = getchar();
					if (isdigit(ic))
						num = 10*num + ic - '0';
					else
						return No;
				}
				break;
			case '+':
				num = getchar() - *format++;
				break;
			case '-':
				num = getchar() + *format++;
				break;
			default:
				return No;
			}
			/* assign num to parameter */
			if (incr_orig)
				num--;
			if (on_y)
				*py = num;
			else
				*px = num;
			on_y = 1 - on_y;
		}
	}

	return Yes;
}
		
/* 
 * To move over characters by rewriting them, we have to check:
 * (1) that the screen has been initialised on these positions;
 * (2) we do not screw up characters
 * when rewriting line[y] from x_from upto x_to
 */
Hidden bool
rewrite_ok(y, xfrom, xto)
int y, xfrom, xto;
{
	register intlet *plnyx, *plnyto;
	
	if (xto > lenline[y])
		return No;

	plnyto = &line[y][xto];
	for (plnyx = &line[y][xfrom]; plnyx <= plnyto; plnyx++)
		if (*plnyx == UNKNOWN
		    ||
		    (!has_xs && (*plnyx & SOBIT) != so_mode)
		   )
			return No;
	return Yes;
}
		
/*
 * Move to position y,x on the screen
 */
/* possible move types for y and x respectively: */
#define None	0
#define Down	1
#define Up	2
#define Right	1
#define ReWrite	2
#define Left	3
#define CrWrite	4

Hidden Procedure
move(y, x)
int y, x;
{
	int dy, dx;
	int y_cost, x_cost, y_move, x_move;
	int mode_cost;
	int xi;
	
	if (cur_y == y && cur_x == x)
		return;
	
	if (!has_mi || mode == Undefined)
		set_mode(Normal);
	if (!has_xs && ((!has_ms && so_mode != Off) || so_mode == Undefined))
		standend();
	
	if (cur_y == Undefined || cur_x == Undefined)
		goto absmove;
	
	dy = y - cur_y;
	dx = x - cur_x;

	if (dy > 0) {
		y_move = Down;
		y_cost = dy * do_cost;
	}
	else if (dy < 0) {
		y_move = Up;
		y_cost = -dy * up_cost;
	}
	else {
		y_move = None;
		y_cost = 0;
	}
	if (y_cost < abs_cost) {
		switch (mode) {
		case Normal:
			mode_cost = 0;
			break;
		case Insert:
			mode_cost = ei_cost;
			break;
		case Delete:
			mode_cost = ed_cost;
			break;
		}
		if (dx > 0) {
			x_cost = dx + mode_cost;
			if (dx*nd_cost < x_cost || !rewrite_ok(y, cur_x, x)) {
				x_cost = dx * nd_cost;
				x_move = Right;
			}
			else
				x_move = ReWrite;
		}
		else if (dx < 0) {
			x_cost = -dx * le_cost;
			x_move = Left;
		}
		else {
			x_cost = 0;
			x_move = None;
		}
		if (cr_cost + x + mode_cost < x_cost && rewrite_ok(y, 0, x)) {
			x_move = CrWrite;
			x_cost = cr_cost + x + mode_cost;
		}
	}
	else
		x_cost = abs_cost;

	if (y_cost + x_cost < abs_cost) {
		switch (y_move) {
		case Down:
			while (dy-- > 0) Putstr(do_str);
			break;
		case Up:
			while (dy++ < 0) Putstr(up_str);
			break;
		}
		switch (x_move) {
		case Right:
			while (dx-- > 0) Putstr(nd_str);
			break;
		case Left:
			while (dx++ < 0) Putstr(le_str);
			break;
		case CrWrite:
			Putstr(cr_str);
			cur_x = 0;
			/* FALL THROUGH */
		case ReWrite:
			set_mode(Normal);
			for (xi = cur_x; xi < x; xi++)
				putchar(line[y][xi]);
			break;
		}
	}
	else
	{
    absmove:
		if (cm_str == NULL) {
			Putstr(ho_str);
			for (cur_y = 0; cur_y < y; ++cur_y)
				Putstr(do_str);
			/* Should try to use tabs here: */
			for (cur_x = 0; cur_x < x; ++cur_x)
				Putstr(nd_str);
		}
		else
			Putstr(tgoto(cm_str, x, y));
	}
	
	cur_y = y;
	cur_x = x;
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Putting data on the screen.                                              */
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

/*
 * Fill screen area with given data.
 * Characters with the SO-bit (0200) set are put in standout mode.
 */
Visible Procedure
trmputdata(yfirst, ylast, indent, data)
int yfirst;
int ylast;
register int indent;
register string data;
{
	register int y;
	int x, len, lendata, space;
		
#ifdef TRACE
fprintf(stderr, "\ttrmputdata(%d, %d, %d, \"%s\");\n", yfirst, ylast, indent, data);
#endif
	check_started("trmputdata");
	
	if (yfirst < 0)
		yfirst = 0;
	if (ylast >= lines)
		ylast = lines-1;
	space = cols*(ylast-yfirst+1) - indent;
	if (space <= 0)
		return;
	yfirst += indent/cols;
	indent %= cols;
	if (data) {
		x = indent;
		lendata = strlen(data);
		if (ylast == lines-1 && lendata >= space)
			lendata = space - 1;
		len = Min(lendata, cols-x);
		for (y = yfirst; y <= ylast; ) {
			put_line(y, x, data, len);
			y++;
			lendata -= len;
			if (lendata > 0) {
				x = 0;
				data += len;
				len = Min(lendata, cols);
			}
			else
				break;
		}
	}
	if (y <= ylast)
		clear_lines(y, ylast);
}

/* 
 * We will first try to get the picture:
 *
 *                  op>>>>>>>>>>>op          oq<<<<<<<<<<<<<<<<<<<<<<<<oq
 *                  ^            ^           ^                         ^
 *           <xskip><-----m1----><----od-----><-----------m2----------->
 *   OLD:   "You're in a maze of twisty little pieces of code, all alike"
 *   NEW:          "in a maze of little twisting pieces of code, all alike"
 *                  <-----m1----><-----nd------><-----------m2----------->
 *                  ^            ^             ^                         ^
 *                  np>>>>>>>>>>>np            nq<<<<<<<<<<<<<<<<<<<<<<<<nq
 * where
 *	op, oq, np, nq are pointers to start and end of Old and New data,
 * and
 *	xskip = length of indent to be skipped,
 *	m1 = length of Matching part at start,
 *	od = length of Differing mid on screen,
 *	nd = length of Differing mid in data to be put,
 *	m2 = length of Matching trail.
 *
 * Then we will try to find a long blank-or-cleared piece in <nd+m2>:
 *
 *    <---m1---><---d1---><---nb---><---d2---><---m2--->
 *              ^         ^         ^        ^         ^
 *              np        bp        bq1      nq        nend
 * where
 *	bp, bq are pointers to start and AFTER end of blank piece,
 * and
 *	d1 = length of differing part before blank piece,
 *	nb = length of blank piece to be skipped,
 *	d2 = length of differing part after blank piece.
 * Remarks:
 *	d1 + nb + d2 == nd,
 * and
 *	d2 maybe less than 0.
 */
Hidden int
put_line(y, xskip, data, len)
int y, xskip;
string data;
int len;
{
	register intlet *op, *oq;
	register char *np, *nq, *nend;
	char *bp, *bq1, *p, *q;
	int m1, m2, od, nd, delta, dd, d1, nb, d2;
	bool skipping;
	int cost, o_cost; 	/* normal and optimising cost */
	
	/* calculate the magic parameters */
	op = &line[y][xskip];
	oq = &line[y][lenline[y]-1];
	np = data;
	nq = nend = data + len - 1;
	m1 = m2 = 0;
	while ((*op&SOCHAR) == (((intlet)*np)&SOCHAR) && op <= oq && np <= nq)
		op++, np++, m1++;
	if (flags & CAN_OPTIMISE)
		while ((*oq&SOCHAR) == (((intlet)*nq)&SOCHAR) && op <= oq && np <= nq)
			oq--, nq--, m2++;
	od = oq - op + 1;
	nd = nq - np + 1;
	/* now we have the first picture above */

	if (od==0 && nd==0)
		return;
	delta = nd - od;

	/* find the blank piece */
	p = q = bp = bq1 = np;
	oq += m2; 		/* back to current eol */
	if (!has_in) {
		while (p <= nend) {
			while (q<=nend && *q==' ' && (op>oq || *op==' '))
				q++, op++;
			if (q - p > bq1 - bp)
				bp = p, bq1 = q;
			p = ++q;
			op++;
		}
	}
	d1 = bp - np;
	nb = bq1 - bp;
	d2 = nq - bq1 + 1;
	
	/* what is cheapest:
	 *	normal: put nd+m2;                         (dd = nd+m2)
	 *	skipping: put d1, skip nb, put d2+m2;      (dd = d2+m2)
	 *	optimise: put dd, insert or delete delta.  (dd = min(od,nd))
	 */
	cost = nd + m2; 	/* normal cost */
	if (nb > abs_cost || (d1 == 0 && nb > 0)) {
		skipping = Yes;
		cost -= nb - (d1>0 ? abs_cost : 0); /* skipping cost */
		dd = d2;
	}
	else {
		skipping = No;
		dd = nd;
	}
	
	if (m2 != 0) {
		/* try optimising */
		o_cost = Min(od, nd);
		if (delta > 0)
			o_cost += delta * ins_mf + ins_oh;
		else if (delta < 0)
			o_cost += -delta * del_mf + del_oh;
		if (o_cost >= cost) {
			/* discard m2, no optimise */
			dd += m2;
			m2 = 0;
		}
		else {
			dd = Min(od, nd);
			skipping = No;
		}
	}

	/* and now for the real work */
	if (!skipping || d1 > 0)
		move(y, xskip + m1);

	if (has_xs)
		get_so_mode();
	
	if (skipping) {
		if (d1 > 0) {
			set_mode(Normal);
			put_str(np, d1, No);
		}
		if (has_xs && so_mode != Off)
			standend();
		set_blanks(y, xskip+m1+d1, xskip+m1+d1+nb);
		if (dd != 0 || delta < 0) {
			move(y, xskip+m1+d1+nb);
			np = bq1;
		}
	}
	
	if (dd > 0) {
		set_mode(Normal);
		put_str(np, dd, No);
	}
	
	if (m2 > 0) {
		if (delta > 0) {
			set_mode(Insert);
			ins_str(np+dd, delta);
		}
		else if (delta < 0) {
			set_mode(Delete);
			del_str(-delta);
		}
	}
	else {
		if (delta < 0) {
			clr_to_eol();
			return;
		}
	}
	
	lenline[y] = xskip + len;
	if (cur_x == cols) {
		if (!has_mi)
			set_mode(Normal);
		if (!has_ms)
			so_mode = Undefined;
		if (has_am)
			cur_y++;
		else
			Putstr(cr_str);
		cur_x = 0;
	}
	else if (has_xs) {
		if (m2 == 0) {
			if (so_mode == On)
				standend();
		}
		else {
			if (!(line[cur_y][cur_x] & XSBIT)) {
				if (so_mode != (line[cur_y][cur_x] & SOBIT))
					(so_mode ? standend() : standout());
			}
		}
	}
}

Hidden Procedure
set_mode(m)
int m;
{
	if (m == mode)
		return;
	switch (mode) {
	case Insert:
		Putstr(ei_str);
		break;
	case Delete:
		Putstr(ed_str);
		break;
	case Undefined:
		Putstr(ei_str);
		Putstr(ed_str);
		break;
	}
	switch (m) {
	case Insert:
		Putstr(im_str);
		break;
	case Delete:
		Putstr(dm_str);
		break;
	}
	mode = m;
}

Hidden Procedure
get_so_mode()
{
	if (cur_x >= lenline[cur_y] || line[cur_y][cur_x] == UNKNOWN)
		so_mode = Off;
	else
		so_mode = line[cur_y][cur_x] & SOBIT;
}

Hidden Procedure
standout()
{
	Putstr(so_str);
	so_mode = On;
	if (has_xs)
		line[cur_y][cur_x] |= SOCOOK;
}

Hidden Procedure
standend()
{
	Putstr(se_str);
	so_mode = Off;
	if (has_xs)
		line[cur_y][cur_x] = (line[cur_y][cur_x] & ~SOBIT) | XSBIT;
}

Hidden Procedure
put_str(data, n, inserting)
char *data;
int n;
bool inserting;
{
	register intlet c, so;
	intlet *ln_y_x, *ln_y_end;
	
	so = so_mode;
	if (has_xs) {
		ln_y_x = &line[cur_y][cur_x];
		ln_y_end = &line[cur_y][lenline[cur_y]];
	}
	while (n-- > 0) {
		if (has_xs && ln_y_x <= ln_y_end && ((*ln_y_x)&XSBIT))
			so = so_mode = (*ln_y_x)&SOBIT;
			/* this also checks for the standend cookie AFTER */
			/* the line because off the equals sign in <= */
		c = ((intlet)(*data++))&SOCHAR;
		if ((c&SOBIT) != so) {
			so = c&SOBIT;
			so ? standout() : standend();
 		}
		if (inserting)
			Putstr(ic_str);
		put_c(c);
		if (has_xs)
			ln_y_x++;
	}
}

Hidden Procedure
ins_str(data, n)
char *data;
int n;
{
	int x;
	
	/* x will start AFTER the line, because there might be a cookie */
	for (x = lenline[cur_y]; x >= cur_x; x--)
		line[cur_y][x+n] = line[cur_y][x];
	put_str(data, n, Yes);
}

Hidden Procedure
del_str(n)
int n;
{
	int x, xto;
	
	xto = lenline[cur_y] - n; /* again one too far because of cookie */
	if (has_xs) {
		for (x = cur_x + n; x >= cur_x; x--) {
			if (line[cur_y][x] & XSBIT)
				break;
		}
		if (x >= cur_x)
			line[cur_y][cur_x+n] =
				(line[cur_y][cur_x+n] & CHAR)
				|
				(line[cur_y][x] & COOKBITS);
	}
	for (x = cur_x; x <= xto; x++)
		line[cur_y][x] = line[cur_y][x+n];
	while (n-- > 0)
		Putstr(dc_str);
}

Hidden Procedure
put_c(c)
intlet c;
{
	char ch;
	intlet xs_flag;
	
	ch = c&CHAR;
	if (!isprint(ch) && ch != ' ') { /* V7 isprint doesn't include blank */
		ch = '?';
		c = (c&SOBIT)|'?';
	}
	putchar(ch);
	if (has_xs)
		xs_flag = line[cur_y][cur_x]&XSBIT;
	else
		xs_flag = 0;
	line[cur_y][cur_x] = (c&SOCHAR)|xs_flag;
	cur_x++;
}

Hidden Procedure
clear_lines(yfirst, ylast)
int yfirst, ylast ;
{
	register int y;
	
	if (!has_xs && so_mode != Off)
		standend();
	if (cl_str && yfirst == 0 && ylast == lines-1) {
		Putstr(cl_str);
		cur_y = cur_x = 0;
		return;
	}
	for (y = yfirst; y <= ylast; y++) {
		if (lenline[y] > 0) {
			move(y, 0);
			if (ylast == lines-1 && cd_str) {
				Putstr(cd_str);
				while (y <= ylast) {
					if (has_xs) line[y][0] = NOCOOK;
					lenline[y++] = 0;
				}
				break;
			}
			else {
				clr_to_eol();
			}
		}
	}
}

Hidden Procedure
clr_to_eol()
{
	lenline[cur_y] = cur_x;
	if (!has_xs && so_mode != Off)
		standend();
	Putstr(ce_str);
	if (has_xs) {
		if (cur_x == 0)
			line[cur_y][0] = NOCOOK;
		else if (line[cur_y][cur_x-1]&SOBIT)
			standend();
	}
}

Hidden Procedure
set_blanks
(y, xfrom, xto)
int y, xfrom, xto;
{
	register int x;
	
	for (x = xfrom; x < xto; x++) {
		line[y][x] = (line[y][x]&XSBIT) | ' ';
	}
}

/* 
 * outchar() is used by termcap's tputs;
 * we can't use putchar because that's probably a macro
 */
Hidden int
outchar(ch)
char ch;
{
	putchar(ch);
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Scrolling (part of) the screen up (or down, dy<0).                       */
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

Visible Procedure
trmscrollup(yfirst, ylast, by)
register int yfirst;
register int ylast;
register int by;
{
#ifdef TRACE
fprintf(stderr, "\ttrmscrollup(%d, %d, %d);\n", yfirst, ylast, by);
#endif
	check_started("trmscrollup");
	
	if (yfirst < 0)
		yfirst = 0;
	if (ylast >= lines)
		ylast = lines-1;

	if (yfirst > ylast)
		return;

	if (!has_xs && so_mode != Off)
		standend();
	
	if (by > 0 && yfirst + by > ylast
	    ||
	    by < 0 && yfirst - by > ylast)
	{
		clear_lines(yfirst, ylast);
		return;
	}
	
	if (by > 0) {
		(*scr_up)(yfirst, ylast, by);
		scr_lines(yfirst, ylast, by, 1);
	}
	else if (by < 0) {
		(*scr_down)(yfirst, ylast, -by);
		scr_lines(ylast, yfirst, -by, -1);
	}
}

Hidden Procedure
scr_lines(yfrom, yto, n, dy)
int yfrom, yto, n, dy;
{
	register int y;
	intlet *saveln;
	
	while (n-- > 0) {
		saveln = line[yfrom];
		for (y = yfrom; y != yto; y += dy) {
			line[y] = line[y+dy];
			lenline[y] = lenline[y+dy];
		}
		line[yto] = saveln;
		lenline[yto] = 0;
		if (has_xs) line[yto][0] = NOCOOK;
	}
}

Hidden Procedure
scr1up(yfirst, ylast, n)
	int yfirst;
	int ylast;
	int n;
{
	move(yfirst, 0);
	dellines(n);
	if (ylast < lines-1) {
		move(ylast-n+1, 0);
		addlines(n);
	}
}

Hidden Procedure
scr1down(yfirst, ylast, n)
	int yfirst;
	int ylast;
	int n;
{
	if (ylast == lines-1) {
		clear_lines(ylast-n+1, ylast);
	}
	else {
		move(ylast-n+1, 0);
		dellines(n);
	}
	move(yfirst, 0);
	addlines(n);
}

Hidden Procedure
addlines(n)
register int n;
{
	if (par_al_str && n > 1)
			Putstr(tgoto(par_al_str, n, n));
	else {
		while (n-- > 0)
			Putstr(al_str);
	}
}

Hidden Procedure
dellines(n)
register int n;
{
	if (par_dl_str && n > 1)
		Putstr(tgoto(par_dl_str, n, n));
	else {
		while (n-- > 0)
			Putstr(dl_str);
	}
}

Hidden Procedure
scr2up(yfirst, ylast, n)
int yfirst, ylast, n;
{
	Putstr(tgoto(cs_str, ylast, yfirst));
	cur_y = cur_x = Undefined;
	move(ylast, 0);
	while (n-- > 0) {
		Putstr(sf_str);
		if (has_db && ylast == lines-1)
			clr_to_eol();
	}
	Putstr(tgoto(cs_str, lines-1, 0));
	cur_y = cur_x = Undefined;
}

Hidden Procedure
scr2down(yfirst, ylast, n)
int yfirst, ylast, n;
{
	Putstr(tgoto(cs_str, ylast, yfirst));
	cur_y = cur_x = Undefined;
	move(yfirst, 0);
	while (n-- > 0) {
		Putstr(sr_str);
		if (has_da && yfirst == 0)
			clr_to_eol();
	}
	Putstr(tgoto(cs_str, lines-1, 0));
	cur_y = cur_x = Undefined;
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Synchronization, move cursor to given position (or previous if < 0).     */
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

Visible Procedure
trmsync(y, x)
	int y;
	int x;
{
#ifdef TRACE
fprintf(stderr, "\ttrmsync(%d, %d);\n", y, x);
#endif
	check_started("trmsync");
	
	if (0 <= y && y < lines && 0 <= x && x < cols) {
		move(y, x);
		if (no_cursor) {
			Putstr(ve_str);
			no_cursor = No;
		}
	}
	else if (no_cursor == No) {
		Putstr(vi_str);
		no_cursor = Yes;
	}
	VOID fflush(stdout);
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Send a bell, visible if possible.                                        */
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

Visible Procedure
trmbell()
{
#ifdef TRACE
fprintf(stderr, "\ttrmbell();\n");
#endif
	check_started("trmbell");
	
	Putstr(vb_str);
	VOID fflush(stdout);
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
/* Show the current internal statuses of the screen on stderr.              */
/* For debugging only.                                                      */
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */

#ifdef SHOW
Visible Procedure
trmshow(s)
char *s;
{
	int y, x;
	
	fprintf(stderr, "<<< %s >>>\n", s);
	for (y = 0; y < lines; y++) {
		for (x = 0; x <= lenline[y] /*** && x < cols-1 ***/ ; x++) {
			fputc(line[y][x]&CHAR, stderr);
		}
		fputc('\n', stderr);
		for (x = 0; x <= lenline[y] && x < cols-1; x++) {
			if (line[y][x]&SOBIT)
				fputc('-', stderr);
			else
				fputc(' ', stderr);
		}
		fputc('\n', stderr);
		for (x = 0; x <= lenline[y] && x < cols-1; x++) {
			if (line[y][x]&XSBIT)
				fputc('+', stderr);
			else
				fputc(' ', stderr);
		}
		fputc('\n', stderr);
	}
	fprintf(stderr, "CUR_Y = %d, CUR_X = %d.\n", cur_y, cur_x);
	VOID fflush(stderr);
}
#endif