/*
 * This code contains changes by
 *      Gunnar Ritter, Freiburg i. Br., Germany, 2002. All rights reserved.
 *
 * Conditions 1, 2, and 4 and the no-warranty notice below apply
 * to these changes.
 *
 *
 * Copyright (c) 1980, 1993
 * 	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 * 	This product includes software developed by the University of
 * 	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *
 * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *   Redistributions of source code and documentation must retain the
 *    above copyright notice, this list of conditions and the following
 *    disclaimer.
 *   Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *   All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed or owned by Caldera
 *      International, Inc.
 *   Neither the name of Caldera International, Inc. nor the names of
 *    other contributors may be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
 * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE
 * LIABLE FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef	lint
#ifdef	DOSCCS
static char sccsid[] = "@(#)ex_put.c	1.35 (gritter) 12/25/06";
#endif
#endif

/* from ex_put.c	7.9.1 (2.11BSD GTE) 12/9/94 */

#include "ex.h"
#include "ex_tty.h"
#include "ex_vis.h"

/*
 * Terminal driving and line formatting routines.
 * Basic motion optimizations are done here as well
 * as formatting of lines (printing of control characters,
 * line numbering and the like).
 */

/*
 * The routines outchar, putchar and pline are actually
 * variables, and these variables point at the current definitions
 * of the routines.  See the routine setflav.
 * We sometimes make outchar be routines which catch the characters
 * to be printed, e.g. if we want to see how long a line is.
 * During open/visual, outchar and putchar will be set to
 * routines in the file ex_vput.c (vputchar, vinschar, etc.).
 */
int	(*Outchar)(int) = termchar;
int	(*Putchar)(int) = normchar;
int	(*Pline)(int, int) = normline;

int (*
setlist(int t))(int)
{
	register int (*P)(int);

	listf = t;
	P = Putchar;
	Putchar = t ? listchar : normchar;
	return (P);
}

int (*
setnumb(int t))(int, int)
{
	register int (*P)(int, int);

	numberf = t;
	P = Pline;
	Pline = t ? numbline : normline;
	return (P);
}

/*
 * Format c for list mode; leave things in common
 * with normal print mode to be done by normchar.
 */
int 
listchar(int c)
{

	if (c & MULTICOL) {
		c &= ~MULTICOL;
		if (c == 0)
			return MULTICOL;
	}
	c &= (TRIM|QUOTE);
	switch (c) {
	case '\t':
	case '\b':
		c = ctlof(c);
		outchar('^');
		break;

	case '\n':
		break;

	default:
		if (c == ('\n' | QUOTE))
			outchar('$');
		if (c & QUOTE)
			break;
#ifndef	BIT8
		if (c < ' ' && c != '\n')
			outchar('^'), c = ctlof(c);
#else	/* !BIT8 */
		if (!printable(c) && c != '\n' || c == DELETE)
			c = printof(c);
#endif
		break;
	}
	return normchar(c);
}

/*
 * Format c for printing. Handle funnies of upper case terminals
 * and crocky hazeltines which don't have ~.
 */
int
normchar(register int c)
{
	int	u;

#ifdef	UCVISUAL
	register char *colp;

	if (c == '~' && xHZ) {
		normchar('\\');
		c = '^';
	}
#endif

	if (c & MULTICOL) {
		c &= ~MULTICOL;
		if (c == 0)
			return MULTICOL;
	}
	c &= (TRIM|QUOTE);
	u = c & TRIM;
	if (c & QUOTE) {
		if (c == (' ' | QUOTE) || c == ('\b' | QUOTE))
			/*EMPTY*/;
		else if (c == QUOTE)
			return c;
		else
			c &= TRIM;
	}
#ifdef	BIT8
	else {
		if (!printable(c) && (u != '\b' || !OS) &&
				u != '\n' && u != '\t')
			c = printof(u);
		else {
			c = u;
			if (0)
				/*EMPTY*/;
#else	/* !BIT8 */
	else if (c < ' ' && (c != '\b' || !OS) && c != '\n' && c != '\t')
		putchar('^'), c = ctlof(c);
#endif	/* !BIT8 */
#ifdef	UCVISUAL
	else if (UPPERCASE)
		if (xisupper(c)) {
			outchar('\\');
			c = tolower(c);
		} else {
			colp = "({)}!|^~'`";
			while (*colp++)
				if (c == *colp++) {
					outchar('\\');
					c = colp[-2];
					break;
				}
		}
#endif	/* UCVISUAL */
#ifdef	BIT8
		}
	}
#endif
	outchar(c);
	return c;
}

