X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/3b35bf499f76e67f8f24afd8572a953ec82c4c18..3958cd1211fd7c17c60cafce34c06e6d81f5d793:/lib/libcurses/cr_put.c

diff --git a/lib/libcurses/cr_put.c b/lib/libcurses/cr_put.c
index c9d0e79134..b50875c912 100644
--- a/lib/libcurses/cr_put.c
+++ b/lib/libcurses/cr_put.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 1981 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1981, 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
@@ -32,51 +32,62 @@
  */
 
 #ifndef lint
-static char sccsid[] = "@(#)cr_put.c	5.5 (Berkeley) 6/1/90";
-#endif /* not lint */
+static char sccsid[] = "@(#)cr_put.c	8.2 (Berkeley) 1/9/94";
+#endif	/* not lint */
 
-# include	"curses.ext"
+#include <curses.h>
+#include <string.h>
 
-# define	HARDTABS	8
-
-extern char	*tgoto();
-int		plodput();
+#define	HARDTABS	8
 
 /*
- * Terminal driving and line formatting routines.
- * Basic motion optimizations are done here as well
- * as formatting of lines (printing of control characters,
+ * Terminal driving and line formatting routines.  Basic motion optimizations
+ * are done here as well as formatting 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;
+/* Stub function for the users. */
+int
+mvcur(ly, lx, y, x)
+	int ly, lx, y, x;
+{
+	return (__mvcur(ly, lx, y, x, 0));
+}
 
-WINDOW		*_win;
+static void	fgoto __P((int));
+static int	plod __P((int, int));
+static void     plodput __P((int));
+static int	tabcol __P((int, int));
 
-mvcur(ly, lx, y, x)
-int	ly, lx, y, x; {
+static int outcol, outline, destcol, destline;
 
+/*
+ * 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.
+ */
+int
+__mvcur(ly, lx, y, x, in_refresh)
+	int ly, lx, y, x, in_refresh;
+{
 #ifdef DEBUG
-	fprintf(outf, "MVCUR: moving cursor from (%d,%d) to (%d,%d)\n", ly, lx, y, x);
+	__CTRACE("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()
+	fgoto(in_refresh);
+	return (OK);
+}	
+        
+static void
+fgoto(in_refresh)
+	int in_refresh;
 {
-	reg char	*cgp;
-	reg int		l, c;
+	register int c, l;
+	register char *cgp;
 
 	if (destcol >= COLS) {
 		destline += destcol / COLS;
@@ -88,15 +99,15 @@ fgoto()
 		outcol %= COLS;
 		if (AM == 0) {
 			while (l > 0) {
-				if (_pfast)
+				if (__pfast)
 					if (CR)
-						_puts(CR);
+						tputs(CR, 0, __cputchar);
 					else
-						_putchar('\r');
+						putchar('\r');
 				if (NL)
-					_puts(NL);
+					tputs(NL, 0, __cputchar);
 				else
-					_putchar('\n');
+					putchar('\n');
 				l--;
 			}
 			outcol = 0;
@@ -111,36 +122,35 @@ fgoto()
 		destline = LINES - 1;
 		if (outline < LINES - 1) {
 			c = destcol;
-			if (_pfast == 0 && !CA)
+			if (__pfast == 0 && !CA)
 				destcol = 0;
-			fgoto();
+			fgoto(in_refresh);
 			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.
+			/* 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 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);
+			if (NL /* && !XB */ && __pfast)
+				tputs(NL, 0, __cputchar);
 			else
-				_putchar('\n');
+				putchar('\n');
 			l--;
-			if (_pfast == 0)
+			if (__pfast == 0)
 				outcol = 0;
 		}
 	}
@@ -148,17 +158,20 @@ fgoto()
 		destline = outline;
 	if (CA) {
 		cgp = tgoto(CM, destcol, destline);
-		if (plod(strlen(cgp)) > 0)
-			plod(0);
-		else
-			tputs(cgp, 0, _putchar);
-	}
-	else
-		plod(0);
+
+		/*
+		 * Need this condition due to inconsistent behavior
+		 * of backspace on the last column.
+		 */
+		if (outcol != COLS - 1 && plod(strlen(cgp), in_refresh) > 0)
+			plod(0, in_refresh);
+		else 
+			tputs(cgp, 0, __cputchar);
+	} else
+		plod(0, in_refresh);
 	outline = destline;
 	outcol = destcol;
 }
-
 /*
  * Move (slowly) to destination.
  * Hard thing here is using home cursor on really deficient terminals.
@@ -168,63 +181,63 @@ fgoto()
 
 static int plodcnt, plodflg;
 
+static void
 plodput(c)
+	int c;
 {
 	if (plodflg)
-		plodcnt--;
+		--plodcnt;
 	else
-		_putchar(c);
+		putchar(c);
 }
 
-plod(cnt)
+static int
+plod(cnt, in_refresh)
+	int cnt, in_refresh;
 {
-	register int i, j, k;
-	register int soutcol, soutline;
-	chtype ch;
+	register int i, j, k, soutcol, soutline;
 
 	plodcnt = plodflg = cnt;
 	soutcol = outcol;
 	soutline = outline;
 	/*
-	 * Consider homing and moving down/right from there, vs moving
+	 * 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.
+		 * 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
-		 */
+
+		/* 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
+		} else
 			/* leftward motion only works if we can backspace. */
 			if (outcol - destcol <= i && (BS || BC))
-				i = j = outcol - destcol; /* cheaper to backspace */
+				/* Cheaper to backspace. */
+				i = j = outcol - destcol;
 			else
-				j = i + 1; /* impossibly expensive */
+				/* Impossibly expensive. */
+				j = i + 1;
 
-		/* k is the absolute value of vertical distance */
+		/* 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.
-		 */
+		/* 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
@@ -232,32 +245,29 @@ plod(cnt)
 			 */
 			tputs(HO, 0, plodput);
 			outcol = outline = 0;
-		}
-		else if (LL) {
+		} 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)) {
+			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.
-	 */
+	} else
+		/* No home and no up means it's impossible. */
 		if (!UP && destline < outline)
