Pull in some of the lpt_port_test fixes from lpt.c.

[unix-history] / lib / libcurses / cr_put.c

diff --git a/lib/libcurses/cr_put.c b/lib/libcurses/cr_put.c
index c9d0e79..b50875c 100644 (file)
--- 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
  *
  * 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
  */
 
 #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).
  */
 
  * 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
 #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;
 #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;
 
        if (destcol >= COLS) {
                destline += destcol / COLS;


@@ -88,15 +99,15 @@ fgoto()
                outcol %= COLS;
                if (AM == 0) {
                        while (l > 0) {
                outcol %= COLS;
                if (AM == 0) {
                        while (l > 0) {

-                               if (_pfast)
+                               if (__pfast)

                                        if (CR)
                                        if (CR)

-                                               _puts(CR);
+                                               tputs(CR, 0, __cputchar);

                                        else
                                        else

-                                               _putchar('\r');
+                                               putchar('\r');

                                if (NL)
                                if (NL)

-                                       _puts(NL);
+                                       tputs(NL, 0, __cputchar);

                                else
                                else

-                                       _putchar('\n');
+                                       putchar('\n');

                                l--;
                        }
                        outcol = 0;
                                l--;
                        }
                        outcol = 0;


@@ -111,36 +122,35 @@ fgoto()
                destline = LINES - 1;
                if (outline < LINES - 1) {
                        c = destcol;
                destline = LINES - 1;
                if (outline < LINES - 1) {
                        c = destcol;

-                       if (_pfast == 0 && !CA)
+                       if (__pfast == 0 && !CA)

                                destcol = 0;
                                destcol = 0;

-                       fgoto();
+                       fgoto(in_refresh);

                        destcol = c;
                }
                while (l >= LINES) {
                        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
                        else

-                               _putchar('\n');
+                               putchar('\n');

                        l--;
                        l--;

-                       if (_pfast == 0)
+                       if (__pfast == 0)

                                outcol = 0;
                }
        }
                                outcol = 0;
                }
        }


@@ -148,17 +158,20 @@ fgoto()
                destline = outline;
        if (CA) {
                cgp = tgoto(CM, destcol, destline);
                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;
 }
        outline = destline;
        outcol = destcol;
 }

-

 /*
  * Move (slowly) to destination.
  * Hard thing here is using home cursor on really deficient terminals.
 /*
  * 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 int plodcnt, plodflg;
 

+static void

 plodput(c)
 plodput(c)

+       int c;

 {
        if (plodflg)
 {
        if (plodflg)

-               plodcnt--;
+               --plodcnt;

        else
        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;
        /*
 
        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) {
                /*
         * 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;
                 */
                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;
                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))
                        /* 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
                        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;
 
                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
                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;
                         */
                        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;
                        /*
                         * 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;
                        }
                }
                                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)
                if (!UP && destline < outline)

-                       return -1;
+                       return (-1);

        if (GT)
                i = destcol % HARDTABS + destcol / HARDTABS;
        else
                i = destcol;
        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);
                j *= (k = strlen(BT));
                if ((k += (destcol&7)) > 4)
                        j += 8 - (destcol&7);


@@ -265,28 +275,31 @@ plod(cnt)
                        j += k;
        }
        else
                        j += k;
        }
        else

-*/
+#endif

                j = outcol - destcol;
                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;
                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 (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) {
                /*
         */
        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);
                 */
                if (CR)
                        tputs(CR, 0, plodput);


@@ -301,8 +314,8 @@ plod(cnt)
                }
                outcol = 0;
        }
                }
                outcol = 0;
        }

-dontcr:
-       while (outline < destline) {
+
+dontcr:        while (outline < destline) {

                outline++;
                if (NL)
                        tputs(NL, 0, plodput);
                outline++;
                if (NL)
                        tputs(NL, 0, plodput);


@@ -310,7 +323,7 @@ dontcr:
                        plodput('\n');
                if (plodcnt < 0)
                        goto out;
                        plodput('\n');
                if (plodcnt < 0)
                        goto out;

-               if (NONL || _pfast == 0)
+               if (NONL || __pfast == 0)

                        outcol = 0;
        }
        if (BT)
                        outcol = 0;
        }
        if (BT)


@@ -318,14 +331,14 @@ dontcr:
        while (outcol > destcol) {
                if (plodcnt < 0)
                        goto out;
        while (outcol > destcol) {
                if (plodcnt < 0)
                        goto out;

-/*
+#ifdef notdef

                if (BT && outcol - destcol > k + 4) {
                        tputs(BT, 0, plodput);
                        outcol--;
                        outcol &= ~7;
                        continue;
                }
                if (BT && outcol - destcol > k + 4) {
                        tputs(BT, 0, plodput);
                        outcol--;
                        outcol &= ~7;
                        continue;
                }

-*/
+#endif

                outcol--;
                if (BC)
                        tputs(BC, 0, plodput);
                outcol--;
                if (BC)
                        tputs(BC, 0, plodput);


@@ -366,36 +379,36 @@ dontcr:
        }
        while (outcol < destcol) {
                /*
        }
        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 {
                                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
                                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;
        }
                outcol++;
                if (plodcnt < 0)
                        goto out;
        }

-out:
-       if (plodflg) {
+
+out:   if (plodflg) {

                outcol = soutcol;
                outline = soutline;
        }
                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.
  */
  * 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)
 tabcol(col, ts)

-int col, ts;
+       int col, ts;

 {
 {

-       int offset, result;
+       int offset;

 
        if (col >= COLS) {
                offset = COLS * (col / COLS);
                col -= offset;
 
        if (col >= COLS) {
                offset = COLS * (col / COLS);
                col -= offset;

-       }
-       else
+       } else

                offset = 0;
                offset = 0;

-       return col + ts - (col % ts) + offset;
+       return (col + ts - (col % ts) + offset);

 }
 }