/*
 * Given c at the beginning of a line, determine whether
 * the printing of the line will erase or otherwise obliterate
 * the prompt which was printed before.  If it won't, do it now.
 */
void
slobber(int c)
{

	shudclob = 0;
	switch (c) {

	case '\t':
		if (Putchar == listchar)
			return;
		break;

	default:
		return;

	case ' ':
	case 0:
		break;
	}
	if (OS)
		return;
	flush();
	putch(' ');
	if (BC)
		tputs(BC, 0, putch);
	else
		putch('\b');
}

/*
 * Print a line with a number.
 */
int
numbline(int i, int max)
{

	if (shudclob)
		slobber(' ');
	max -= printf("%6d  ", i);
	return normline(0, max);
}

/*
 * Normal line output, no numbering.
 */
int
normline(int unused, int max)
{
	extern short	vcntcol, lastsc;
	short	ovc = -1;
	register char *cp;
	int	(*OO)(int);
	int	c, n;
	int	ret = 0;

	if (max > 0)
		vcntcol = 0;
	if (shudclob)
		slobber(linebuf[0]);
	/* pdp-11 doprnt is not reentrant so can't use "printf" here
	   in case we are tracing */
	cp = linebuf;
	vcolbp = cp;
	while (*cp && max) {
		vcolbp = cp;
		nextc(c, cp, n);
		cp += n;
		if (max > 0) {
			if (Outchar != qcount) {
				OO = Outchar;
				Outchar = qcount;
				putchar(c);
				Outchar = OO;
			} else
				putchar(c);
			if ((vcntcol-1) % WCOLS == 0 && lastsc > 1)
				vcntcol++;
			if (vcntcol >= max) {
				putchar('@');
				vcntcol = ovc + 1;
				lastsc = 1;
				ret = 1;
				break;
			}
			ovc = vcntcol;
			if (Outchar != qcount)
				putchar(c);
		} else
			putchar(c);
	}
	if (!inopen) {
		putchar('\n' | QUOTE);
	}
	return ret;
}

/*
 * The output buffer is initialized with a useful error
 * message so we don't have to keep it in data space.
 */
static	char linb[66+MB_LEN_MAX];
char *linp = linb;

/*
 * Phadnl records when we have already had a complete line ending with \n.
 * If another line starts without a flush, and the terminal suggests it,
 * we switch into -nl mode so that we can send lineffeeds to avoid
 * a lot of spacing.
 */
static	bool phadnl;

/*
 * Indirect to current definition of putchar.
 */
int
putchar(int c)
{
	if (c & MULTICOL) {
		c &= ~MULTICOL;
		if (c == 0)
			return MULTICOL;
	}
	(*Putchar)(c);
	return c;
}

/*
 * Termchar routine for command mode.
 * Watch for possible switching to -nl mode.
 * Otherwise flush into next level of buffering when
 * small buffer fills or at a newline.
 */
int
termchar(int c)
{

	if (pfast == 0 && phadnl)
		pstart();
	if (c == '\n')
		phadnl = 1;
	else if (linp >= &linb[63])
		flush1();
#ifdef	MB
	if (mb_cur_max > 1 && c & ~(wchar_t)0177) {
		char	mb[MB_LEN_MAX];
		int	i, n;
		n = wctomb(mb, c&TRIM);
		for (i = 0; i < n; i++)
			*linp++ = mb[i];
	} else
#endif	/* MB */
		*linp++ = c;
	if (linp >= &linb[63]) {
		fgoto();
		flush1();
	}
	return c;
}

void
flush2(void)
{

	fgoto();
	flusho();
	pstop();
}

void
flush(void)
{

	flush1();
	flush2();
}

/*
 * Flush from small line buffer into output buffer.
 * Work here is destroying motion into positions, and then
 * letting fgoto do the optimized motion.
 */
