![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to display.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / me|
Return to display.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / me |
1.1 ! root 1: /* ! 2: * The functions in this file handle redisplay. ! 3: * There are two halves, the ones that update the virtual display screen, ! 4: * and the ones that make the physical display screen the same as the virtual ! 5: * display screen. These functions use hints that are left in the windows by ! 6: * the commands. ! 7: */ ! 8: #include <stdio.h> ! 9: #include "ed.h" ! 10: ! 11: #define WFDEBUG 0 /* Window flag debug. */ ! 12: #define FASTHACK 1 /* Slightly faster update code */ ! 13: ! 14: typedef struct VIDEO { ! 15: short v_flag; /* Flags */ ! 16: uchar v_text[]; /* Screen data. */ ! 17: } VIDEO; ! 18: ! 19: #define VFCHG 0x0001 /* Changed. */ ! 20: #define VFSTD 0x0002 /* Standout. */ ! 21: ! 22: int sgarbf = TRUE; /* TRUE if screen is garbage */ ! 23: int mpresf = FALSE; /* TRUE if message in last line */ ! 24: int vtrow = 0; /* Row location of SW cursor */ ! 25: int vtcol = 0; /* Column location of SW cursor */ ! 26: int ttrow = HUGE; /* Row location of HW cursor */ ! 27: int ttcol = HUGE; /* Column location of HW cursor */ ! 28: VIDEO **vscreen; /* Virtual screen. */ ! 29: VIDEO **pscreen; /* Physical screen. */ ! 30: ! 31: /* ! 32: * Initialize the data structures used by the display code. ! 33: * The edge vectors used to access the screens are set up. ! 34: * The operating system's terminal I/O channel is set up. ! 35: * All the other things get initialized at compile time. ! 36: * The original window has "WFCHG" set, so that it will get ! 37: * completely redrawn on the first call to "update". ! 38: */ ! 39: vtinit() ! 40: { ! 41: register int i; ! 42: register VIDEO *vp; ! 43: ! 44: vscreen = (VIDEO **) malloc(term.t_nrow*sizeof(VIDEO *)); ! 45: if (vscreen == NULL) ! 46: abort(); ! 47: pscreen = (VIDEO **) malloc(term.t_nrow*sizeof(VIDEO *)); ! 48: if (pscreen == NULL) ! 49: abort(); ! 50: for (i=0; i<term.t_nrow; ++i) { ! 51: vp = (VIDEO *) malloc(sizeof(VIDEO)+term.t_ncol); ! 52: if (vp == NULL) ! 53: abort(); ! 54: vscreen[i] = vp; ! 55: vp = (VIDEO *) malloc(sizeof(VIDEO)+term.t_ncol); ! 56: if (vp == NULL) ! 57: abort(); ! 58: pscreen[i] = vp; ! 59: } ! 60: } ! 61: ! 62: /* ! 63: * Clean up the virtual terminal system, in anticipation for a return to the ! 64: * operating system. Move down to the last line and clear it out (the next ! 65: * system prompt will be written in the line). Shut down the channel to the ! 66: * terminal. ! 67: */ ! 68: vttidy() ! 69: { ! 70: movecursor(term.t_nrow, 0); ! 71: teeol(); ! 72: tstand(0); ! 73: tclose(); ! 74: } ! 75: ! 76: /* ! 77: * Set the virtual cursor to the specified row and column on the ! 78: * virtual screen. There is no checking for nonsense values; this might ! 79: * be a good idea during the early stages. ! 80: */ ! 81: vtmove(row, col) ! 82: { ! 83: vtrow = row; ! 84: vtcol = col; ! 85: } ! 86: ! 87: /* ! 88: * If bind.dispmode == 1 chars < ' ' are displayed directly ! 89: * else they are displayed whit preceeding ^ and ^= '@' ! 90: */ ! 91: displaymod() ! 92: { ! 93: bind.dispmode ^= 1; ! 94: } ! 95: ! 96: /* ! 97: * Return 2 if char is tab 1 if it needs ^ for ansi emulation. ! 98: */ ! 99: dblchr(c) ! 100: register unsigned c; ! 101: { ! 102: if (bind.dispmode) { ! 103: switch(c) { ! 104: case '\n': ! 105: case '\f': ! 106: case '\r': ! 107: case 0x1b: ! 108: return (1); ! 109: case '\t': ! 110: return (2); ! 111: } ! 112: return (0); ! 113: } ! 114: return (((c < ' ') || (c == 0x7f)) ? ((c == '\t') ? 2 : 1) : 0); ! 115: } ! 116: ! 117: /* ! 118: * Write a character to the virtual screen. The virtual row and ! 119: * column are updated. If the line is too long put a "$" in the last column. ! 120: * This routine only puts printing characters into the virtual terminal buffers. ! 121: * Only column overflow is checked. ! 122: */ ! 123: vtputc(c) ! 124: unsigned c; ! 125: { ! 126: register VIDEO *vp; ! 127: ! 128: vp = vscreen[vtrow]; ! 129: switch (dblchr(c)) { ! 130: case 0: /* normal character */ ! 131: if (vtcol >= term.t_ncol) ! 132: vp->v_text[term.t_ncol - 1] = '$'; ! 133: else ! 134: vp->v_text[vtcol++] = c; ! 135: break; ! 136: case 2: /* tab */ ! 137: do { ! 138: if (vtcol >= term.t_ncol) { ! 139: vp->v_text[term.t_ncol - 1] = '$'; ! 140: break; ! 141: } else ! 142: vp->v_text[vtcol++] = ' '; ! 143: } while (vtcol % bind.tabsiz); ! 144: break; ! 145: case 1: /* needs ^ */ ! 146: vtputc('^'); ! 147: vtputc(c ^ 0x40); ! 148: break; ! 149: } ! 150: } ! 151: ! 152: /* ! 153: * Erase from the end of the software cursor to the end of the line on which ! 154: * the software cursor is located. ! 155: */ ! 156: vteeol() ! 157: { ! 158: register VIDEO *vp; ! 159: ! 160: vp = vscreen[vtrow]; ! 161: while (vtcol < term.t_ncol) ! 162: vp->v_text[vtcol++] = ' '; ! 163: } ! 164: ! 165: /* ! 166: * Make sure that the display is right. This is a three part process. ! 167: * First, scan through all of the windows looking for dirty ones. ! 168: * Check the framing, and refresh the screen. ! 169: * Second, make sure that "currow" and "curcol" are correct for the current ! 170: * window. ! 171: * Third, make the virtual and physical screens the same. ! 172: */ ! 173: update() ! 174: { ! 175: register LINE *lp; ! 176: LINE *xlp; ! 177: register WINDOW *wp; ! 178: register VIDEO *vp1; ! 179: register VIDEO *vp2; ! 180: register int i; ! 181: register int j; ! 182: ! 183: wp = wheadp; ! 184: while (wp != NULL) { ! 185: /* Look at any window with update flags set on. */ ! 186: if (wp->w_flag != 0) { ! 187: /* If not force reframe, check the framing. */ ! 188: if ((wp->w_flag&WFFORCE) == 0) { ! 189: lp = wp->w_linep; ! 190: for (i=0; i<wp->w_ntrows; ++i) { ! 191: if (lp == wp->w_dotp) ! 192: goto out; ! 193: if (lp == wp->w_bufp->b_linep) ! 194: break; ! 195: lp = lforw(lp); ! 196: } ! 197: } ! 198: /* Not acceptable, better compute a new value */ ! 199: /* for the line at the top of the window. Then */ ! 200: /* set the "WFHARD" flag to force full redraw. */ ! 201: i = wp->w_force; ! 202: if (i > 0) { ! 203: --i; ! 204: if (i >= wp->w_ntrows) ! 205: i = wp->w_ntrows-1; ! 206: } else if (i < 0) { ! 207: i += wp->w_ntrows; ! 208: if (i < 0) ! 209: i = 0; ! 210: } else ! 211: i = wp->w_ntrows/2; ! 212: lp = wp->w_dotp; ! 213: while (i!=0 && lback(lp)!=wp->w_bufp->b_linep) { ! 214: --i; ! 215: lp = lback(lp); ! 216: } ! 217: wp->w_linep = lp; ! 218: wp->w_flag |= WFHARD; /* Force full. */ ! 219: out: ! 220: /* Try to use reduced update. Mode line update */ ! 221: /* has its own special flag. The fast update is */ ! 222: /* used if the only thing to do is within the */ ! 223: /* line editing. */ ! 224: lp = wp->w_linep; ! 225: i = wp->w_toprow; ! 226: if ((wp->w_flag&~WFMODE) == WFEDIT) { ! 227: while (lp != wp->w_dotp) { ! 228: ++i; ! 229: lp = lforw(lp); ! 230: } ! 231: #ifdef FASTHACK ! 232: vscreen[i]->v_flag = VFCHG; ! 233: #else ! 234: vscreen[i]->v_flag |= VFCHG; ! 235: vscreen[i]->v_flag &= ~VFSTD; ! 236: #endif ! 237: vtmove(i, 0); ! 238: for (j=0; j<llength(lp); ++j) ! 239: vtputc(lgetc(lp, j)); ! 240: vteeol(); ! 241: } else if ((wp->w_flag&(WFEDIT|WFHARD)) != 0) { ! 242: while (i < wp->w_toprow+wp->w_ntrows) { ! 243: #ifdef FASTHACK ! 244: vscreen[i]->v_flag = VFCHG; ! 245: #else ! 246: vscreen[i]->v_flag |= VFCHG; ! 247: vscreen[i]->v_flag &= ~VFSTD; ! 248: #endif ! 249: vtmove(i, 0); ! 250: if (lp != wp->w_bufp->b_linep) { ! 251: for (j=0; j<llength(lp); ++j) ! 252: vtputc(lgetc(lp, j)); ! 253: lp = lforw(lp); ! 254: } ! 255: vteeol(); ! 256: ++i; ! 257: } ! 258: } ! 259: #if !WFDEBUG ! 260: if ((wp->w_flag&WFMODE) != 0) ! 261: modeline(wp); ! 262: wp->w_flag = 0; ! 263: wp->w_force = 0; ! 264: #endif ! 265: } ! 266: #if WFDEBUG ! 267: modeline(wp); ! 268: wp->w_flag = 0; ! 269: wp->w_force = 0; ! 270: #endif ! 271: /* Set standout mode on status line... */ ! 272: vscreen[wp->w_toprow+wp->w_ntrows]->v_flag |= VFSTD; ! 273: wp = wp->w_wndp; ! 274: } ! 275: /* Always recompute the row and column number of the hardware */ ! 276: /* cursor. This is the only update for simple moves. */ ! 277: xlp = lp = curwp->w_linep; ! 278: currow = curwp->w_toprow; ! 279: while (lp != curwp->w_dotp) { ! 280: ++currow; ! 281: if (xlp == (lp = lforw(lp))) { /* Fix infinite loop problem */ ! 282: currow = curwp->w_toprow; ! 283: curwp->w_dotp = lp = xlp; ! 284: curwp->w_doto = 0; ! 285: break; ! 286: } ! 287: } ! 288: curcol = truecol(lp, curwp->w_doto); ! 289: ! 290: #if GEM && NATIVE ! 291: /* Special preparation for screen update on ATARI ST native screen */ ! 292: /* We shut off the cursor -- This speeds up the writing of text */ ! 293: /* quite a bit. */ ! 294: ! 295: astcursor(0); /* Turn cursor off for update */ ! 296: #endif ! 297: ! 298: /* Special hacking if the screen is garbage. Clear the hardware */ ! 299: /* screen, and update your copy to agree with it. Set all the */ ! 300: /* virtual screen change bits, to force a full update. */ ! 301: ! 302: if (sgarbf != FALSE) { ! 303: for (i=0; i<term.t_nrow; ++i) { ! 304: vscreen[i]->v_flag |= VFCHG; ! 305: vp1 = pscreen[i]; ! 306: for (j=0; j<term.t_ncol; ++j) ! 307: vp1->v_text[j] = ' '; ! 308: } ! 309: teeop(); /* Erase the screen. */ ! 310: sgarbf = FALSE; /* Erase-page clears */ ! 311: mpresf = FALSE; /* the message area. */ ! 312: } ! 313: ! 314: /* Make sure that the physical and virtual displays agree. */ ! 315: /* Unlike before, the "updateline" code is only called with a */ ! 316: /* line that has been updated for sure. */ ! 317: ! 318: for (i=0; i<term.t_nrow; ++i) { ! 319: vp1 = vscreen[i]; ! 320: if ((vp1->v_flag&VFCHG) != 0) { ! 321: vp2 = pscreen[i]; ! 322: if ((vp1->v_flag&VFSTD) != 0) { /* Standout mode */ ! 323: #ifndef FASTHACK ! 324: vp1->v_flag &= ~VFSTD; ! 325: #endif ! 326: tstand(1); ! 327: updateline(i, &vp1->v_text[0], &vp2->v_text[0]); ! 328: tstand(0); ! 329: } else ! 330: updateline(i, &vp1->v_text[0], &vp2->v_text[0]); ! 331: #ifdef FASTHACK ! 332: vp1->v_flag = 0; ! 333: #else ! 334: vp1->v_flag &= ~VFCHG; ! 335: #endif ! 336: } ! 337: } ! 338: /* Finally, update the hardware cursor and flush out buffers. */ ! 339: bracketmode(currow, curcol); ! 340: #if GEM && NATIVE ! 341: astcursor(1); /* Turn cursor back on... */ ! 342: #endif ! 343: tflush(); ! 344: } ! 345: ! 346: /* ! 347: * Update a single line. This does not know how to use insert or delete ! 348: * character sequences; we are using VT52 functionality. Update the physical ! 349: * row and column variables. It does try and exploit erase to end of line. ! 350: * The RAINBOW version of this routine uses fast video. ! 351: */ ! 352: updateline(row, vline, pline) ! 353: uchar vline[]; ! 354: uchar pline[]; ! 355: { ! 356: #if RAINBOW|IBM ! 357: register uchar *cp1; ! 358: register uchar *cp2; ! 359: register int nch; ! 360: ! 361: cp1 = &vline[0]; /* Use fast video. */ ! 362: cp2 = &pline[0]; ! 363: putline(row+1, 1, cp1); ! 364: nch = term.t_ncol; ! 365: do { ! 366: *cp2 = *cp1; ! 367: ++cp2; ! 368: ++cp1; ! 369: } while (--nch); ! 370: #else ! 371: register uchar *cp1; ! 372: register uchar *cp2; ! 373: register uchar *cp3; ! 374: register uchar *cp4; ! 375: register uchar *cp5; ! 376: register int nbflag; ! 377: ! 378: cp1 = &vline[0]; /* Compute left match. */ ! 379: cp2 = &pline[0]; ! 380: while (cp1!=&vline[term.t_ncol] && cp1[0]==cp2[0]) { ! 381: ++cp1; ! 382: ++cp2; ! 383: } ! 384: /* This can still happen, even though we only call this routine */ ! 385: /* on changed lines. A hard update is always done when a line */ ! 386: /* splits, a massive change is done, or a buffer is displayed */ ! 387: /* twice. This optimizes out most of the excess updating. A lot */ ! 388: /* of computes are used, but these tend to be hard operations */ ! 389: /* that do a lot of update, so I don't really care. */ ! 390: if (cp1 == &vline[term.t_ncol]) /* All equal. */ ! 391: return; ! 392: nbflag = FALSE; ! 393: cp3 = &vline[term.t_ncol]; /* Compute right match. */ ! 394: cp4 = &pline[term.t_ncol]; ! 395: while (cp3[-1] == cp4[-1]) { ! 396: --cp3; ! 397: --cp4; ! 398: if (cp3[0] != ' ') /* Note if any nonblank */ ! 399: nbflag = TRUE; /* in right match. */ ! 400: } ! 401: cp5 = cp3; ! 402: if (nbflag == FALSE) { /* Erase to EOL ? */ ! 403: while (cp5!=cp1 && cp5[-1]==' ') ! 404: --cp5; ! 405: if (cp3-cp5 <= 3) /* Use only if erase is */ ! 406: cp5 = cp3; /* fewer characters. */ ! 407: } ! 408: movecursor(row, (int)(cp1-&vline[0])); /* Go to start of line. */ ! 409: while (cp1 != cp5) { /* Ordinary. */ ! 410: tputc(*cp1); ! 411: ++ttcol; ! 412: *cp2++ = *cp1++; ! 413: } ! 414: if (cp5 != cp3) { /* Erase. */ ! 415: teeol(); ! 416: while (cp1 != cp3) ! 417: *cp2++ = *cp1++; ! 418: } ! 419: #endif ! 420: } ! 421: ! 422: /* ! 423: * Redisplay the mode line for the window pointed to by the "wp". ! 424: * This is the only routine that has any idea of how the modeline is formatted. ! 425: * You can change the modeline format by hacking at this routine. ! 426: * Called by "update" any time there is a dirty window. ! 427: */ ! 428: modeline(wp) ! 429: register WINDOW *wp; ! 430: { ! 431: register uchar *cp; ! 432: register int c; ! 433: register int n; ! 434: register BUFFER *bp; ! 435: ! 436: n = wp->w_toprow+wp->w_ntrows; /* Location. */ ! 437: vscreen[n]->v_flag |= VFCHG; /* Redraw next time. */ ! 438: vtmove(n, 0); /* Seek to right line. */ ! 439: vtputc('-'); ! 440: bp = wp->w_bufp; ! 441: if ((bp->b_flag&BFCHG) != 0) /* "*" if changed. */ ! 442: vtputc('*'); ! 443: else ! 444: vtputc('-'); ! 445: n = 2; ! 446: cp = PROMPT; /* Buffer name. */ ! 447: while ((c = *cp++) != 0) { ! 448: vtputc(c); ! 449: ++n; ! 450: } ! 451: cp = &bp->b_bname[0]; ! 452: while ((c = *cp++) != 0) { ! 453: vtputc(c); ! 454: ++n; ! 455: } ! 456: vtputc(' '); ! 457: ++n; ! 458: if (bp->b_fname[0] != 0) { /* File name. */ ! 459: #if LIBHELP ! 460: if (bp->b_flag & BFHELP) ! 461: cp = "- Subject: "; ! 462: else ! 463: #endif ! 464: cp = "-- File: "; ! 465: while ((c = *cp++) != 0) { ! 466: vtputc(c); ! 467: ++n; ! 468: } ! 469: cp = &bp->b_fname[0]; ! 470: while ((c = *cp++) != 0) { ! 471: vtputc(c); ! 472: ++n; ! 473: } ! 474: vtputc(' '); ! 475: ++n; ! 476: } ! 477: #if WFDEBUG ! 478: vtputc('-'); ! 479: vtputc((wp->w_flag&WFMODE)!=0 ? 'M' : '-'); ! 480: vtputc((wp->w_flag&WFHARD)!=0 ? 'H' : '-'); ! 481: vtputc((wp->w_flag&WFEDIT)!=0 ? 'E' : '-'); ! 482: vtputc((wp->w_flag&WFMOVE)!=0 ? 'V' : '-'); ! 483: vtputc((wp->w_flag&WFFORCE)!=0 ? 'F' : '-'); ! 484: n += 6; ! 485: #endif ! 486: while (n < term.t_ncol) { /* Pad to full width. */ ! 487: vtputc('-'); ! 488: ++n; ! 489: } ! 490: } ! 491: ! 492: /* ! 493: * Send a command to the terminal to move the hardware cursor to row "row" ! 494: * and column "col". The row and column arguments are origin 0. ! 495: * Optimize out random calls. Update "ttrow" and "ttcol". ! 496: */ ! 497: movecursor(row, col) ! 498: { ! 499: if (row!=ttrow || col!=ttcol) { ! 500: ttrow = row; ! 501: ttcol = col; ! 502: tmove(row, col); ! 503: } ! 504: } ! 505: ! 506: /* ! 507: * Erase the message line. ! 508: * This is a special routine because the message line is not considered to be ! 509: * part of the virtual screen. It always works immediately; the terminal ! 510: * buffer is flushed via a call to the flusher. ! 511: */ ! 512: mlerase() ! 513: { ! 514: movecursor(term.t_nrow, 0); ! 515: teeol(); ! 516: tflush(); ! 517: mpresf = FALSE; ! 518: } ! 519: ! 520: /* ! 521: * Ask a yes or no question in the message line. ! 522: * Return either TRUE, FALSE, or ABORT. The ABORT status is returned ! 523: * if the user bumps out of the question with a ^G. ! 524: * Used any time a confirmation is required. ! 525: */ ! 526: mlyesno(prompt) ! 527: uchar *prompt; ! 528: { ! 529: register int s; ! 530: uchar buf[64]; ! 531: ! 532: for (;;) { ! 533: strcpy(buf, prompt); ! 534: strcat(buf, " [y/n]? "); ! 535: s = mlreply(buf, buf, sizeof(buf)); ! 536: if (s == ABORT) ! 537: return (ABORT); ! 538: if (s != FALSE) { ! 539: if (buf[0]=='y' || buf[0]=='Y') ! 540: return (TRUE); ! 541: if (buf[0]=='n' || buf[0]=='N') ! 542: return (FALSE); ! 543: } ! 544: } ! 545: } ! 546: ! 547: /* ! 548: * Write a prompt into the message line, then read back a response. ! 549: * Keep track of the physical position of the cursor. ! 550: * If we are in a keyboard macro throw the prompt away, and return ! 551: * the remembered response. This lets macros run at full speed. ! 552: * The reply is always terminated by a carriage return. ! 553: * Handle erase, kill, and abort keys. ! 554: */ ! 555: mlreply(prompt, buf, nbuf) ! 556: uchar *prompt; ! 557: uchar *buf; ! 558: { ! 559: register int cpos; ! 560: register int i; ! 561: register int c; ! 562: ! 563: cpos = 0; ! 564: if (kbdmop != NULL) { ! 565: while ((c = *kbdmop++) != '\0') ! 566: buf[cpos++] = c; ! 567: buf[cpos] = 0; ! 568: if (buf[0] == 0) ! 569: return (FALSE); ! 570: return (TRUE); ! 571: } ! 572: mlwrite(prompt); ! 573: for (;;) { ! 574: c = tgetc(); ! 575: switch (c) { ! 576: case 0x0D: /* Return, end of line */ ! 577: buf[cpos++] = 0; ! 578: if (kbdmip != NULL) { ! 579: if ((kbdmip+cpos) > (kbdm + ((NKBDM - 3)/2))) { ! 580: ctrlg(FALSE, 0); ! 581: tflush(); ! 582: return (ABORT); ! 583: } ! 584: for (i=0; i<cpos; ++i) ! 585: *kbdmip++ = buf[i]; ! 586: } ! 587: tputc('\r'); ! 588: ttcol = 0; ! 589: tflush(); ! 590: if (buf[0] == 0) ! 591: return (FALSE); ! 592: return (TRUE); ! 593: ! 594: case 0x07: /* Bell, abort */ ! 595: tputc('^'); ! 596: tputc('G'); ! 597: ttcol += 2; ! 598: ctrlg(FALSE, 0); ! 599: tflush(); ! 600: return (ABORT); ! 601: ! 602: case 0x7f: /* Rubout, erase */ ! 603: case 0x08: /* Backspace, erase */ ! 604: if (cpos != 0) { ! 605: tputc('\b'); ! 606: tputc(' '); ! 607: tputc('\b'); ! 608: --ttcol; ! 609: if (buf[--cpos] < 0x20) { ! 610: tputc('\b'); ! 611: tputc(' '); ! 612: tputc('\b'); ! 613: --ttcol; ! 614: } ! 615: tflush(); ! 616: } ! 617: break; ! 618: ! 619: case 0x15: /* C-U, kill */ ! 620: while (cpos != 0) { ! 621: tputc('\b'); ! 622: tputc(' '); ! 623: tputc('\b'); ! 624: --ttcol; ! 625: if (buf[--cpos] < 0x20) { ! 626: tputc('\b'); ! 627: tputc(' '); ! 628: tputc('\b'); ! 629: --ttcol; ! 630: } ! 631: } ! 632: tflush(); ! 633: break; ! 634: ! 635: default: ! 636: if (cpos < nbuf-1) { ! 637: buf[cpos++] = c; ! 638: if (c < ' ') { ! 639: tputc('^'); ! 640: ++ttcol; ! 641: c ^= 0x40; ! 642: } ! 643: tputc(c); ! 644: ++ttcol; ! 645: tflush(); ! 646: } ! 647: } ! 648: } ! 649: } ! 650: ! 651: /* ! 652: * Write a message into the message line. ! 653: * Keep track of the physical cursor position. ! 654: * A small class of printf like format items is handled. ! 655: * Assumes the stack grows down; this assumption is made by the "++" ! 656: * in the argument scan loop. Set the "message line" flag TRUE. ! 657: */ ! 658: mlwrite(fmt) ! 659: uchar *fmt; ! 660: { ! 661: register int c; ! 662: ! 663: uchar buf[NPAT * 2]; ! 664: ! 665: movecursor(term.t_nrow, 0); ! 666: sprintf(buf, "%r", &fmt); ! 667: if (strlen(buf) > (term.t_ncol - 1)) ! 668: buf[term.t_ncol - 1] = 0; ! 669: for (fmt = buf; c = *fmt; fmt++) { ! 670: tputc(c); ! 671: ++ttcol; ! 672: } ! 673: teeol(); ! 674: tflush(); ! 675: mpresf = TRUE; ! 676: } ! 677: ! 678: /* ! 679: * Write out a string. ! 680: * Update the physical cursor position. This assumes that the characters in the ! 681: * string all have width "1"; if this is not the case things will get screwed up ! 682: * a little. ! 683: */ ! 684: mlputs(s) ! 685: register uchar *s; ! 686: { ! 687: register int c; ! 688: ! 689: while ((c = *s++) != 0) { ! 690: tputc(c); ! 691: ++ttcol; ! 692: } ! 693: } ! 694: ! 695: /* ! 696: * find the logical cursor. Return line from top of ! 697: * window. ! 698: */ ! 699: locatecursor(what) ! 700: LINE *what; ! 701: { ! 702: int row; ! 703: LINE *clp; ! 704: ! 705: row = 0; ! 706: for (clp = curwp->w_linep; clp != what; clp = lforw(clp)) { ! 707: if ((clp == curbp->b_linep) || (row > curwp->w_ntrows)) ! 708: return (-1); ! 709: row++; ! 710: } ! 711: return (row + curwp->w_toprow); ! 712: } ! 713: ! 714: /* ! 715: * turn LINE and char pointer into display col. ! 716: */ ! 717: truecol(clp, col) ! 718: LINE *clp; ! 719: { ! 720: register int i, tcol; ! 721: unsigned c; ! 722: ! 723: for (i = tcol = 0; i < col; i++) { ! 724: c = lgetc(clp, i); ! 725: switch (dblchr(c)) { ! 726: case 2: ! 727: taber(tcol); ! 728: break; ! 729: case 1: ! 730: tcol++; ! 731: } ! 732: tcol++; ! 733: } ! 734: if (tcol >= term.t_ncol) /* too far out */ ! 735: tcol = term.t_ncol - 1; ! 736: return (tcol); ! 737: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.