From 0bf22a0c2bbab7ee2b5ac5f1159e40bea326eab7 Mon Sep 17 00:00:00 2001
From: Oliver Lehmann <lehmann@ans-netz.de>
Date: Sat, 8 Jun 1985 05:58:39 +0000
Subject: [PATCH] add LCC - a better C-Compiler for WEGA

---
 WEGA/contrib/lcc/contrib/libcurses/cr_put.c  | 390 +++++++++++++++++++
 WEGA/contrib/lcc/contrib/libcurses/refresh.c | 308 +++++++++++++++
 2 files changed, 698 insertions(+)
 create mode 100644 WEGA/contrib/lcc/contrib/libcurses/cr_put.c
 create mode 100644 WEGA/contrib/lcc/contrib/libcurses/refresh.c

diff --git a/WEGA/contrib/lcc/contrib/libcurses/cr_put.c b/WEGA/contrib/lcc/contrib/libcurses/cr_put.c
new file mode 100644
index 0000000..1f01e3f
--- /dev/null
+++ b/WEGA/contrib/lcc/contrib/libcurses/cr_put.c
@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) 1980 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)cr_put.c	5.1 (Berkeley) 6/7/85";
+#endif not lint
+
+# include	"curses.ext"
+
+# define	HARDTABS	8
+
+extern char	*tgoto();
+int		plodput();
+
+/*
+ * 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).
+ */
+
+/*
+ * 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.
+ */
+
+static int	outcol, outline, destcol, destline;
+
+WINDOW		*_win;
+
+mvcur(ly, lx, y, x)
+int	ly, lx, y, x; {
+
+#ifdef DEBUG
+	fprintf(outf, "MVCUR: moving cursor from (%d,%d) to (%d,%d)\n", ly, lx, y, x);
+#endif
+	destcol = x;
+	destline = y;
+	outcol = lx;
+	outline = ly;
+	fgoto();
+}
+
+fgoto()
+{
+	reg char	*cgp;
+	reg int		l, c;
+
+	if (destcol >= COLS) {
+		destline += destcol / COLS;
+		destcol %= COLS;
+	}
+	if (outcol >= COLS) {
+		l = (outcol + 1) / COLS;
+		outline += l;
+		outcol %= COLS;
+		if (AM == 0) {
+			while (l > 0) {
+				if (_pfast)
+					if (CR)
+						_puts(CR);
+					else
+						_putchar('\r');
+				if (NL)
+					_puts(NL);
+				else
+					_putchar('\n');
+				l--;
+			}
+			outcol = 0;
+		}
+		if (outline > LINES - 1) {
+			destline -= outline - (LINES - 1);
+			outline = LINES - 1;
+		}
+	}
+	if (destline >= LINES) {
+		l = destline;
+		destline = LINES - 1;
+		if (outline < LINES - 1) {
+			c = destcol;
+			if (_pfast == 0 && !CA)
+				destcol = 0;
+			fgoto();
+			destcol = c;
+		}
+		while (l >= LINES) {
+			/*
+			 * 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 (NL /* && !XB */ && _pfast)
+				_puts(NL);
+			else
+				_putchar('\n');
+			l--;
+			if (_pfast == 0)
+				outcol = 0;
+		}
+	}
+	if (destline < outline && !(CA || UP))
+		destline = outline;
+	if (CA) {
+		cgp = tgoto(CM, destcol, destline);
+		if (plod(strlen(cgp)) > 0)
+			plod(0);
+		else
+			tputs(cgp, 0, _putchar);
+	}
+	else
+		plod(0);
+	outline = destline;
+	outcol = destcol;
+}
+
+/*
+ * 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.
+ */
+
+static int plodcnt, plodflg;
+
+plodput(c)
+{
+	if (plodflg)
+		plodcnt--;
+	else
+		_putchar(c);
+}
+
+plod(cnt)
+{
+	register int i, j, k;
+	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 / HARDTABS) + (destcol % HARDTABS);
+		else
+			i = destcol;
+		/*
+		 * j is cost to move locally without homing
+		 */
+		if (destcol >= outcol) {	/* if motion is to the right */
+			j = destcol / HARDTABS - outcol / HARDTABS;
+			if (GT && j)
+				j += destcol % 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 = (LINES - 1) - destline;
+			if (i + k + 2 < j && (k<=0 || UP)) {
+				tputs(LL, 0, plodput);
+				outcol = 0;
+				outline = LINES - 1;
+			}
+		}
+	}
+	else
+	/*
+	 * No home and no up means it's impossible.
+	 */
+		if (!UP && destline < outline)
+			return -1;
+	if (GT)
+		i = destcol % HARDTABS + destcol / 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 CR into account.
+		 */
+		if (CR)
+			tputs(CR, 0, plodput);
+		else
+			plodput('\r');
+		if (NC) {
+			if (NL)
+				tputs(NL, 0, plodput);
+			else
+				plodput('\n');
+			outline++;
+		}
+		outcol = 0;
+	}
+dontcr:
+	while (outline < destline) {
+		outline++;
+		if (NL)
+			tputs(NL, 0, plodput);
+		else
+			plodput('\n');
+		if (plodcnt < 0)
+			goto out;
+		if (NONL || _pfast == 0)
+			outcol = 0;
+	}
+	if (BT)
+		k = strlen(BT);
+	while (outcol > destcol) {
+		if (plodcnt < 0)
+			goto out;
+/*
+		if (BT && outcol - destcol > k + 4) {
+			tputs(BT, 0, plodput);
+			outcol--;
+			outcol &= ~7;
+			continue;
+		}
+*/
+		outcol--;
+		if (BC)
+			tputs(BC, 0, plodput);
+		else
+			plodput('\b');
+	}
+	while (outline > destline) {
+		outline--;
+		tputs(UP, 0, plodput);
+		if (plodcnt < 0)
+			goto out;
+	}
+	if (GT && destcol - outcol > 1) {
+		for (;;) {
+			i = tabcol(outcol, HARDTABS);
+			if (i > destcol)
+				break;
+			if (TA)
+				tputs(TA, 0, plodput);
+			else
+				plodput('\t');
+			outcol = i;
+		}
+		if (destcol - outcol > 4 && i < COLS && (BC || BS)) {
+			if (TA)
+				tputs(TA, 0, plodput);
+			else
+				plodput('\t');
+			outcol = i;
+			while (outcol > destcol) {
+				outcol--;
+				if (BC)
+					tputs(BC, 0, plodput);
+				else
+					plodput('\b');
+			}
+		}
+	}
+	while (outcol < destcol) {
+		/*
+		 * 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.
+		 */
+		if (_win != NULL)
+			if (plodflg)	/* avoid a complex calculation */
+				plodcnt--;
+			else {
+				i = curscr->_y[outline][outcol];
+				if ((i&_STANDOUT) == (curscr->_flags&_STANDOUT))
+					_putchar(i);
+				else
+					goto nondes;
+			}
+		else
+nondes:
+		     if (ND)
+			tputs(ND, 0, plodput);
+		else
+			plodput(' ');
+		outcol++;
+		if (plodcnt < 0)
+			goto out;
+	}
+out:
+	if (plodflg) {
+		outcol = soutcol;
+		outline = soutline;
+	}
+	return(plodcnt);
+}
+
+/*
+ * Return the column number that results from being in column col and
+ * hitting a tab, where tabs are set every ts columns.  Work right for
+ * the case where col > COLS, even if ts does not divide COLS.
+ */
+tabcol(col, ts)
+int col, ts;
+{
+	int offset, result;
+
+	if (col >= COLS) {
+		offset = COLS * (col / COLS);
+		col -= offset;
+	}
+	else
+		offset = 0;
+	return col + ts - (col % ts) + offset;
+}
diff --git a/WEGA/contrib/lcc/contrib/libcurses/refresh.c b/WEGA/contrib/lcc/contrib/libcurses/refresh.c
new file mode 100644
index 0000000..110006f
--- /dev/null
+++ b/WEGA/contrib/lcc/contrib/libcurses/refresh.c
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 1980 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)refresh.c	5.1 (Berkeley) 6/7/85";
+#endif not lint
+
+/*
+ * make the current screen look like "win" over the area coverd by
+ * win.
+ */
+
+# include	"curses.ext"
+
+# ifdef DEBUG
+# define	STATIC
+# else
+# define	STATIC	static
+# endif
+
+STATIC short	ly, lx;
+
+STATIC bool	curwin;
+
+WINDOW	*_win = NULL;
+
+wrefresh(win)
+reg WINDOW	*win;
+{
+	reg short	wy;
+	reg int		retval;
+	reg WINDOW	*orig;
+
+	/*
+	 * make sure were in visual state
+	 */
+	if (_endwin) {
+		_puts(VS);
+		_puts(TI);
+		_endwin = FALSE;
+	}
+
+	/*
+	 * initialize loop parameters
+	 */
+
+	ly = curscr->_cury;
+	lx = curscr->_curx;
+	wy = 0;
+	_win = win;
+	curwin = (win == curscr);
+
+	if (win->_clear || curscr->_clear || curwin) {
+		if ((win->_flags & _FULLWIN) || curscr->_clear) {
+			_puts(CL);
+			ly = 0;
+			lx = 0;
+			if (!curwin) {
+				curscr->_clear = FALSE;
+				curscr->_cury = 0;
+				curscr->_curx = 0;
+				werase(curscr);
+			}
+			touchwin(win);
+		}
+		win->_clear = FALSE;
+	}
+	if (!CA) {
+		if (win->_curx != 0)
+			_putchar('\n');
+		if (!curwin)
+			werase(curscr);
+	}
+# ifdef DEBUG
+	fprintf(outf, "REFRESH(%0.2o): curwin = %d\n", win, curwin);
+	fprintf(outf, "REFRESH:\n\tfirstch\tlastch\n");
+# endif
+	for (wy = 0; wy < win->_maxy; wy++) {
+# ifdef DEBUG
+		fprintf(outf, "%d\t%d\t%d\n", wy, win->_firstch[wy],
+			win->_lastch[wy]);
+# endif
+		if (win->_firstch[wy] != _NOCHANGE)
+			if (makech(win, wy) == ERR)
+				return ERR;
+			else {
+				if (win->_firstch[wy] >= win->_ch_off)
+					win->_firstch[wy] = win->_maxx +
+							    win->_ch_off;
+				if (win->_lastch[wy] < win->_maxx +
+						       win->_ch_off)
+					win->_lastch[wy] = win->_ch_off;
+				if (win->_lastch[wy] < win->_firstch[wy])
+					win->_firstch[wy] = _NOCHANGE;
+			}
+# ifdef DEBUG
+		fprintf(outf, "\t%d\t%d\n", win->_firstch[wy],
+			win->_lastch[wy]);
+# endif
+	}
+
+	if (win == curscr)
+		domvcur(ly, lx, win->_cury, win->_curx);
+	else {
+		if (win->_leave) {
+			curscr->_cury = ly;
+			curscr->_curx = lx;
+			ly -= win->_begy;
+			lx -= win->_begx;
+			if (ly >= 0 && ly < win->_maxy && lx >= 0 &&
+			    lx < win->_maxx) {
+				win->_cury = ly;
+				win->_curx = lx;
+			}
+			else
+				win->_cury = win->_curx = 0;
+		}
+		else {
+			domvcur(ly, lx, win->_cury + win->_begy,
+				win->_curx + win->_begx);
+			curscr->_cury = win->_cury + win->_begy;
+			curscr->_curx = win->_curx + win->_begx;
+		}
+	}
+	retval = OK;
+ret:
+	_win = NULL;
+	fflush(stdout);
+	return retval;
+}
+
+/*
+ * make a change on the screen
+ */
+STATIC
+makech(win, wy)
+reg WINDOW	*win;
+short		wy;
+{
+	reg char	*nsp, *csp, *ce;
+	reg short	wx, lch, y;
+	reg int		nlsp, clsp;	/* last space in lines		*/
+
+	wx = win->_firstch[wy] - win->_ch_off;
+	if (wx >= win->_maxx)
+		return OK;
+	else if (wx < 0)
+		wx = 0;
+	lch = win->_lastch[wy] - win->_ch_off;
+	if (lch < 0)
+		return OK;
+	else if (lch >= win->_maxx)
+		lch = win->_maxx - 1;;
+	y = wy + win->_begy;
+
+	if (curwin)
+		csp = " ";
+	else
+		csp = &curscr->_y[wy + win->_begy][wx + win->_begx];
+
+	nsp = &win->_y[wy][wx];
+	if (CE && !curwin) {
+		for (ce = &win->_y[wy][win->_maxx - 1]; *ce == ' '; ce--)
+			if (ce <= win->_y[wy])
+				break;
+		nlsp = ce - win->_y[wy];
+	}
+
+	if (!curwin)
+		ce = CE;
+	else
+		ce = NULL;
+
+	while (wx <= lch) {
+		if (*nsp != *csp) {
+			domvcur(ly, lx, y, wx + win->_begx);
+# ifdef DEBUG
+			fprintf(outf, "MAKECH: 1: wx = %d, lx = %d\n", wx, lx);
+# endif	
+			ly = y;
+			lx = wx + win->_begx;
+			while (*nsp != *csp && wx <= lch) {
+				if (ce != NULL && wx >= nlsp && *nsp == ' ') {
+					/*
+					 * check for clear to end-of-line
+					 */
+					ce = &curscr->_y[ly][COLS - 1];
+					while (*ce == ' ')
+						if (ce-- <= csp)
+							break;
+					clsp = ce - curscr->_y[ly] - win->_begx;
+# ifdef DEBUG
+					fprintf(outf, "MAKECH: clsp = %d, nlsp = %d\n", clsp, nlsp);
+# endif
+					if (clsp - nlsp >= strlen(CE)
+					    && clsp < win->_maxx) {
+# ifdef DEBUG
+						fprintf(outf, "MAKECH: using CE\n");
+# endif
+						_puts(CE);
+						lx = wx + win->_begx;
+						while (wx++ <= clsp)
+							*csp++ = ' ';
+						return OK;
+					}
+					ce = NULL;
+				}
+				/*
+				 * enter/exit standout mode as appropriate
+				 */
+				if (SO && (*nsp&_STANDOUT) != (curscr->_flags&_STANDOUT)) {
+					if (*nsp & _STANDOUT) {
+						_puts(SO);
+						curscr->_flags |= _STANDOUT;
+					}
+					else {
+						_puts(SE);
+						curscr->_flags &= ~_STANDOUT;
+					}
+				}
+				wx++;
+				if (wx >= win->_maxx && wy == win->_maxy - 1)
+					if (win->_scroll) {
+					    if ((curscr->_flags&_STANDOUT) &&
+					        (win->_flags & _ENDLINE))
+						    if (!MS) {
+							_puts(SE);
+							curscr->_flags &= ~_STANDOUT;
+						    }
+					    if (!curwin)
+						_putchar((*csp = *nsp) & 0177);
+					    else
+						_putchar(*nsp & 0177);
+					    if (win->_flags&_FULLWIN && !curwin)
+						scroll(curscr);
+					    ly = win->_begy+win->_cury;
+					    lx = win->_begx+win->_curx;
+					    return OK;
+					}
+					else if (win->_flags&_SCROLLWIN) {
+					    lx = --wx;
+					    return ERR;
+					}
+				if (!curwin)
+					_putchar((*csp++ = *nsp) & 0177);
+				else
+					_putchar(*nsp & 0177);
+# ifdef FULLDEBUG
+				fprintf(outf,
+					"MAKECH:putchar(%c)\n", *nsp & 0177);
+# endif
+				if (UC && (*nsp & _STANDOUT)) {
+					_putchar('\b');
+					_puts(UC);
+				}
+				nsp++;
+			}
+# ifdef DEBUG
+			fprintf(outf, "MAKECH: 2: wx = %d, lx = %d\n", wx, lx);
+# endif	
+			if (lx == wx + win->_begx)	/* if no change */
+				break;
+			lx = wx + win->_begx;
+			if (lx >= COLS && AM) {
+				lx = 0;
+				ly++;
+				/*
+				 * xn glitch: chomps a newline after auto-wrap.
+				 * we just feed it now and forget about it.
+				 */
+				if (XN) {
+					_putchar('\n');
+					_putchar('\r');
+				}
+			}
+		}
+		else if (wx <= lch)
+			while (*nsp == *csp && wx <= lch) {
+				nsp++;
+				if (!curwin)
+					csp++;
+				++wx;
+			}
+		else
+			break;
+# ifdef DEBUG
+		fprintf(outf, "MAKECH: 3: wx = %d, lx = %d\n", wx, lx);
+# endif	
+	}
+	return OK;
+}
+
+/*
+ * perform a mvcur, leaving standout mode if necessary
+ */
+STATIC
+domvcur(oy, ox, ny, nx)
+int	oy, ox, ny, nx; {
+
+	if (curscr->_flags & _STANDOUT && !MS) {
+		_puts(SE);
+		curscr->_flags &= ~_STANDOUT;
+	}
+	mvcur(oy, ox, ny, nx);
+}