void
flush1(void)
{
	register char *lp;
	int c, n;

	*linp = 0;
	lp = linb;
	while (*lp) {
		nextc(c, lp, n);
		lp += n;
		switch (c) {

		case '\r':
			destline += destcol / TCOLUMNS;
			destcol = 0;
			continue;

		case '\b':
			if (destcol)
				destcol--;
			continue;

		case ' ':
			destcol++;
			continue;

		case '\t':
			destcol += value(TABSTOP) - destcol % value(TABSTOP);
			continue;

		case '\n':
			destline += destcol / TCOLUMNS + 1;
			if (destcol != 0 && destcol % TCOLUMNS == 0)
				destline--;
			destcol = 0;
			continue;

		default:
			fgoto();
			for (;;) {
				if (AM == 0 && outcol == TCOLUMNS)
					fgoto();
				c &= TRIM;
				putch(c);
				if (c == '\b') {
					outcol--;
					destcol--;
#ifndef	BIT8
				} else if ( c >= ' ' && c != DELETE) {
#else
				} else if (printable(c)) {
#endif
#ifdef	MB
					n = colsc(c);
					outcol += n;
					destcol += n;
#else	/* !MB */
					outcol++;
					destcol++;
#endif	/* !MB */
					if (XN && outcol % TCOLUMNS == 0)
						putch('\r'), putch('\n');
				}
				nextc(c, lp, n);
				lp += n;
#ifndef BIT8
				if (c <= ' ')
#else
				if (c == ' ' || !printable(c))
#endif
					break;
			}
			--lp;
			continue;
		}
	}
	linp = linb;
}

static int plodcnt, plodflg;

/*
 * Move (slowly) to destination.
 * Hard thing here is using home cursor on really deficient terminals.
 * Otherwise just use cursor motions, hacking use of tabs and overtabbing
 * and backspace.
 */

int
plodput(int c)
{

	if (plodflg)
		plodcnt--;
	else
		putch(c);
	return c;
}

