contrib/tcsh-6/ed.refresh.c

   1 /*
   2  * ed.refresh.c: Lower level screen refreshing functions
   3  */
   4 /*-
   5  * Copyright (c) 1980, 1991 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32 #include "sh.h"
  33 #include "ed.h"
  34 /* #define DEBUG_UPDATE */
  35 /* #define DEBUG_REFRESH */
  36 /* #define DEBUG_LITERAL */
  37
  38 /* refresh.c -- refresh the current set of lines on the screen */
  39
  40 Char   *litptr;
  41 static int vcursor_h, vcursor_v;
  42 static int rprompt_h, rprompt_v;
  43
  44 static  int     MakeLiteral             (Char *, int, Char);
  45 static  int     Draw                    (Char *, int, int);
  46 static  void    Vdraw                   (Char, int);
  47 static  void    RefreshPromptpart       (Char *);
  48 static  void    update_line             (Char *, Char *, int);
  49 static  void    str_insert              (Char *, int, int, Char *, int);
  50 static  void    str_delete              (Char *, int, int, int);
  51 static  void    str_cp                  (Char *, Char *, int);
  52 #ifndef WINNT_NATIVE
  53 static
  54 #else
  55 extern
  56 #endif
  57         void    PutPlusOne      (Char, int);
  58 static  void    cpy_pad_spaces          (Char *, Char *, int);
  59 #if defined(DEBUG_UPDATE) || defined(DEBUG_REFRESH) || defined(DEBUG_LITERAL)
  60 static  void    reprintf                        (char *, ...);
  61 #ifdef DEBUG_UPDATE
  62 static  void    dprintstr               (char *, const Char *, const Char *);
  63
  64 static void
  65 dprintstr(char *str, const Char *f, const Char *t)
  66 {
  67     reprintf("%s:\"", str);
  68     while (f < t) {
  69         if (ASC(*f) & ~ASCII)
  70           reprintf("[%x]", *f++);
  71         else
  72           reprintf("%c", CTL_ESC(ASCII & ASC(*f++)));
  73     }
  74     reprintf("\"\r\n");
  75 }
  76 #endif /* DEBUG_UPDATE */
  77
  78 /* reprintf():
  79  *      Print to $DEBUGTTY, so that we can test editing on one pty, and
  80  *      print debugging stuff on another. Don't interrupt the shell while
  81  *      debugging cause you'll mangle up the file descriptors!
  82  */
  83 static void
  84 reprintf(char *fmt, ...)
  85 {
  86     static int fd = -1;
  87     char *dtty;
  88
  89     if ((dtty = getenv("DEBUGTTY"))) {
  90         int o;
  91         va_list va;
  92         va_start(va, fmt);
  93
  94         if (fd == -1)
  95             fd = xopen(dtty, O_RDWR);
  96         o = SHOUT;
  97         flush();
  98         SHOUT = fd;
  99         xvprintf(fmt, va);
 100         va_end(va);
 101         flush();
 102         SHOUT = o;
 103     }
 104 }
 105 #endif  /* DEBUG_UPDATE || DEBUG_REFRESH || DEBUG_LITERAL */
 106
 107 static int litlen = 0, litalloc = 0;
 108
 109 static int MakeLiteral(Char *str, int len, Char addlit)
 110 {
 111     int i, addlitlen = 0;
 112     Char *addlitptr = 0;
 113     if (addlit) {
 114         if ((addlit & LITERAL) != 0) {
 115             addlitptr = litptr + (addlit & ~LITERAL) * LIT_FACTOR;
 116             addlitlen = Strlen(addlitptr);
 117         } else {
 118             addlitptr = &addlit;
 119             addlitlen = 1;
 120         }
 121         for (i = 0; i < litlen; i += LIT_FACTOR)
 122             if (!Strncmp(addlitptr, litptr + i, addlitlen) && !Strncmp(str, litptr + i + addlitlen, len) && litptr[i + addlitlen + len] == 0)
 123                 return (i / LIT_FACTOR) | LITERAL;
 124     } else {
 125         addlitlen = 0;
 126         for (i = 0; i < litlen; i += LIT_FACTOR)
 127             if (!Strncmp(str, litptr + i, len) && litptr[i + len] == 0)
 128                 return (i / LIT_FACTOR) | LITERAL;
 129     }
 130     if (litlen + addlitlen + len + 1 + (LIT_FACTOR - 1) > litalloc) {
 131         Char *newlitptr;
 132         int add = 256;
 133         while (len + addlitlen + 1 + (LIT_FACTOR - 1) > add)
 134             add *= 2;
 135         newlitptr = xrealloc(litptr, (litalloc + add) * sizeof(Char));
 136         if (!newlitptr)
 137             return '?';
 138         litptr = newlitptr;
 139         litalloc += add;
 140         if (addlitptr && addlitptr != &addlit)
 141             addlitptr = litptr + (addlit & ~LITERAL) * LIT_FACTOR;
 142     }
 143     i = litlen / LIT_FACTOR;
 144     if (i >= LITERAL || i == CHAR_DBWIDTH)
 145         return '?';
 146     if (addlitptr) {
 147         Strncpy(litptr + litlen, addlitptr, addlitlen);
 148         litlen += addlitlen;
 149     }
 150     Strncpy(litptr + litlen, str, len);
 151     litlen += len;
 152     do
 153         litptr[litlen++] = 0;
 154     while (litlen % LIT_FACTOR);
 155     return i | LITERAL;
 156 }
 157
 158 /* draw char at cp, expand tabs, ctl chars */
 159 static int
 160 Draw(Char *cp, int nocomb, int drawPrompt)
 161 {
 162     int w, i, lv, lh;
 163     Char c, attr;
 164
 165 #ifdef WIDE_STRINGS
 166     if (!drawPrompt) {                  /* draw command-line */
 167         attr = 0;
 168         c = *cp;
 169     } else {                            /* draw prompt */
 170         /* prompt with attributes(UNDER,BOLD,STANDOUT) */
 171         if (*cp & (UNDER | BOLD | STANDOUT)) {          /* *cp >= STANDOUT */
 172
 173             /* example)
 174              * We can't distinguish whether (*cp=)0x02ffffff is
 175              * U+02FFFFFF or U+00FFFFFF|STANDOUT.
 176              * We handle as U+00FFFFFF|STANDOUT, only when drawing prompt. */
 177             attr = (*cp & ATTRIBUTES);
 178             /* ~(UNDER | BOLD | STANDOUT) = 0xf1ffffff */
 179             c = *cp & ~(UNDER | BOLD | STANDOUT);
 180
 181             /* if c is ctrl code, we handle *cp as havnig no attributes */
 182             if ((c < 0x20 && c >= 0) || c == 0x7f) {
 183                 attr = 0;
 184                 c = *cp;
 185             }
 186         } else {                        /* prompt without attributes */
 187             attr = 0;
 188             c = *cp;
 189         }
 190     }
 191 #else
 192     attr = *cp & ~CHAR;
 193     c = *cp & CHAR;
 194 #endif
 195     w = NLSClassify(c, nocomb, drawPrompt);
 196     switch (w) {
 197         case NLSCLASS_NL:
 198             Vdraw('\0', 0);             /* assure end of line    */
 199             vcursor_h = 0;              /* reset cursor pos      */
 200             vcursor_v++;
 201             break;
 202         case NLSCLASS_TAB:
 203             do {
 204                 Vdraw(' ', 1);
 205             } while ((vcursor_h & 07) != 0);
 206             break;
 207         case NLSCLASS_CTRL:
 208             Vdraw('^' | attr, 1);
 209             if (c == CTL_ESC('\177')) {
 210                 Vdraw('?' | attr, 1);
 211             } else {
 212 #ifdef IS_ASCII
 213                 /* uncontrolify it; works only for iso8859-1 like sets */
 214                 Vdraw(c | 0100 | attr, 1);
 215 #else
 216                 Vdraw(_toebcdic[_toascii[c]|0100] | attr, 1);
 217 #endif
 218             }
 219             break;
 220         case NLSCLASS_ILLEGAL:
 221             Vdraw('\\' | attr, 1);
 222             Vdraw((((c >> 6) & 7) + '0') | attr, 1);
 223             Vdraw((((c >> 3) & 7) + '0') | attr, 1);
 224             Vdraw(((c & 7) + '0') | attr, 1);
 225             break;
 226         case NLSCLASS_ILLEGAL2:
 227         case NLSCLASS_ILLEGAL3:
 228         case NLSCLASS_ILLEGAL4:
 229         case NLSCLASS_ILLEGAL5:
 230             Vdraw('\\', 1);
 231             Vdraw('U', 1);
 232             Vdraw('+', 1);
 233             for (i = 16 + 4 * (-w-5); i >= 0; i -= 4)
 234                 Vdraw("0123456789ABCDEF"[(c >> i) & 15] | attr, 1);
 235             break;
 236         case 0:
 237             lv = vcursor_v;
 238             lh = vcursor_h;
 239             for (;;) {
 240                 lh--;
 241                 if (lh < 0) {
 242                     lv--;
 243                     if (lv < 0)
 244                         break;
 245                     lh = Strlen(Vdisplay[lv]) - 1;
 246                 }
 247                 if (Vdisplay[lv][lh] != CHAR_DBWIDTH)
 248                     break;
 249             }
 250             if (lv < 0) {
 251                 Vdraw('\\' | attr, 1);
 252                 Vdraw((((c >> 6) & 7) + '0') | attr, 1);
 253                 Vdraw((((c >> 3) & 7) + '0') | attr, 1);
 254                 Vdraw(((c & 7) + '0') | attr, 1);
 255                 break;
 256             }
 257             Vdisplay[lv][lh] = MakeLiteral(cp, 1, Vdisplay[lv][lh]);
 258             break;
 259         default:
 260             Vdraw(*cp, w);
 261             break;
 262     }
 263     return 1;
 264 }
 265
 266 static void
 267 Vdraw(Char c, int width)        /* draw char c onto V lines */
 268 {
 269 #ifdef DEBUG_REFRESH
 270 # ifdef SHORT_STRINGS
 271     reprintf("Vdrawing %6.6o '%c' %d\r\n", (unsigned)c, (int)(c & ASCII), width);
 272 # else
 273     reprintf("Vdrawing %3.3o '%c' %d\r\n", (unsigned)c, (int)c, width);
 274 # endif /* SHORT_STRNGS */
 275 #endif  /* DEBUG_REFRESH */
 276
 277     /* Hopefully this is what all the terminals do with multi-column characters
 278        that "span line breaks". */
 279     while (vcursor_h + width > TermH)
 280         Vdraw(' ', 1);
 281     Vdisplay[vcursor_v][vcursor_h] = c;
 282     if (width)
 283         vcursor_h++;            /* advance to next place */
 284     while (--width > 0)
 285         Vdisplay[vcursor_v][vcursor_h++] = CHAR_DBWIDTH;
 286     if (vcursor_h >= TermH) {
 287         Vdisplay[vcursor_v][TermH] = '\0';      /* assure end of line */
 288         vcursor_h = 0;          /* reset it. */
 289         vcursor_v++;
 290 #ifdef DEBUG_REFRESH
 291         if (vcursor_v >= TermV) {       /* should NEVER happen. */
 292             reprintf("\r\nVdraw: vcursor_v overflow! Vcursor_v == %d > %d\r\n",
 293                     vcursor_v, TermV);
 294             abort();
 295         }
 296 #endif /* DEBUG_REFRESH */
 297     }
 298 }
 299
 300 /*
 301  *  RefreshPromptpart()
 302  *      draws a prompt element, expanding literals (we know it's ASCIZ)
 303  */
 304 static void
 305 RefreshPromptpart(Char *buf)
 306 {
 307     Char *cp;
 308     int w;
 309
 310     if (buf == NULL)
 311         return;
 312     for (cp = buf; *cp; ) {
 313         if (*cp & LITERAL) {
 314             Char *litstart = cp;
 315             while (*cp & LITERAL)
 316                 cp++;
 317             if (*cp) {
 318                 w = NLSWidth(*cp & CHAR);
 319                 Vdraw(MakeLiteral(litstart, cp + 1 - litstart, 0), w);
 320                 cp++;
 321             }
 322             else {
 323                 /*
 324                  * XXX: This is a bug, we lose the last literal, if it is not
 325                  * followed by a normal character, but it is too hard to fix
 326                  */
 327                 break;
 328             }
 329         }
 330         else
 331             cp += Draw(cp, cp == buf, 1);
 332     }
 333 }
 334
 335 /*
 336  *  Refresh()
 337  *      draws the new virtual screen image from the current input
 338  *      line, then goes line-by-line changing the real image to the new
 339  *      virtual image. The routine to re-draw a line can be replaced
 340  *      easily in hopes of a smarter one being placed there.
 341  */
 342 #ifndef WINNT_NATIVE
 343 static
 344 #endif
 345 int OldvcV = 0;
 346
 347 void
 348 Refresh(void)
 349 {
 350     int cur_line;
 351     Char *cp;
 352     int     cur_h, cur_v = 0, new_vcv;
 353     int     rhdiff;
 354     Char    oldgetting;
 355
 356 #ifdef DEBUG_REFRESH
 357     reprintf("Prompt = :%s:\r\n", short2str(Prompt));
 358     reprintf("InputBuf = :%s:\r\n", short2str(InputBuf));
 359 #endif /* DEBUG_REFRESH */
 360     oldgetting = GettingInput;
 361     GettingInput = 0;           /* avoid re-entrance via SIGWINCH */
 362
 363     /* reset the Vdraw cursor, temporarily draw rprompt to calculate its size */
 364     vcursor_h = 0;
 365     vcursor_v = 0;
 366     RefreshPromptpart(RPrompt);
 367     rprompt_h = vcursor_h;
 368     rprompt_v = vcursor_v;
 369
 370     /* reset the Vdraw cursor, draw prompt */
 371     vcursor_h = 0;
 372     vcursor_v = 0;
 373     RefreshPromptpart(Prompt);
 374     cur_h = -1;                 /* set flag in case I'm not set */
 375
 376     /* draw the current input buffer */
 377     for (cp = InputBuf; (cp < LastChar); ) {
 378         if (cp >= Cursor && cur_h == -1) {
 379             cur_h = vcursor_h;  /* save for later */
 380             cur_v = vcursor_v;
 381             Cursor = cp;
 382         }
 383         cp += Draw(cp, cp == InputBuf, 0);
 384     }
 385
 386     if (cur_h == -1) {          /* if I haven't been set yet, I'm at the end */
 387         cur_h = vcursor_h;
 388         cur_v = vcursor_v;
 389     }
 390
 391     rhdiff = TermH - vcursor_h - rprompt_h;
 392     if (rprompt_h != 0 && rprompt_v == 0 && vcursor_v == 0 && rhdiff > 1) {
 393                         /*
 394                          * have a right-hand side prompt that will fit on
 395                          * the end of the first line with at least one
 396                          * character gap to the input buffer.
 397                          */
 398         while (--rhdiff > 0)            /* pad out with spaces */
 399             Vdraw(' ', 1);
 400         RefreshPromptpart(RPrompt);
 401     }
 402     else {
 403         rprompt_h = 0;                  /* flag "not using rprompt" */
 404         rprompt_v = 0;
 405     }
 406
 407     new_vcv = vcursor_v;        /* must be done BEFORE the NUL is written */
 408     Vdraw('\0', 1);             /* put NUL on end */
 409
 410 #if defined (DEBUG_REFRESH)
 411     reprintf("TermH=%d, vcur_h=%d, vcur_v=%d, Vdisplay[0]=\r\n:%80.80s:\r\n",
 412             TermH, vcursor_h, vcursor_v, short2str(Vdisplay[0]));
 413 #endif /* DEBUG_REFRESH */
 414
 415 #ifdef DEBUG_UPDATE
 416     reprintf("updating %d lines.\r\n", new_vcv);
 417 #endif  /* DEBUG_UPDATE */
 418     for (cur_line = 0; cur_line <= new_vcv; cur_line++) {
 419         /* NOTE THAT update_line MAY CHANGE Display[cur_line] */
 420         update_line(Display[cur_line], Vdisplay[cur_line], cur_line);
 421 #ifdef WINNT_NATIVE
 422         flush();
 423 #endif /* WINNT_NATIVE */
 424
 425         /*
 426          * Copy the new line to be the current one, and pad out with spaces
 427          * to the full width of the terminal so that if we try moving the
 428          * cursor by writing the character that is at the end of the
 429          * screen line, it won't be a NUL or some old leftover stuff.
 430          */
 431         cpy_pad_spaces(Display[cur_line], Vdisplay[cur_line], TermH);
 432     }
 433 #ifdef DEBUG_REFRESH
 434     reprintf("\r\nvcursor_v = %d, OldvcV = %d, cur_line = %d\r\n",
 435             vcursor_v, OldvcV, cur_line);
 436 #endif /* DEBUG_REFRESH */
 437     if (OldvcV > new_vcv) {
 438         for (; cur_line <= OldvcV; cur_line++) {
 439             update_line(Display[cur_line], STRNULL, cur_line);
 440             *Display[cur_line] = '\0';
 441         }
 442     }
 443     OldvcV = new_vcv;           /* set for next time */
 444 #ifdef DEBUG_REFRESH
 445     reprintf("\r\nCursorH = %d, CursorV = %d, cur_h = %d, cur_v = %d\r\n",
 446             CursorH, CursorV, cur_h, cur_v);
 447 #endif /* DEBUG_REFRESH */
 448 #ifdef WINNT_NATIVE
 449     flush();
 450 #endif /* WINNT_NATIVE */
 451     MoveToLine(cur_v);          /* go to where the cursor is */
 452     MoveToChar(cur_h);
 453     SetAttributes(0);           /* Clear all attributes */
 454     flush();                    /* send the output... */
 455     GettingInput = oldgetting;  /* reset to old value */
 456 }
 457
 458 #ifdef notdef
 459 GotoBottom(void)
 460 {                               /* used to go to last used screen line */
 461     MoveToLine(OldvcV);
 462 }
 463
 464 #endif
 465
 466 void
 467 PastBottom(void)
 468 {                               /* used to go to last used screen line */
 469     MoveToLine(OldvcV);
 470     (void) putraw('\r');
 471     (void) putraw('\n');
 472     ClearDisp();
 473     flush();
 474 }
 475
 476
 477 /* insert num characters of s into d (in front of the character) at dat,
 478    maximum length of d is dlen */
 479 static void
 480 str_insert(Char *d, int dat, int dlen, Char *s, int num)
 481 {
 482     Char *a, *b;
 483
 484     if (num <= 0)
 485         return;
 486     if (num > dlen - dat)
 487         num = dlen - dat;
 488
 489 #ifdef DEBUG_REFRESH
 490     reprintf("str_insert() starting: %d at %d max %d, d == \"%s\"\n",
 491             num, dat, dlen, short2str(d));
 492     reprintf("s == \"%s\"n", short2str(s));
 493 #endif /* DEBUG_REFRESH */
 494
 495     /* open up the space for num chars */
 496     if (num > 0) {
 497         b = d + dlen - 1;
 498         a = b - num;
 499         while (a >= &d[dat])
 500             *b-- = *a--;
 501         d[dlen] = '\0';         /* just in case */
 502     }
 503 #ifdef DEBUG_REFRESH
 504     reprintf("str_insert() after insert: %d at %d max %d, d == \"%s\"\n",
 505             num, dat, dlen, short2str(d));
 506     reprintf("s == \"%s\"n", short2str(s));
 507 #endif /* DEBUG_REFRESH */
 508
 509     /* copy the characters */
 510     for (a = d + dat; (a < d + dlen) && (num > 0); num--)
 511         *a++ = *s++;
 512
 513 #ifdef DEBUG_REFRESH
 514     reprintf("str_insert() after copy: %d at %d max %d, d == \"%s\"\n",
 515             num, dat, dlen, d, short2str(s));
 516     reprintf("s == \"%s\"n", short2str(s));
 517 #endif /* DEBUG_REFRESH */
 518 }
 519
 520 /* delete num characters d at dat, maximum length of d is dlen */
 521 static void
 522 str_delete(Char *d, int dat, int dlen, int num)
 523 {
 524     Char *a, *b;
 525
 526     if (num <= 0)
 527         return;
 528     if (dat + num >= dlen) {
 529         d[dat] = '\0';
 530         return;
 531     }
 532
 533 #ifdef DEBUG_REFRESH
 534     reprintf("str_delete() starting: %d at %d max %d, d == \"%s\"\n",
 535             num, dat, dlen, short2str(d));
 536 #endif /* DEBUG_REFRESH */
 537
 538     /* open up the space for num chars */
 539     if (num > 0) {
 540         b = d + dat;
 541         a = b + num;
 542         while (a < &d[dlen])
 543             *b++ = *a++;
 544         d[dlen] = '\0';         /* just in case */
 545     }
 546 #ifdef DEBUG_REFRESH
 547     reprintf("str_delete() after delete: %d at %d max %d, d == \"%s\"\n",
 548             num, dat, dlen, short2str(d));
 549 #endif /* DEBUG_REFRESH */
 550 }
 551
 552 static void
 553 str_cp(Char *a, Char *b, int n)
 554 {
 555     while (n-- && *b)
 556         *a++ = *b++;
 557 }
 558
 559
 560 /* ****************************************************************
 561     update_line() is based on finding the middle difference of each line
 562     on the screen; vis:
 563
 564                              /old first difference
 565         /beginning of line   |              /old last same       /old EOL
 566         v                    v              v                    v
 567 old:    eddie> Oh, my little gruntle-buggy is to me, as lurgid as
 568 new:    eddie> Oh, my little buggy says to me, as lurgid as
 569         ^                    ^        ^                    ^
 570         \beginning of line   |        \new last same       \new end of line
 571                              \new first difference
 572
 573     all are character pointers for the sake of speed.  Special cases for
 574     no differences, as well as for end of line additions must be handled.
 575 **************************************************************** */
 576
 577 /* Minimum at which doing an insert it "worth it".  This should be about
 578  * half the "cost" of going into insert mode, inserting a character, and
 579  * going back out.  This should really be calculated from the termcap
 580  * data...  For the moment, a good number for ANSI terminals.
 581  */
 582 #define MIN_END_KEEP    4
 583
 584 static void                     /* could be changed to make it smarter */
 585 update_line(Char *old, Char *new, int cur_line)
 586 {
 587     Char *o, *n, *p, c;
 588     Char  *ofd, *ols, *oe, *nfd, *nls, *ne;
 589     Char  *osb, *ose, *nsb, *nse;
 590     int     fx, sx;
 591
 592     /*
 593      * find first diff (won't be CHAR_DBWIDTH in either line)
 594      */
 595     for (o = old, n = new; *o && (*o == *n); o++, n++)
 596         continue;
 597     ofd = o;
 598     nfd = n;
 599
 600     /*
 601      * Find the end of both old and new
 602      */
 603     o = Strend(o);
 604
 605     /*
 606      * Remove any trailing blanks off of the end, being careful not to
 607      * back up past the beginning.
 608      */
 609     if (!(adrof(STRhighlight) && MarkIsSet)) {
 610     while (ofd < o) {
 611         if (o[-1] != ' ')
 612             break;
 613         o--;
 614     }
 615     }
 616     oe = o;
 617     *oe = (Char) 0;
 618
 619     n = Strend(n);
 620
 621     /* remove blanks from end of new */
 622     if (!(adrof(STRhighlight) && MarkIsSet)) {
 623     while (nfd < n) {
 624         if (n[-1] != ' ')
 625             break;
 626         n--;
 627     }
 628     }
 629     ne = n;
 630     *ne = (Char) 0;
 631
 632     /*
 633      * if no diff, continue to next line of redraw
 634      */
 635     if (*ofd == '\0' && *nfd == '\0') {
 636 #ifdef DEBUG_UPDATE
 637         reprintf("no difference.\r\n");
 638 #endif /* DEBUG_UPDATE */
 639         return;
 640     }
 641
 642     /*
 643      * find last same pointer
 644      */
 645     while ((o > ofd) && (n > nfd) && (*--o == *--n))
 646         continue;
 647     if (*o != *n) {
 648         o++;
 649         n++;
 650     }
 651     while (*o == CHAR_DBWIDTH) {
 652         o++;
 653         n++;
 654     }
 655     ols = o;
 656     nls = n;
 657
 658     /*
 659      * find same begining and same end
 660      */
 661     osb = ols;
 662     nsb = nls;
 663     ose = ols;
 664     nse = nls;
 665
 666     /*
 667      * case 1: insert: scan from nfd to nls looking for *ofd
 668      */
 669     if (*ofd) {
 670         for (c = *ofd, n = nfd; n < nls; n++) {
 671             if (c == *n) {
 672                 for (o = ofd, p = n; p < nls && o < ols && *o == *p; o++, p++)
 673                     continue;
 674                 /*
 675                  * if the new match is longer and it's worth keeping, then we
 676                  * take it
 677                  */
 678                 if (((nse - nsb) < (p - n)) && (2 * (p - n) > n - nfd)) {
 679                     nsb = n;
 680                     nse = p;
 681                     osb = ofd;
 682                     ose = o;
 683                 }
 684             }
 685         }
 686     }
 687
 688     /*
 689      * case 2: delete: scan from ofd to ols looking for *nfd
 690      */
 691     if (*nfd) {
 692         for (c = *nfd, o = ofd; o < ols; o++) {
 693             if (c == *o) {
 694                 for (n = nfd, p = o; p < ols && n < nls && *p == *n; p++, n++)
 695                     continue;
 696                 /*
 697                  * if the new match is longer and it's worth keeping, then we
 698                  * take it
 699                  */
 700                 if (((ose - osb) < (p - o)) && (2 * (p - o) > o - ofd)) {
 701                     nsb = nfd;
 702                     nse = n;
 703                     osb = o;
 704                     ose = p;
 705                 }
 706             }
 707         }
 708     }
 709 #ifdef notdef
 710     /*
 711      * If `last same' is before `same end' re-adjust
 712      */
 713     if (ols < ose)
 714         ols = ose;
 715     if (nls < nse)
 716         nls = nse;
 717 #endif
 718
 719     /*
 720      * Pragmatics I: If old trailing whitespace or not enough characters to
 721      * save to be worth it, then don't save the last same info.
 722      */
 723     if ((oe - ols) < MIN_END_KEEP) {
 724         ols = oe;
 725         nls = ne;
 726     }
 727
 728     /*
 729      * Pragmatics II: if the terminal isn't smart enough, make the data dumber
 730      * so the smart update doesn't try anything fancy
 731      */
 732
 733     /*
 734      * fx is the number of characters we need to insert/delete: in the
 735      * beginning to bring the two same begins together
 736      */
 737     fx = (int) ((nsb - nfd) - (osb - ofd));
 738     /*
 739      * sx is the number of characters we need to insert/delete: in the end to
 740      * bring the two same last parts together
 741      */
 742     sx = (int) ((nls - nse) - (ols - ose));
 743
 744     if (!T_CanIns) {
 745         if (fx > 0) {
 746             osb = ols;
 747             ose = ols;
 748             nsb = nls;
 749             nse = nls;
 750         }
 751         if (sx > 0) {
 752             ols = oe;
 753             nls = ne;
 754         }
 755         if ((ols - ofd) < (nls - nfd)) {
 756             ols = oe;
 757             nls = ne;
 758         }
 759     }
 760     if (!T_CanDel) {
 761         if (fx < 0) {
 762             osb = ols;
 763             ose = ols;
 764             nsb = nls;
 765             nse = nls;
 766         }
 767         if (sx < 0) {
 768             ols = oe;
 769             nls = ne;
 770         }
 771         if ((ols - ofd) > (nls - nfd)) {
 772             ols = oe;
 773             nls = ne;
 774         }
 775     }
 776
 777     /*
 778      * Pragmatics III: make sure the middle shifted pointers are correct if
 779      * they don't point to anything (we may have moved ols or nls).
 780      */
 781     /* if the change isn't worth it, don't bother */
 782     /* was: if (osb == ose) */
 783     if ((ose - osb) < MIN_END_KEEP) {
 784         osb = ols;
 785         ose = ols;
 786         nsb = nls;
 787         nse = nls;
 788     }
 789
 790     /*
 791      * Now that we are done with pragmatics we recompute fx, sx
 792      */
 793     fx = (int) ((nsb - nfd) - (osb - ofd));
 794     sx = (int) ((nls - nse) - (ols - ose));
 795
 796 #ifdef DEBUG_UPDATE
 797     reprintf("\n");
 798     reprintf("ofd %d, osb %d, ose %d, ols %d, oe %d\n",
 799             ofd - old, osb - old, ose - old, ols - old, oe - old);
 800     reprintf("nfd %d, nsb %d, nse %d, nls %d, ne %d\n",
 801             nfd - new, nsb - new, nse - new, nls - new, ne - new);
 802     reprintf("xxx-xxx:\"00000000001111111111222222222233333333334\"\r\n");
 803     reprintf("xxx-xxx:\"01234567890123456789012345678901234567890\"\r\n");
 804     dprintstr("old- oe", old, oe);
 805     dprintstr("new- ne", new, ne);
 806     dprintstr("old-ofd", old, ofd);
 807     dprintstr("new-nfd", new, nfd);
 808     dprintstr("ofd-osb", ofd, osb);
 809     dprintstr("nfd-nsb", nfd, nsb);
 810     dprintstr("osb-ose", osb, ose);
 811     dprintstr("nsb-nse", nsb, nse);
 812     dprintstr("ose-ols", ose, ols);
 813     dprintstr("nse-nls", nse, nls);
 814     dprintstr("ols- oe", ols, oe);
 815     dprintstr("nls- ne", nls, ne);
 816 #endif /* DEBUG_UPDATE */
 817
 818     /*
 819      * CursorV to this line cur_line MUST be in this routine so that if we
 820      * don't have to change the line, we don't move to it. CursorH to first
 821      * diff char
 822      */
 823     MoveToLine(cur_line);
 824
 825     /*
 826      * at this point we have something like this:
 827      *
 828      * /old                  /ofd    /osb               /ose    /ols     /oe
 829      * v.....................v       v..................v       v........v
 830      * eddie> Oh, my fredded gruntle-buggy is to me, as foo var lurgid as
 831      * eddie> Oh, my fredded quiux buggy is to me, as gruntle-lurgid as
 832      * ^.....................^     ^..................^       ^........^
 833      * \new                  \nfd  \nsb               \nse     \nls    \ne
 834      *
 835      * fx is the difference in length between the the chars between nfd and
 836      * nsb, and the chars between ofd and osb, and is thus the number of
 837      * characters to delete if < 0 (new is shorter than old, as above),
 838      * or insert (new is longer than short).
 839      *
 840      * sx is the same for the second differences.
 841      */
 842
 843     /*
 844      * if we have a net insert on the first difference, AND inserting the net
 845      * amount ((nsb-nfd) - (osb-ofd)) won't push the last useful character
 846      * (which is ne if nls != ne, otherwise is nse) off the edge of the screen
 847      * (TermH - 1) else we do the deletes first so that we keep everything we
 848      * need to.
 849      */
 850
 851     /*
 852      * if the last same is the same like the end, there is no last same part,
 853      * otherwise we want to keep the last same part set p to the last useful
 854      * old character
 855      */
 856     p = (ols != oe) ? oe : ose;
 857
 858     /*
 859      * if (There is a diffence in the beginning) && (we need to insert
 860      * characters) && (the number of characters to insert is less than the term
 861      * width) We need to do an insert! else if (we need to delete characters)
 862      * We need to delete characters! else No insert or delete
 863      */
 864     if ((nsb != nfd) && fx > 0 && ((p - old) + fx < TermH)) {
 865 #ifdef DEBUG_UPDATE
 866         reprintf("first diff insert at %d...\r\n", nfd - new);
 867 #endif  /* DEBUG_UPDATE */
 868         /*
 869          * Move to the first char to insert, where the first diff is.
 870          */
 871         MoveToChar(nfd - new);
 872         /*
 873          * Check if we have stuff to keep at end
 874          */
 875         if (nsb != ne) {
 876 #ifdef DEBUG_UPDATE
 877             reprintf("with stuff to keep at end\r\n");
 878 #endif  /* DEBUG_UPDATE */
 879             /*
 880              * insert fx chars of new starting at nfd
 881              */
 882             if (fx > 0) {
 883 #ifdef DEBUG_UPDATE
 884                 if (!T_CanIns)
 885                     reprintf("   ERROR: cannot insert in early first diff\n");
 886 #endif  /* DEBUG_UPDATE */
 887                 Insert_write(nfd, fx);
 888                 str_insert(old, (int) (ofd - old), TermH, nfd, fx);
 889             }
 890             /*
 891              * write (nsb-nfd) - fx chars of new starting at (nfd + fx)
 892              */
 893             so_write(nfd + fx, (nsb - nfd) - fx);
 894             str_cp(ofd + fx, nfd + fx, (int) ((nsb - nfd) - fx));
 895         }
 896         else {
 897 #ifdef DEBUG_UPDATE
 898             reprintf("without anything to save\r\n");
 899 #endif  /* DEBUG_UPDATE */
 900             so_write(nfd, (nsb - nfd));
 901             str_cp(ofd, nfd, (int) (nsb - nfd));
 902             /*
 903              * Done
 904              */
 905             return;
 906         }
 907     }
 908     else if (fx < 0) {
 909 #ifdef DEBUG_UPDATE
 910         reprintf("first diff delete at %d...\r\n", ofd - old);
 911 #endif  /* DEBUG_UPDATE */
 912         /*
 913          * move to the first char to delete where the first diff is
 914          */
 915         MoveToChar(ofd - old);
 916         /*
 917          * Check if we have stuff to save
 918          */
 919         if (osb != oe) {
 920 #ifdef DEBUG_UPDATE
 921             reprintf("with stuff to save at end\r\n");
 922 #endif  /* DEBUG_UPDATE */
 923             /*
 924              * fx is less than zero *always* here but we check for code
 925              * symmetry
 926              */
 927             if (fx < 0) {
 928 #ifdef DEBUG_UPDATE
 929                 if (!T_CanDel)
 930                     reprintf("   ERROR: cannot delete in first diff\n");
 931 #endif /* DEBUG_UPDATE */
 932                 DeleteChars(-fx);
 933                 str_delete(old, (int) (ofd - old), TermH, -fx);
 934             }
 935             /*
 936              * write (nsb-nfd) chars of new starting at nfd
 937              */
 938             so_write(nfd, (nsb - nfd));
 939             str_cp(ofd, nfd, (int) (nsb - nfd));
 940
 941         }
 942         else {
 943 #ifdef DEBUG_UPDATE
 944             reprintf("but with nothing left to save\r\n");
 945 #endif  /* DEBUG_UPDATE */
 946             /*
 947              * write (nsb-nfd) chars of new starting at nfd
 948              */
 949             so_write(nfd, (nsb - nfd));
 950 #ifdef DEBUG_REFRESH
 951             reprintf("cleareol %d\n", (oe - old) - (ne - new));
 952 #endif  /* DEBUG_UPDATE */
 953 #ifndef WINNT_NATIVE
 954             ClearEOL((oe - old) - (ne - new));
 955 #else
 956             /*
 957              * The calculation above does not work too well on NT
 958              */
 959             ClearEOL(TermH - CursorH);
 960 #endif /*WINNT_NATIVE*/
 961             /*
 962              * Done
 963              */
 964             return;
 965         }
 966     }
 967     else
 968         fx = 0;
 969
 970     if (sx < 0) {
 971 #ifdef DEBUG_UPDATE
 972         reprintf("second diff delete at %d...\r\n", (ose - old) + fx);
 973 #endif  /* DEBUG_UPDATE */
 974         /*
 975          * Check if we have stuff to delete
 976          */
 977         /*
 978          * fx is the number of characters inserted (+) or deleted (-)
 979          */
 980
 981         MoveToChar((ose - old) + fx);
 982         /*
 983          * Check if we have stuff to save
 984          */
 985         if (ols != oe) {
 986 #ifdef DEBUG_UPDATE
 987             reprintf("with stuff to save at end\r\n");
 988 #endif  /* DEBUG_UPDATE */
 989             /*
 990              * Again a duplicate test.
 991              */
 992             if (sx < 0) {
 993 #ifdef DEBUG_UPDATE
 994                 if (!T_CanDel)
 995                     reprintf("   ERROR: cannot delete in second diff\n");
 996 #endif  /* DEBUG_UPDATE */
 997                 DeleteChars(-sx);
 998             }
 999
1000             /*
1001              * write (nls-nse) chars of new starting at nse
1002              */
1003             so_write(nse, (nls - nse));
1004         }
1005         else {
1006             int olen = (int) (oe - old + fx);
1007             if (olen > TermH)
1008                 olen = TermH;
1009 #ifdef DEBUG_UPDATE
1010             reprintf("but with nothing left to save\r\n");
1011 #endif /* DEBUG_UPDATE */
1012             so_write(nse, (nls - nse));
1013 #ifdef DEBUG_REFRESH
1014             reprintf("cleareol %d\n", olen - (ne - new));
1015 #endif /* DEBUG_UPDATE */
1016 #ifndef WINNT_NATIVE
1017             ClearEOL(olen - (ne - new));
1018 #else
1019             /*
1020              * The calculation above does not work too well on NT
1021              */
1022             ClearEOL(TermH - CursorH);
1023 #endif /*WINNT_NATIVE*/
1024         }
1025     }
1026
1027     /*
1028      * if we have a first insert AND WE HAVEN'T ALREADY DONE IT...
1029      */
1030     if ((nsb != nfd) && (osb - ofd) <= (nsb - nfd) && (fx == 0)) {
1031 #ifdef DEBUG_UPDATE
1032         reprintf("late first diff insert at %d...\r\n", nfd - new);
1033 #endif /* DEBUG_UPDATE */
1034
1035         MoveToChar(nfd - new);
1036         /*
1037          * Check if we have stuff to keep at the end
1038          */
1039         if (nsb != ne) {
1040 #ifdef DEBUG_UPDATE
1041             reprintf("with stuff to keep at end\r\n");
1042 #endif /* DEBUG_UPDATE */
1043             /*
1044              * We have to recalculate fx here because we set it
1045              * to zero above as a flag saying that we hadn't done
1046              * an early first insert.
1047              */
1048             fx = (int) ((nsb - nfd) - (osb - ofd));
1049             if (fx > 0) {
1050                 /*
1051                  * insert fx chars of new starting at nfd
1052                  */
1053 #ifdef DEBUG_UPDATE
1054                 if (!T_CanIns)
1055                     reprintf("   ERROR: cannot insert in late first diff\n");
1056 #endif /* DEBUG_UPDATE */
1057                 Insert_write(nfd, fx);
1058                 str_insert(old, (int) (ofd - old), TermH, nfd, fx);
1059             }
1060
1061             /*
1062              * write (nsb-nfd) - fx chars of new starting at (nfd + fx)
1063              */
1064             so_write(nfd + fx, (nsb - nfd) - fx);
1065             str_cp(ofd + fx, nfd + fx, (int) ((nsb - nfd) - fx));
1066         }
1067         else {
1068 #ifdef DEBUG_UPDATE
1069             reprintf("without anything to save\r\n");
1070 #endif /* DEBUG_UPDATE */
1071             so_write(nfd, (nsb - nfd));
1072             str_cp(ofd, nfd, (int) (nsb - nfd));
1073         }
1074     }
1075
1076     /*
1077      * line is now NEW up to nse
1078      */
1079     if (sx >= 0) {
1080 #ifdef DEBUG_UPDATE
1081         reprintf("second diff insert at %d...\r\n", nse - new);
1082 #endif /* DEBUG_UPDATE */
1083         MoveToChar(nse - new);
1084         if (ols != oe) {
1085 #ifdef DEBUG_UPDATE
1086             reprintf("with stuff to keep at end\r\n");
1087 #endif /* DEBUG_UPDATE */
1088             if (sx > 0) {
1089                 /* insert sx chars of new starting at nse */
1090 #ifdef DEBUG_UPDATE
1091                 if (!T_CanIns)
1092                     reprintf("   ERROR: cannot insert in second diff\n");
1093 #endif /* DEBUG_UPDATE */
1094                 Insert_write(nse, sx);
1095             }
1096
1097             /*
1098              * write (nls-nse) - sx chars of new starting at (nse + sx)
1099              */
1100             so_write(nse + sx, (nls - nse) - sx);
1101         }
1102         else {
1103 #ifdef DEBUG_UPDATE
1104             reprintf("without anything to save\r\n");
1105 #endif /* DEBUG_UPDATE */
1106             so_write(nse, (nls - nse));
1107
1108             /*
1109              * No need to do a clear-to-end here because we were doing
1110              * a second insert, so we will have over written all of the
1111              * old string.
1112              */
1113         }
1114     }
1115 #ifdef DEBUG_UPDATE
1116     reprintf("done.\r\n");
1117 #endif /* DEBUG_UPDATE */
1118 }
1119
1120
1121 static void
1122 cpy_pad_spaces(Char *dst, Char *src, int width)
1123 {
1124     int i;
1125
1126     for (i = 0; i < width; i++) {
1127         if (*src == (Char) 0)
1128             break;
1129         *dst++ = *src++;
1130     }
1131
1132     while (i < width) {
1133         *dst++ = ' ';
1134         i++;
1135     }
1136     *dst = (Char) 0;
1137 }
1138
1139 static void
1140 CalcPosition(int w, int th, int *h, int *v)
1141 {
1142     switch(w) {
1143         case NLSCLASS_NL:
1144             *h = 0;
1145             (*v)++;
1146             break;
1147         case NLSCLASS_TAB:
1148             while (++(*h) & 07)
1149                 ;
1150             break;
1151         case NLSCLASS_CTRL:
1152             *h += 2;
1153             break;
1154         case NLSCLASS_ILLEGAL:
1155             *h += 4;
1156             break;
1157         case NLSCLASS_ILLEGAL2:
1158         case NLSCLASS_ILLEGAL3:
1159         case NLSCLASS_ILLEGAL4:
1160         case NLSCLASS_ILLEGAL5:
1161             *h += 4 + 2 * NLSCLASS_ILLEGAL_SIZE(w);
1162             break;
1163         default:
1164             *h += w;
1165     }
1166     if (*h >= th) {             /* check, extra long tabs picked up here also */
1167         *h -= th;
1168         (*v)++;
1169     }
1170 }
1171
1172 void
1173 RefCursor(void)
1174 {                               /* only move to new cursor pos */
1175     Char *cp;
1176     int w, h, th, v;
1177
1178     /* first we must find where the cursor is... */
1179     h = 0;
1180     v = 0;
1181     th = TermH;                 /* optimize for speed */
1182
1183     for (cp = Prompt; cp != NULL && *cp; ) {    /* do prompt */
1184         if (*cp & LITERAL) {
1185             cp++;
1186             continue;
1187         }
1188         w = NLSClassify(*cp & CHAR, cp == Prompt, 0);
1189         cp++;
1190         CalcPosition(w, th, &h, &v);
1191     }
1192
1193     for (cp = InputBuf; cp < Cursor;) { /* do input buffer to Cursor */
1194         w = NLSClassify(*cp & CHAR, cp == InputBuf, 0);
1195         cp++;
1196         CalcPosition(w, th, &h, &v);
1197     }
1198
1199     /* now go there */
1200     MoveToLine(v);
1201     MoveToChar(h);
1202     if (adrof(STRhighlight) && MarkIsSet) {
1203         ClearLines();
1204         ClearDisp();
1205         Refresh();
1206     }
1207     flush();
1208 }
1209
1210 #ifndef WINTT_NATIVE
1211 static void
1212 PutPlusOne(Char c, int width)
1213 {
1214     while (width > 1 && CursorH + width > TermH)
1215         PutPlusOne(' ', 1);
1216     if ((c & LITERAL) != 0) {
1217         Char *d;
1218         for (d = litptr + (c & ~LITERAL) * LIT_FACTOR; *d; d++)
1219             (void) putwraw(*d);
1220     } else {
1221         (void) putwraw(c);
1222     }
1223     Display[CursorV][CursorH++] = (Char) c;
1224     while (--width > 0)
1225         Display[CursorV][CursorH++] = CHAR_DBWIDTH;
1226     if (CursorH >= TermH) {     /* if we must overflow */
1227         CursorH = 0;
1228         CursorV++;
1229         OldvcV++;
1230         if (T_Margin & MARGIN_AUTO) {
1231             if (T_Margin & MARGIN_MAGIC) {
1232                 (void) putraw(' ');
1233                 (void) putraw('\b');
1234             }
1235         }
1236         else {
1237             (void) putraw('\r');
1238             (void) putraw('\n');
1239         }
1240     }
1241 }
1242 #endif
1243
1244 void
1245 RefPlusOne(int l)
1246 {                               /* we added just one char, handle it fast.
1247                                  * assumes that screen cursor == real cursor */
1248     Char *cp, c;
1249     int w;
1250
1251     if (Cursor != LastChar) {
1252         Refresh();              /* too hard to handle */
1253         return;
1254     }
1255     if (rprompt_h != 0 && (TermH - CursorH - rprompt_h < 3)) {
1256         Refresh();              /* clear out rprompt if less than one char gap*/
1257         return;
1258     }
1259     cp = Cursor - l;
1260     c = *cp & CHAR;
1261     w = NLSClassify(c, cp == InputBuf, 0);
1262     switch(w) {
1263         case NLSCLASS_CTRL:
1264             PutPlusOne('^', 1);
1265             if (c == CTL_ESC('\177')) {
1266                 PutPlusOne('?', 1);
1267                 break;
1268             }
1269 #ifdef IS_ASCII
1270             /* uncontrolify it; works only for iso8859-1 like sets */
1271             PutPlusOne((c | 0100), 1);
1272 #else
1273             PutPlusOne(_toebcdic[_toascii[c]|0100], 1);
1274 #endif
1275             break;
1276         case NLSCLASS_ILLEGAL:
1277             PutPlusOne('\\', 1);
1278             PutPlusOne(((c >> 6) & 7) + '0', 1);
1279             PutPlusOne(((c >> 3) & 7) + '0', 1);
1280             PutPlusOne((c & 7) + '0', 1);
1281             break;
1282         case 1:
1283             if (adrof(STRhighlight) && MarkIsSet)
1284                 StartHighlight();
1285             if (l > 1)
1286                 PutPlusOne(MakeLiteral(cp, l, 0), 1);
1287             else
1288                 PutPlusOne(*cp, 1);
1289             if (adrof(STRhighlight) && MarkIsSet)
1290                 StopHighlight();
1291             break;
1292         default:
1293             Refresh();          /* too hard to handle */
1294             return;
1295     }
1296     flush();
1297 }
1298
1299 /* clear the screen buffers so that new new prompt starts fresh. */
1300
1301 void
1302 ClearDisp(void)
1303 {
1304     int i;
1305
1306     CursorV = 0;                /* clear the display buffer */
1307     CursorH = 0;
1308     for (i = 0; i < TermV; i++)
1309         (void) memset(Display[i], 0, (TermH + 1) * sizeof(Display[0][0]));
1310     OldvcV = 0;
1311     litlen = 0;
1312 }
1313
1314 void
1315 ClearLines(void)
1316 {                               /* Make sure all lines are *really* blank */
1317     int i;
1318
1319     if (T_CanCEOL) {
1320         /*
1321          * Clear the lines from the bottom up so that if we try moving
1322          * the cursor down by writing the character that is at the end
1323          * of the screen line, we won't rewrite a character that shouldn't
1324          * be there.
1325          */
1326         for (i = OldvcV; i >= 0; i--) { /* for each line on the screen */
1327             MoveToLine(i);
1328             MoveToChar(0);
1329             ClearEOL(TermH);
1330         }
1331     }
1332     else {
1333         MoveToLine(OldvcV);     /* go to last line */
1334         (void) putraw('\r');    /* go to BOL */
1335         (void) putraw('\n');    /* go to new line */
1336     }
1337 }