-			return -1;
+			return (-1);
 	if (GT)
 		i = destcol % HARDTABS + destcol / HARDTABS;
 	else
 		i = destcol;
-/*
-	if (BT && outcol > destcol && (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
+#ifdef notdef
+	if (BT && outcol > destcol &&
+	    (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
 		j *= (k = strlen(BT));
 		if ((k += (destcol&7)) > 4)
 			j += 8 - (destcol&7);
@@ -265,28 +275,31 @@ plod(cnt)
 			j += k;
 	}
 	else
-*/
+#endif
 		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 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)
+	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 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 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.
+		 * BUG: this doesn't take the (possibly long) length of CR
+		 * into account.
 		 */
 		if (CR)
 			tputs(CR, 0, plodput);
@@ -301,8 +314,8 @@ plod(cnt)
 		}
 		outcol = 0;
 	}
-dontcr:
-	while (outline < destline) {
+
+dontcr:	while (outline < destline) {
 		outline++;
 		if (NL)
 			tputs(NL, 0, plodput);
@@ -310,7 +323,7 @@ dontcr:
 			plodput('\n');
 		if (plodcnt < 0)
 			goto out;
-		if (NONL || _pfast == 0)
+		if (NONL || __pfast == 0)
 			outcol = 0;
 	}
 	if (BT)
@@ -318,14 +331,14 @@ dontcr:
 	while (outcol > destcol) {
 		if (plodcnt < 0)
 			goto out;
-/*
+#ifdef notdef
 		if (BT && outcol - destcol > k + 4) {
 			tputs(BT, 0, plodput);
 			outcol--;
 			outcol &= ~7;
 			continue;
 		}
-*/
+#endif
 		outcol--;
 		if (BC)
 			tputs(BC, 0, plodput);
@@ -366,36 +379,36 @@ dontcr:
 	}
 	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.
+		 * 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 */
+		if (in_refresh)
+			if (plodflg)	/* Avoid a complex calculation. */
 				plodcnt--;
 			else {
-				ch = curscr->_y[outline][outcol];
-				if ((ch&_STANDOUT) == (curscr->_flags&_STANDOUT))
-					_putchar(ch);
+				i = curscr->lines[outline]->line[outcol].ch;
+				if ((curscr->lines[outline]->line[outcol].attr
+				     & __STANDOUT) ==
+				    (curscr->flags & __WSTANDOUT))
+					putchar(i);
 				else
 					goto nondes;
 			}
 		else
-nondes:
-		     if (ND)
-			tputs(ND, 0, plodput);
-		else
-			plodput(' ');
+nondes:			if (ND)
+				tputs(ND, 0, plodput);
+			else
+				plodput(' ');
 		outcol++;
 		if (plodcnt < 0)
 			goto out;
 	}
-out:
-	if (plodflg) {
+
+out:	if (plodflg) {
 		outcol = soutcol;
 		outline = soutline;
 	}
-	return(plodcnt);
+	return (plodcnt);
 }
 
 /*
@@ -403,16 +416,16 @@ out:
  * 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.
  */
+static int
 tabcol(col, ts)
-int col, ts;
+	int col, ts;
 {
-	int offset, result;
+	int offset;
 
 	if (col >= COLS) {
 		offset = COLS * (col / COLS);
 		col -= offset;
-	}
-	else
+	} else
 		offset = 0;
-	return col + ts - (col % ts) + offset;
+	return (col + ts - (col % ts) + offset);
 }