int
plod(int cnt)
{
	register int i, j, k = 0;
	register int soutcol, soutline;

	plodcnt = plodflg = cnt;
	soutcol = outcol;
	soutline = outline;
	/*
	 * Consider homing and moving down/right from there, vs moving
	 * directly with local motions to the right spot.
	 */
	if (HO) {
		/*
		 * i is the cost to home and tab/space to the right to
		 * get to the proper column.  This assumes ND space costs
		 * 1 char.  So i+destcol is cost of motion with home.
		 */
		if (GT)
			i = (destcol / value(HARDTABS)) + (destcol % value(HARDTABS));
		else
			i = destcol;
		/*
		 * j is cost to move locally without homing
		 */
		if (destcol >= outcol) {	/* if motion is to the right */
			j = destcol / value(HARDTABS) - outcol / value(HARDTABS);
			if (GT && j)
				j += destcol % value(HARDTABS);
			else
				j = destcol - outcol;
		} else
			/* leftward motion only works if we can backspace. */
			if (outcol - destcol <= i && (BS || BC))
				i = j = outcol - destcol; /* cheaper to backspace */
			else
				j = i + 1; /* impossibly expensive */

		/* k is the absolute value of vertical distance */
		k = outline - destline;
		if (k < 0)
			k = -k;
		j += k;

		/*
		 * Decision.  We may not have a choice if no UP.
		 */
		if (i + destline < j || (!UP && destline < outline)) {
			/*
			 * Cheaper to home.  Do it now and pretend it's a
			 * regular local motion.
			 */
			tputs(HO, 0, plodput);
			outcol = outline = 0;
		} else if (LL) {
			/*
			 * Quickly consider homing down and moving from there.
			 * Assume cost of LL is 2.
			 */
			k = (TLINES - 1) - destline;
			if (i + k + 2 < j && (k<=0 || UP)) {
				tputs(LL, 0, plodput);
				outcol = 0;
				outline = TLINES - 1;
			}
		}
	} else
	/*
	 * No home and no up means it's impossible, so we return an
	 * incredibly big number to make cursor motion win out.
	 */
		if (!UP && destline < outline)
			return (500);
	if (GT)
		i = destcol % value(HARDTABS)
		    + destcol / value(HARDTABS);
	else
		i = destcol;
/*
	if (BT && outcol > destcol && (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
		j *= (k = strlen(BT));
		if ((k += (destcol&7)) > 4)
			j += 8 - (destcol&7);
		else
			j += k;
	} else
*/
		j = outcol - destcol;
	/*
	 * If we will later need a \n which will turn into a \r\n by
	 * the system or the terminal, then don't bother to try to \r.
	 */
	if ((NONL || !pfast) && outline < destline)
		goto dontcr;
	/*
	 * If the terminal will do a \r\n and there isn't room for it,
	 * then we can't afford a \r.
	 */
	if (NC && outline >= destline)
		goto dontcr;
	/*
	 * If it will be cheaper, or if we can't back up, then send
	 * a return preliminarily.
	 */
	if (j > i + 1 || outcol > destcol && !BS && !BC) {
		/*
		 * BUG: this doesn't take the (possibly long) length
		 * of xCR into account.
		 */
		if (ospeed != B0) {
			if (xCR)
				tputs(xCR, 0, plodput);
			else
				plodput('\r');
		}
		if (NC) {
			if (xNL)
				tputs(xNL, 0, plodput);
			else
				plodput('\n');
			outline++;
		}
		outcol = 0;
	}
dontcr:
	/* Move down, if necessary, until we are at the desired line */
	while (outline < destline) {
		j = destline - outline;
		if (j > costDP && DOWN_PARM) {
			/* Win big on Tek 4025 */
			tputs(tgoto(DOWN_PARM, 0, j), j, plodput);
			outline += j;
		}
		else {
			outline++;
			if (xNL && pfast)
				tputs(xNL, 0, plodput);
			else
				plodput('\n');
		}
		if (plodcnt < 0)
			goto out;
		if (NONL || pfast == 0)
			outcol = 0;
	}
	if (BT)
		k = strlen(BT);	/* should probably be cost(BT) and moved out */
	/* Move left, if necessary, to desired column */
	while (outcol > destcol) {
		if (plodcnt < 0)
			goto out;
		if (BT && !insmode && outcol - destcol > 4+k) {
			tputs(BT, 0, plodput);
			outcol--;
			outcol -= outcol % value(HARDTABS); /* outcol &= ~7; */
			continue;
		}
		j = outcol - destcol;
		if (j > costLP && LEFT_PARM) {
			tputs(tgoto(LEFT_PARM, 0, j), j, plodput);
			outcol -= j;
		}
		else {
			outcol--;
			if (BC)
				tputs(BC, 0, plodput);
			else
				plodput('\b');
		}
	}
	/* Move up, if necessary, to desired row */
	while (outline > destline) {
		j = outline - destline;
		if (UP_PARM && j > 1) {
			/* Win big on Tek 4025 */
			tputs(tgoto(UP_PARM, 0, j), j, plodput);
			outline -= j;
		}
		else {
			outline--;
			tputs(UP, 0, plodput);
		}
		if (plodcnt < 0)
			goto out;
	}
	/*
	 * Now move to the right, if necessary.  We first tab to
	 * as close as we can get.
	 */
	if (GT && !insmode && destcol - outcol > 1) {
		/* tab to right as far as possible without passing col */
		for (;;) {
			i = tabcol(outcol, value(HARDTABS));
			if (i > destcol)
				break;
			if (TA)
				tputs(TA, 0, plodput);
			else
				plodput('\t');
			outcol = i;
		}
		/* consider another tab and then some backspaces */
		if (destcol - outcol > 4 && i < TCOLUMNS && (BC || BS)) {
			if (TA)
				tputs(TA, 0, plodput);
			else
				plodput('\t');
			outcol = i;
			/*
			 * Back up.  Don't worry about LEFT_PARM because
			 * it's never more than 4 spaces anyway.
			 */
			while (outcol > destcol) {
				outcol--;
				if (BC)
					tputs(BC, 0, plodput);
				else
					plodput('\b');
			}
		}
	}
	/*
	 * We've tabbed as much as possible.  If we still need to go
	 * further (not exact or can't tab) space over.  This is a
	 * very common case when moving to the right with space.
	 */
	while (outcol < destcol) {
		j = destcol - outcol;
		if (j > costRP && RIGHT_PARM) {
			/*
			 * This probably happens rarely, if at all.
			 * It seems mainly useful for ANSI terminals
			 * with no hardware tabs, and I don't know
			 * of any such terminal at the moment.
			 */
			tputs(tgoto(RIGHT_PARM, 0, j), j, plodput);
			outcol += j;
		}
		else {
			/*
			 * move one char to the right.  We don't use ND space
			 * because it's better to just print the char we are
			 * moving over.  There are various exceptions, however.
			 * If !inopen, vtube contains garbage.  If the char is
			 * a null or a tab we want to print a space.  Other
			 * random chars we use space for instead, too.
			 */
			if (!inopen || vtube[outline]==NULL ||
#ifndef	BIT8
				((i=vtube[outline][outcol]) < ' ')
#else
				((i=vtube[outline][outcol]) == 0)
					|| (i!=MULTICOL && !printable(i&~INVBIT&~MULTICOL))
#endif
				)
				i = ' ';
			if((i & (QUOTE|INVBIT)) == QUOTE) /* mjm: no sign
							     extension on 3B */
				i = ' ';
			if ((insmode || i == MULTICOL) && ND)
				tputs(ND, 0, plodput);
			else if (i == MULTICOL) {
				if (BS && BC)
					tputs(BC, 0, plodput);
				else
					plodput('\b');
				plodput(vtube[outline][outcol-1]);
			} else
				plodput(i);
			outcol += i == MULTICOL ? 1 : colsc(i & ~MULTICOL);
		}
		if (plodcnt < 0)
			goto out;
	}
out:
	if (plodflg) {
		outcol = soutcol;
		outline = soutline;
	}
	return(plodcnt);
}

/*
 * Sync the position of the output cursor.
 * Most work here is rounding for terminal boundaries getting the
 * column position implied by wraparound or the lack thereof and
 * rolling up the screen to get destline on the screen.
 */
void
fgoto(void)
{
	register int l, c;

	if (destcol > TCOLUMNS - 1) {
		destline += destcol / TCOLUMNS;
		destcol %= TCOLUMNS;
	}
	if (outcol > TCOLUMNS - 1) {
		l = (outcol + 1) / TCOLUMNS;
		outline += l;
		outcol %= TCOLUMNS;
		if (AM == 0) {
			while (l > 0) {
				if (pfast && ospeed != B0)
					if (xCR)
						tputs(xCR, 0, putch);
					else
						putch('\r');
				if (xNL)
					tputs(xNL, 0, putch);
				else
					putch('\n');
				l--;
			}
			outcol = 0;
		}
		if (outline > TLINES - 1) {
			destline -= outline - (TLINES - 1);
			outline = TLINES - 1;
		}
	}
	if (destline > TLINES - 1) {
		l = destline;
		destline = TLINES - 1;
		if (outline < TLINES - 1) {
			c = destcol;
			if (pfast == 0 && (!CA || holdcm))
				destcol = 0;
			fgoto();
			destcol = c;
		}
		while (l > TLINES - 1) {
			/*
			 * The following linefeed (or simulation thereof)
			 * is supposed to scroll up the screen, since we
			 * are on the bottom line.  We make the assumption
			 * that linefeed will scroll.  If ns is in the
			 * capability list this won't work.  We should
			 * probably have an sc capability but sf will
			 * generally take the place if it works.
			 *
			 * Superbee glitch:  in the middle of the screen we
			 * have to use esc B (down) because linefeed screws up
			 * in "Efficient Paging" (what a joke) mode (which is
			 * essential in some SB's because CRLF mode puts garbage
			 * in at end of memory), but you must use linefeed to
			 * scroll since down arrow won't go past memory end.
			 * I turned this off after recieving Paul Eggert's
			 * Superbee description which wins better.
			 */
			if (xNL /* && !XB */ && pfast)
				tputs(xNL, 0, putch);
			else
				putch('\n');
			l--;
			if (pfast == 0)
				outcol = 0;
		}
	}
	if (destline < outline && !(CA && !holdcm || UP != NOSTR))
		destline = outline;
	if (CA && !holdcm)
		if (plod(costCM) > 0)
			plod(0);
		else
			tputs(tgoto(CM, destcol, destline), 0, putch);
	else
		plod(0);
	outline = destline;
	outcol = destcol;
}

/*
 * Tab to column col by flushing and then setting destcol.
 * Used by "set all".
 */
void
tab(int col)
{

	flush1();
	destcol = col;
}

/*
 * An input line arrived.
 * Calculate new (approximate) screen line position.
 * Approximate because kill character echoes newline with
 * no feedback and also because of long input lines.
 */
void
noteinp(void)
{

	outline++;
	if (outline > TLINES - 1)
		outline = TLINES - 1;
	destline = outline;
	destcol = outcol = 0;
}

/*
 * Something weird just happened and we
 * lost track of whats happening out there.
 * Since we cant, in general, read where we are
 * we just reset to some known state.
 * On cursor addressible terminals setting to unknown
 * will force a cursor address soon.
 */
void
termreset(void)
{

	endim();
	if (TI)	/* otherwise it flushes anyway, and 'set tty=dumb' vomits */
		putpad(TI);	 /*adb change -- emit terminal initial sequence */
	destcol = 0;
	destline = TLINES - 1;
	if (CA) {
		outcol = UKCOL;
		outline = UKCOL;
	} else {
		outcol = destcol;
		outline = destline;
	}
}

/*
 * Low level buffering, with the ability to drain
 * buffered output without printing it.
 */
char	*obp = obuf;

void
draino(void)
{

	obp = obuf;
}

void
flusho(void)
{

	if (obp != obuf) {
		write(1, obuf, obp - obuf);
		obp = obuf;
	}
}

void
putnl(void)
{

	putchar('\n');
}

void
putS(char *cp)
{

	if (cp == NULL)
		return;
	while (*cp)
		putch(*cp++);
}


int
putch(int c)
{

#ifdef OLD3BTTY		/* mjm */
	if(c == '\n')	/* mjm: Fake "\n\r" for '\n' til fix in 3B firmware */
		putch('\r');	/* mjm: vi does "stty -icanon" => -onlcr !! */
#endif
	if (c & MULTICOL) {
		c &= ~MULTICOL;
		if (c == 0)
			return MULTICOL;
	}
	c &= ~INVBIT;	/* strip '~' | INVBIT multicolumn filler */
#ifdef	MB
	if (mb_cur_max > 1 && c & ~(wchar_t)0177) {
		char	mb[MB_LEN_MAX];
		int	i, n;
		n = wctomb(mb, c&TRIM);
		for (i = 0; i < n; i++) {
			*obp++ = mb[i];
			if (obp >= &obuf[sizeof obuf])
				flusho();
		}
	} else
#endif	/* MB */
		*obp++ = c & TRIM;
	if (obp >= &obuf[sizeof obuf])
		flusho();
	return c;
}

/*
 * Miscellaneous routines related to output.
 */

/*
 * Put with padding
 */
void
putpad(char *cp)
{

	flush();
	tputs(cp, 0, putch);
}

/*
 * Set output through normal command mode routine.
 */
void
setoutt(void)
{

	Outchar = termchar;
}

/*
 * Printf (temporarily) in list mode.
 */
/*VARARGS2*/
void
vlprintf(char *cp, va_list ap)
{
	register int (*P)(int);

	P = setlist(1);
	vprintf(cp, ap);
	Putchar = P;
}

void
lprintf(char *cp, ...)
{
	va_list ap;

	va_start(ap, cp);
	vlprintf(cp, ap);
	va_end(ap);
}

/*
 * Newline + flush.
 */
void
putNFL(void)
{

	putnl();
	flush();
}

/*
 * sTTY: set the tty modes on file descriptor i to be what's
 * currently in global "tty".  (Also use nttyc if needed.)
 */
void
sTTY(int i)
{

	tcsetattr(i, TCSADRAIN, &tty);
}

/*
 * Try to start -nl mode.
 */
void
pstart(void)
{

	if (NONL)
		return;
 	if (!value(OPTIMIZE))
		return;
	if (ruptible == 0 || pfast)
		return;
	fgoto();
	flusho();
	pfast = 1;
	normtty++;
	tty = normf;
	tty.c_oflag &= ~(ONLCR
#if defined (TAB3)
			| TAB3
#elif defined (XTABS)
			| XTABS
#endif
			);
	tty.c_lflag &= ~ECHO;
	sTTY(1);
}

/*
 * Stop -nl mode.
 */
void
pstop(void)
{

	if (inopen)
		return;
	phadnl = 0;
	linp = linb;
	draino();
	normal(normf);
	pfast &= ~1;
}

/*
 * Turn off start/stop chars if they aren't the default ^S/^Q.
 * This is so idiots who make esc their start/stop don't lose.
 * We always turn off quit since datamedias send ^\ for their
 * right arrow key.
 */
void
ttcharoff(void)
{
#ifdef	_PC_VDISABLE
	long vdis;

	errno = 0;
#ifndef	__dietlibc__
	vdis = fpathconf(1, _PC_VDISABLE);
	if (errno)
		/*
		 * Use the old value of 0377, hope it is not
		 * the user's favourite character.
		 */
#endif	/* !__dietlibc__ */
		vdis = '\377';
#else	/* !_PC_VDISABLE */
#define	vdis	'\377';
#endif	/* !_PC_VDISABLE */
	tty.c_cc[VQUIT] = vdis;
#ifdef	VSUSP
	tty.c_cc[VSUSP] = vdis;
#endif
#ifdef	VDSUSP
	tty.c_cc[VDSUSP] = vdis;
#endif
#ifdef	VREPRINT
	tty.c_cc[VREPRINT] = vdis;
#endif
#ifdef	VDISCRD
	tty.c_cc[VDISCRD] = vdis;
#endif
#ifdef	VWERASE
	tty.c_cc[VWERASE] = vdis;
#endif
#ifdef	VLNEXT
	tty.c_cc[VLNEXT] = vdis;
#endif
#ifdef	VSTATUS
	tty.c_cc[VSTATUS] = vdis;
#endif
# ifdef VSTART
	/*
	 * The following is sample code if USG ever lets people change
	 * their start/stop chars.  As long as they can't we can't get
	 * into trouble so we just leave them alone.
	 */
	if (tty.c_cc[VSTART] != CTRL('q'))
		tty.c_cc[VSTART] = vdis;
	if (tty.c_cc[VSTOP] != CTRL('s'))
		tty.c_cc[VSTOP] = vdis;
# endif
}

/*
 * Prep tty for open mode.
 */
struct termios
ostart(void)
{
	struct termios f;

	if (!intty)
		error(catgets(catd, 1, 120,
				"Open and visual must be used interactively"));
	gTTY(1);
	normtty++;
	f = tty;
	tty = normf;
	tty.c_iflag &= ~ICRNL;
	tty.c_lflag &= ~(ECHO|ICANON);
	tty.c_oflag &= ~(ONLCR
#if defined (TAB3)
			| TAB3
#elif defined (XTABS)
			| XTABS
#endif
			);
	tty.c_cc[VMIN] = 1;
	tty.c_cc[VTIME] = 1;
	ttcharoff();
	sTTY(1);
	tostart();
	pfast |= 2;
	return (f);
}

/* actions associated with putting the terminal in open mode */
void
tostart(void)
{
	putpad(VS);
	putpad(KS);
	if (!value(MESG)) {
		if (ttynbuf[0] == 0) {
			register char *tn;
			if ((tn=ttyname(2)) == NULL &&
			    (tn=ttyname(1)) == NULL &&
			    (tn=ttyname(0)) == NULL)
				ttynbuf[0] = 1;
			else
				safecp(ttynbuf, tn, sizeof ttynbuf,
						"%s too long", tn);
		}
		if (ttynbuf[0] != 1) {
			struct stat sbuf;
			stat(ttynbuf, &sbuf);
			ttymesg = sbuf.st_mode & 0777;
			chmod(ttynbuf,
#ifdef UCBV7
	/*
	 * This applies to the UCB V7 Pdp-11 system with the
	 * -u write option only.
	 */
					0611	/* 11 = urgent only allowed */
#else
					0600
#endif
						);
		}
	}
}

/*
 * Stop open, restoring tty modes.
 */
void
ostop(struct termios f)
{

	pfast = (f.c_oflag & ONLCR) == 0;
	termreset(), fgoto(), flusho();
	normal(f);
	tostop();
}

/* Actions associated with putting the terminal in the right mode. */
void
tostop(void)
{
	putpad(VE);
	putpad(KE);
	if (!value(MESG) && ttynbuf[0]>1)
		chmod(ttynbuf, ttymesg);
}

/*
 * Restore flags to normal state f.
 */
void
normal(struct termios f)
{

	if (normtty > 0) {
		setty(f);
		normtty--;
	}
}

/*
 * Straight set of flags to state f.
 */
struct termios
setty(struct termios f)
{
	struct termios ot;
	ot = tty;

	if (tty.c_lflag & ICANON)
		ttcharoff();
	tty = f;
	sTTY(1);
	return (ot);
}

void
gTTY(int i)
{

	tcgetattr(i, &tty);
}

/*
 * Print newline, or blank if in open/visual
 */
void
noonl(void)
{

	putchar(Outchar != termchar ? ' ' : '\n');
}
