![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to screen.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 ! root 1: /*************************************************************************** ! 2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE * ! 3: * is provided to you without charge, and with no warranty. You may give * ! 4: * away copies of JOVE, including sources, provided that this notice is * ! 5: * included in all the files. * ! 6: ***************************************************************************/ ! 7: ! 8: #include "jove.h" ! 9: #include "io.h" ! 10: #include "ctype.h" ! 11: #include "termcap.h" ! 12: ! 13: #ifdef IBMPC ! 14: ! 15: /* here come the actual emulation routines */ ! 16: ! 17: #include <dos.h> ! 18: #include <conio.h> ! 19: ! 20: #define BYTE unsigned char ! 21: #define WORD unsigned int ! 22: ! 23: #ifdef MAC ! 24: # undef private ! 25: # define private ! 26: #endif ! 27: ! 28: #ifdef LINT_ARGS ! 29: private BYTE near get_mode(void); ! 30: ! 31: private WORD ! 32: near cur_page(void), ! 33: near get_cur(void); ! 34: ! 35: private void ! 36: near ch_out(BYTE, BYTE), ! 37: near clr_eop(void), ! 38: near cur_advance(void), ! 39: near cur_down(void), ! 40: near cur_left(void), ! 41: near cur_right(void), ! 42: near cur_up(void), ! 43: near line_feed(void), ! 44: near normfun(char), ! 45: near scr_win(int, BYTE, BYTE, BYTE, BYTE), ! 46: near set_cur(WORD), ! 47: near set_mode(BYTE), ! 48: near wherexy(BYTE *, BYTE *); ! 49: #else ! 50: private BYTE near get_mode(); ! 51: ! 52: private WORD ! 53: near cur_page(), ! 54: near get_cur(); ! 55: ! 56: private void ! 57: near ch_out(), ! 58: near clr_eop(), ! 59: near cur_advance(), ! 60: near cur_down(), ! 61: near cur_left(), ! 62: near cur_right(), ! 63: near cur_up(), ! 64: near line_feed(), ! 65: near normfun(), ! 66: near scr_win(), ! 67: near set_cur(), ! 68: near set_mode(), ! 69: near wherexy(); ! 70: #endif /* LINT_ARGS */ ! 71: ! 72: #ifdef MAC ! 73: # undef private ! 74: # define private static ! 75: #endif ! 76: ! 77: #define VIDEO 0x10 ! 78: ! 79: #define intr(n, r) int86(n, r, r); ! 80: ! 81: BYTE CHPL=80, ! 82: LPP=25, ! 83: CUR_PAGE=0, ! 84: C_ATTR = 0x07, ! 85: C_X=0, ! 86: C_Y=0; ! 87: ! 88: int Fgcolor = 7, ! 89: Bgcolor = 0, ! 90: Mdcolor = 0; ! 91: ! 92: void setcolor(fg, bg) ! 93: BYTE fg, bg; ! 94: { ! 95: C_ATTR = ((bg&0xf)<<4)|(fg&0xf); ! 96: } ! 97: ! 98: private ! 99: WORD near cur_page() ! 100: { ! 101: union REGS vr; ! 102: ! 103: vr.h.ah = 0x0f; ! 104: intr(VIDEO, &vr); ! 105: return(vr.h.bh); ! 106: } ! 107: ! 108: private ! 109: void near set_cur(xy) ! 110: WORD xy; ! 111: { ! 112: union REGS vr; ! 113: ! 114: vr.h.bh = CUR_PAGE; ! 115: vr.h.ah = 0x02; ! 116: vr.x.dx = xy; ! 117: intr(VIDEO, &vr); ! 118: } ! 119: ! 120: private ! 121: WORD near get_cur() ! 122: { ! 123: union REGS vr; ! 124: ! 125: vr.h.bh = CUR_PAGE; ! 126: vr.h.ah = 0x03; ! 127: intr(VIDEO, &vr); ! 128: return (vr.x.dx); ! 129: } ! 130: ! 131: private ! 132: BYTE near get_mode() ! 133: { ! 134: union REGS vr; ! 135: ! 136: vr.h.ah = 0x0f; ! 137: intr(VIDEO, &vr); ! 138: return(vr.h.al); ! 139: } ! 140: ! 141: BYTE lpp() ! 142: { ! 143: int far *regen = (int far *) 0x44C; ! 144: int what; ! 145: BYTE chpl(); ! 146: ! 147: what = (*regen&0xff00)/2/chpl(); ! 148: return (what > 43 ? 25 : what); ! 149: } ! 150: ! 151: private ! 152: void near set_mode(n) ! 153: BYTE n; ! 154: { ! 155: union REGS vr; ! 156: ! 157: vr.h.ah = 0x00; ! 158: vr.h.al = n; ! 159: intr(VIDEO, &vr); ! 160: } ! 161: ! 162: #define gotoxy(x,y) set_cur((x)<<8|((y)&0xff)) ! 163: #define cur_mov(x,y) set_cur((C_X=x)<<8|((C_Y=y)&0xff)) ! 164: ! 165: private ! 166: void near wherexy( x, y) ! 167: BYTE *x, *y; ! 168: { ! 169: register WORD xy; ! 170: ! 171: xy = get_cur(); ! 172: *x = xy>>8; ! 173: *y = xy&0xff; ! 174: } ! 175: ! 176: #define wherex() C_X ! 177: #define wherey() C_Y ! 178: ! 179: private ! 180: void near scr_win(no, ulr, ulc, lrr, lrc) ! 181: int no; ! 182: BYTE ulr, ulc, lrr, lrc; ! 183: { ! 184: union REGS vr; ! 185: ! 186: if (no >= 0) ! 187: vr.h.ah = 0x06; ! 188: else { ! 189: vr.h.ah = 0x07; ! 190: no = - no; ! 191: } ! 192: vr.h.al = no; ! 193: vr.x.cx = ulr<<8 | ulc; ! 194: vr.x.dx = lrr<<8 | lrc; ! 195: vr.h.bh = C_ATTR; ! 196: intr(VIDEO, &vr); ! 197: } ! 198: ! 199: BYTE chpl() ! 200: { ! 201: union REGS vr; ! 202: ! 203: vr.h.ah = 0x0f; ! 204: intr(VIDEO, &vr); ! 205: return(vr.h.ah); ! 206: } ! 207: ! 208: #define clr_page() scr_win(0, 0, 0, LPP-1, CHPL-1), \ ! 209: gotoxy(C_X = 0, C_Y = 0) ! 210: ! 211: private ! 212: void near cur_right() ! 213: { ! 214: if (C_Y < CHPL-1) ! 215: C_Y++; ! 216: gotoxy(C_X, C_Y); ! 217: } ! 218: ! 219: private ! 220: void near cur_up() ! 221: { ! 222: if (C_X) ! 223: C_X--; ! 224: gotoxy(C_X, C_Y); ! 225: } ! 226: ! 227: private ! 228: void near cur_left() ! 229: { ! 230: if (C_Y) ! 231: C_Y--; ! 232: gotoxy(C_X, C_Y); ! 233: } ! 234: ! 235: private ! 236: void near cur_down() ! 237: { ! 238: if (C_X < LPP-1) ! 239: C_X++; ! 240: gotoxy(C_X, C_Y); ! 241: } ! 242: ! 243: private ! 244: void near ch_out(c, n) ! 245: BYTE c, n; ! 246: { ! 247: union REGS vr; ! 248: ! 249: vr.h.ah = 0x09; ! 250: vr.h.al = c; ! 251: vr.h.bl = C_ATTR; ! 252: vr.h.bh = CUR_PAGE; ! 253: vr.x.cx = n; ! 254: intr(VIDEO, &vr); ! 255: } ! 256: ! 257: #define wrch(c) ch_out((c), 1), cur_advance() ! 258: ! 259: #define home_cur() gotoxy(C_X = 0, C_Y = 0) ! 260: ! 261: #define clr_eoln() ch_out(' ', CHPL-wherey()) ! 262: ! 263: private ! 264: void near clr_eop() ! 265: { ! 266: clr_eoln(); ! 267: scr_win(LPP-1-wherex(), wherex()+1, 0, LPP-1, CHPL-1); ! 268: } ! 269: ! 270: void init_43() ! 271: { ! 272: BYTE far *info = (BYTE far *) 0x487; ! 273: WORD far *CRTC = (WORD far *) 0x463; ! 274: union REGS vr; ! 275: WORD cur; ! 276: ! 277: CUR_PAGE = cur_page(); ! 278: CHPL = chpl(); ! 279: LPP = lpp(); ! 280: ! 281: if (get_mode()!=3) ! 282: set_mode(3); ! 283: cur = get_cur(); ! 284: ! 285: vr.x.ax = 0x1112; ! 286: vr.h.bl = 0; ! 287: intr(VIDEO, &vr); ! 288: ! 289: *info |= 1; ! 290: vr.x.ax = 0x0100; ! 291: vr.h.bh = 0; ! 292: vr.x.cx = 0x0600; ! 293: intr(VIDEO, &vr); ! 294: ! 295: outp(*CRTC, 0x14); ! 296: outp(*CRTC+1, 0x07); ! 297: ! 298: vr.x.ax = 0x1200; ! 299: vr.h.bl = 0x20; ! 300: intr(VIDEO, &vr); ! 301: ! 302: LPP = lpp(); ! 303: ! 304: set_cur(cur); ! 305: wherexy(&C_X, &C_Y); ! 306: } ! 307: ! 308: void reset_43() ! 309: { ! 310: BYTE far *info = (BYTE far *) 0x487; ! 311: WORD far *CRTC = (WORD far *) 0x463; ! 312: union REGS vr; ! 313: ! 314: set_mode(3); ! 315: ! 316: *info &= 128; ! 317: vr.x.ax = 0x0100; ! 318: vr.h.bh = 0x0607; ! 319: vr.x.cx = 0x0607; ! 320: intr(VIDEO, &vr); ! 321: ! 322: outp(*CRTC, 0x14); ! 323: outp(*CRTC+1, 13); ! 324: ! 325: } ! 326: ! 327: #define scr_up() scr_win(1, 0, 0, LPP-1, CHPL-1) ! 328: #define back_space() cur_left() ! 329: ! 330: private ! 331: void near line_feed() ! 332: { ! 333: if (++C_X > LPP-1) { ! 334: C_X = LPP-1; ! 335: scr_up(); ! 336: } ! 337: gotoxy(C_X, C_Y); ! 338: } ! 339: ! 340: #define BELL_P 0x61 /* speaker */ ! 341: #define BELL_D 0x2dc /* 550 hz */ ! 342: #define TIME_P 0x40 /* timer */ ! 343: #define TINI 182 /* 10110110b timer initialization */ ! 344: ! 345: void dobell(x) ! 346: { ! 347: unsigned int n = 0x8888; ! 348: int orgval; ! 349: ! 350: outp(TIME_P+3, TINI); ! 351: outp(TIME_P+2, BELL_D&0xff); ! 352: outp(TIME_P+2, BELL_D>>8); ! 353: orgval = inp(BELL_P); ! 354: outp(BELL_P, orgval|3); /* turn speaker on */ ! 355: while (--n > 0) ! 356: ; ! 357: outp(BELL_P, orgval); ! 358: } ! 359: ! 360: #define carriage_return() gotoxy(wherex(), C_Y = 0) ! 361: ! 362: private ! 363: void near cur_advance() ! 364: { ! 365: if (++C_Y > CHPL-1) { ! 366: C_Y = 0; ! 367: if (++C_X > LPP-1) { ! 368: scr_up(); ! 369: C_X = LPP-1; ! 370: } ! 371: } ! 372: gotoxy(C_X, C_Y); ! 373: } ! 374: ! 375: void init_term() ! 376: { ! 377: if (lpp() == 43) ! 378: reset_43(); ! 379: CUR_PAGE = cur_page(); ! 380: CHPL = chpl(); ! 381: LPP = lpp(); ! 382: wherexy(&C_X, &C_Y); ! 383: } ! 384: ! 385: private ! 386: void near normfun(); ! 387: ! 388: void write_em(s) ! 389: char *s; ! 390: { ! 391: while (*s) ! 392: normfun(*s++); ! 393: } ! 394: ! 395: void write_emif(s) ! 396: char *s; ! 397: { ! 398: if (s) ! 399: write_em(s); ! 400: } ! 401: ! 402: void write_emc(s, n) ! 403: char *s; ! 404: int n; ! 405: { ! 406: while (n--) ! 407: normfun(*s++); ! 408: } ! 409: ! 410: private ! 411: void near normfun(c) ! 412: char c; ! 413: { ! 414: switch (c) { ! 415: case 10: line_feed(); break; ! 416: case 13: carriage_return(); break; ! 417: case 8: back_space(); break; ! 418: case 7: dobell(0); break; ! 419: case 0: break; ! 420: default: wrch(c); ! 421: } ! 422: } ! 423: ! 424: #endif /* IBMPC */ ! 425: ! 426: ! 427: extern int BufSize; ! 428: ! 429: int AbortCnt, ! 430: tabstop = 8; ! 431: ! 432: #if !(defined(IBMPC) || defined(MAC)) ! 433: int (*TTins_line)(), ! 434: (*TTdel_line)(); ! 435: #endif /* (defined(IBMPC) || defined(MAC)) */ ! 436: ! 437: struct scrimage ! 438: *DesiredScreen = 0, ! 439: *PhysScreen = 0; ! 440: ! 441: struct screenline *Screen = 0, /* the screen (a bunch of screenline) */ ! 442: *Savelines = 0, /* another bunch (LI of them) */ ! 443: *Curline = 0; /* current line */ ! 444: char *cursor, /* offset into current Line */ ! 445: *cursend; ! 446: ! 447: int CapCol, ! 448: CapLine, ! 449: ! 450: i_line, ! 451: i_col; ! 452: ! 453: void ! 454: make_scr() ! 455: { ! 456: register int i; ! 457: register struct screenline *ns; ! 458: register char *nsp; ! 459: ! 460: #ifdef RESHAPING ! 461: /* In case we are RESHAPING the window! */ ! 462: if (DesiredScreen) ! 463: free((char *) DesiredScreen); ! 464: if (PhysScreen) ! 465: free((char *) PhysScreen); ! 466: if (Savelines) ! 467: free((char *) Savelines); ! 468: if (Screen) { ! 469: free(Screen->s_line); /* free all the screen data */ ! 470: free((char *) Screen); ! 471: } ! 472: #endif /* RESHAPING */ ! 473: ! 474: DesiredScreen = (struct scrimage *) malloc((unsigned) LI * sizeof (struct scrimage)); ! 475: PhysScreen = (struct scrimage *) malloc((unsigned) LI * sizeof (struct scrimage)); ! 476: ! 477: Savelines = (struct screenline *) ! 478: malloc((unsigned) LI * sizeof(struct screenline)); ! 479: ns = Screen = (struct screenline *) ! 480: malloc((unsigned) LI * sizeof(struct screenline)); ! 481: ! 482: nsp = (char *) malloc((unsigned)CO * LI); ! 483: if (nsp == 0) { ! 484: printf("\n\rCannot malloc screen!\n"); ! 485: finish(1); ! 486: } ! 487: ! 488: for (i = 0; i < LI; i++) { ! 489: ns->s_line = nsp; ! 490: nsp += CO; ! 491: ns->s_length = nsp - 1; /* End of Line */ ! 492: ns += 1; ! 493: } ! 494: cl_scr(0); ! 495: } ! 496: ! 497: void ! 498: clrline(cp1, cp2) ! 499: register char *cp1, ! 500: *cp2; ! 501: { ! 502: while (cp1 <= cp2) ! 503: *cp1++ = ' '; ! 504: } ! 505: ! 506: #if !(defined(IBMPC) || defined(MAC)) ! 507: # define sputc(c) ((*cursor != (char) (c)) ? dosputc(c) : (cursor++, i_col++)) ! 508: #endif /* (defined(IBMPC) || defined(MAC)) */ ! 509: ! 510: #ifdef IBMPC ! 511: int force = 0; ! 512: # define sputc(c) dosputc(c) ! 513: #endif /* IBMPC */ ! 514: ! 515: #ifdef MAC ! 516: # define sputc(c) bufputc(c) /* line buffered for mac display */ ! 517: #endif /* MAC */ ! 518: ! 519: #define soutputc(c) if (--n <= 0) break; else sputc(c) ! 520: ! 521: void ! 522: cl_eol() ! 523: { ! 524: if (cursor > cursend) ! 525: return; ! 526: ! 527: if (cursor < Curline->s_length) { ! 528: #if !(defined(IBMPC) || defined(MAC)) ! 529: if (CE) { ! 530: #endif /* (defined(IBMPC) || defined(MAC)) */ ! 531: Placur(i_line, i_col); ! 532: #ifdef TERMCAP ! 533: putpad(CE, 1); ! 534: #else ! 535: clr_eoln(); ! 536: #endif /* TERMCAP */ ! 537: clrline(cursor, Curline->s_length); ! 538: #if !(defined(IBMPC) || defined(MAC)) ! 539: } else { ! 540: /* Ugh. The slow way for dumb terminals. */ ! 541: register char *savecp = cursor; ! 542: ! 543: while (cursor <= Curline->s_length) ! 544: sputc(' '); ! 545: cursor = savecp; ! 546: } ! 547: #endif /* (defined(IBMPC) || defined(MAC)) */ ! 548: Curline->s_length = cursor; ! 549: } ! 550: } ! 551: ! 552: void ! 553: cl_scr(doit) ! 554: { ! 555: register int i; ! 556: register struct screenline *sp = Screen; ! 557: ! 558: for (i = 0; i < LI; i++, sp++) { ! 559: clrline(sp->s_line, sp->s_length); ! 560: sp->s_length = sp->s_line; ! 561: PhysScreen[i].s_id = 0; ! 562: } ! 563: if (doit) { ! 564: #ifdef TERMCAP ! 565: putpad(CL, LI); ! 566: #else ! 567: clr_page(); ! 568: #endif /* TERMCAP */ ! 569: CapCol = CapLine = 0; ! 570: UpdMesg = YES; ! 571: } ! 572: } ! 573: ! 574: #ifdef ID_CHAR ! 575: extern int IN_INSmode; ! 576: #endif ! 577: ! 578: /* Output one character (if necessary) at the current position */ ! 579: ! 580: #ifndef MAC ! 581: int /* only for lints sake */ ! 582: dosputc(c) ! 583: register char c; ! 584: { ! 585: #ifndef IBMPC ! 586: if (*cursor != c) { ! 587: # ifdef ID_CHAR ! 588: if (IN_INSmode) ! 589: INSmode(0); ! 590: # endif ! 591: #else /* IBMPC */ ! 592: if ((force) || (*cursor != c)) { ! 593: #endif /* IBMPC */ ! 594: if (i_line != CapLine || i_col != CapCol) ! 595: Placur(i_line, i_col); ! 596: #ifndef IBMPC ! 597: if (UL && (c & CHARMASK) == '_' && (*cursor & CHARMASK) != ' ') ! 598: putstr(" \b"); /* Erase so '_' looks right. */ ! 599: #endif /* IBMPC */ ! 600: *cursor++ = c; ! 601: #ifndef IBMPC ! 602: putchar(c & CHARMASK); ! 603: #else /* IBMPC */ ! 604: normfun(c); ! 605: #endif /* IBMPC */ ! 606: AbortCnt -= 1; ! 607: CapCol += 1; ! 608: i_col += 1; ! 609: } else { ! 610: cursor += 1; ! 611: i_col += 1; ! 612: } ! 613: } ! 614: #else /* MAC */ ! 615: ! 616: /* Character output to bit-mapped screen is very expensive. It makes ! 617: much more sense to write the entire line at once. So, we print all ! 618: the characters, whether already there or not, once the line is ! 619: complete. */ ! 620: ! 621: #define BUFFLUSH (char) 0 ! 622: #define BUFSTART (char) 1 ! 623: ! 624: bufputc(c) ! 625: register char c; ! 626: { ! 627: static char buf[256]; ! 628: static int len = 0; ! 629: ! 630: if(c == BUFSTART) { ! 631: /* if (i_line != CapLine || i_col != CapCol)*/ ! 632: NPlacur(i_line, i_col); ! 633: len = 0; ! 634: return; ! 635: } ! 636: if(c == BUFFLUSH) { ! 637: buf[0] = (unsigned char) len; ! 638: writechr(buf); ! 639: len = 0; ! 640: } ! 641: else { ! 642: if(len > 255) return; ! 643: *cursor++ = c; ! 644: if(c == '0') buf[++len] = 0xAF; /* slashed zero */ ! 645: else buf[++len] = c; ! 646: CapCol++; ! 647: i_col++; ! 648: } ! 649: return; ! 650: } ! 651: #endif /* MAC */ ! 652: ! 653: /* Write `line' at the current position of `cursor'. Stop when we ! 654: reach the end of the screen. Aborts if there is a character ! 655: waiting. */ ! 656: ! 657: #ifdef MAC /* This was getting too complicated with ifdefs ... */ ! 658: int ! 659: swrite(line, inversep, abortable) ! 660: register char *line; ! 661: register int abortable; ! 662: { ! 663: register int c; ! 664: int col = i_col, ! 665: aborted = 0; ! 666: register int n = cursend - cursor; ! 667: ! 668: if (n <= 0) ! 669: return 1; ! 670: sputc(BUFSTART); /* Okay, because no interruption possible */ ! 671: ! 672: while (c = *line++) { ! 673: if (c == '\t') { ! 674: int nchars; ! 675: ! 676: nchars = (tabstop - (col % tabstop)); ! 677: col += nchars; ! 678: ! 679: while (nchars--) ! 680: soutputc(' '); ! 681: if (n <= 0) ! 682: break; ! 683: } else if (isctrl(c)) { ! 684: soutputc('^'); ! 685: c = ((c == '\177') ? '?' : c + '@'); ! 686: soutputc(c); ! 687: col += 2; ! 688: } else { ! 689: soutputc(c); ! 690: col += 1; ! 691: } ! 692: } ! 693: if (n <= 0) { ! 694: if ((*line == '\0') && (c != '\t') && !isctrl(c)) ! 695: sputc(c); ! 696: sputc('!'); ! 697: } ! 698: if (cursor > Curline->s_length) ! 699: Curline->s_length = cursor; ! 700: sputc(BUFFLUSH); ! 701: return !aborted; ! 702: } ! 703: #else /* MAC */ ! 704: ! 705: int ! 706: swrite(line, inversep, abortable) ! 707: register char *line; ! 708: register int abortable; ! 709: { ! 710: register int c; ! 711: int col = i_col, ! 712: aborted = 0; ! 713: register int n = cursend - cursor; ! 714: #ifndef IBMPC ! 715: int or_byte = inversep ? 0200 : 0, ! 716: thebyte; ! 717: #else ! 718: int thebyte; ! 719: #endif /* IBMPC */ ! 720: ! 721: #ifdef IBMPC ! 722: force = inversep? 1: 0; /* to force a redraw of the modeline */ ! 723: #endif /* IBMPC */ ! 724: ! 725: if (n <= 0) ! 726: return 1; ! 727: while (c = *line++) { ! 728: #if !(defined(IBMPC) || defined(MAC)) /* don't check after every character */ ! 729: if (abortable && AbortCnt < 0) { ! 730: AbortCnt = BufSize; ! 731: if (InputPending = charp()) { ! 732: aborted = 1; ! 733: break; ! 734: } ! 735: } ! 736: #endif /* (defined(IBMPC) || defined(MAC)) */ ! 737: if (c == '\t') { ! 738: int nchars; ! 739: ! 740: nchars = (tabstop - (col % tabstop)); ! 741: col += nchars; ! 742: ! 743: #ifndef IBMPC ! 744: thebyte = (' ' | or_byte); ! 745: #endif /* IBMPC */ ! 746: while (nchars--) ! 747: #ifndef IBMPC ! 748: soutputc(thebyte); ! 749: #else /* IBMPC */ ! 750: soutputc(' '); ! 751: #endif /* IBMPC */ ! 752: if (n <= 0) ! 753: break; ! 754: } else if (isctrl(c)) { ! 755: #ifndef IBMPC ! 756: thebyte = ('^' | or_byte); ! 757: soutputc(thebyte); ! 758: thebyte = (((c == '\177') ? '?' : c + '@') | or_byte); ! 759: soutputc(thebyte); ! 760: #else /* IBMPC */ ! 761: soutputc('^'); ! 762: c = ((c == '\177') ? '?' : c + '@'); ! 763: soutputc(c); ! 764: #endif /* IBMPC */ ! 765: col += 2; ! 766: } else { ! 767: #ifndef IBMPC ! 768: thebyte = (c | or_byte); ! 769: soutputc(thebyte); ! 770: #else /* IBMPC */ ! 771: if (c == 255) c = 1; ! 772: if (c == ' ' && inversep) c = 255; ! 773: soutputc(c); ! 774: #endif /* IBMPC */ ! 775: col += 1; ! 776: } ! 777: } ! 778: if (n <= 0) { ! 779: if ((*line == '\0') && (c != '\t') && !isctrl(c)) ! 780: #ifndef IBMPC ! 781: sputc(c|or_byte); ! 782: #else /* IBMPC */ ! 783: sputc(c); ! 784: #endif /* IBMPC */ ! 785: else ! 786: #ifndef IBMPC ! 787: sputc('!'|or_byte); ! 788: #else /* IBMPC */ ! 789: sputc('!'); ! 790: #endif /* IBMPC */ ! 791: } ! 792: if (cursor > Curline->s_length) ! 793: Curline->s_length = cursor; ! 794: #ifdef IBMPC ! 795: force = 0; ! 796: #endif ! 797: return !aborted; ! 798: } ! 799: #endif /* MAC */ ! 800: /* This is for writing a buffer line to the screen. This is to ! 801: minimize the amount of copying from one buffer to another buffer. ! 802: This gets the info directly from the disk buffers. */ ! 803: ! 804: int ! 805: BufSwrite(linenum) ! 806: { ! 807: register int n = cursend - cursor, ! 808: col = 0, ! 809: c = -1; ! 810: register char *bp; ! 811: int StartCol = DesiredScreen[linenum].s_offset, ! 812: visspace = DesiredScreen[linenum].s_window->w_flags & W_VISSPACE, ! 813: aborted = 0; ! 814: ! 815: bp = lcontents(DesiredScreen[linenum].s_lp); ! 816: if (*bp) for (;;) { ! 817: if (col >= StartCol) { ! 818: DesiredScreen[linenum].s_offset = col; ! 819: break; ! 820: } ! 821: ! 822: c = *bp++ & CHARMASK; ! 823: if (c == '\0') ! 824: break; ! 825: if (c == '\t') ! 826: col += (tabstop - (col % tabstop)); ! 827: else if (isctrl(c)) ! 828: col += 2; ! 829: else ! 830: col += 1; ! 831: } ! 832: #ifdef MAC ! 833: sputc(BUFSTART); /* Okay because we can't be interrupted */ ! 834: #endif ! 835: ! 836: if (c != '\0') while (c = *bp++) { ! 837: #if !(defined(IBMPC) || defined(MAC)) /* will never get true so why bother */ ! 838: if (AbortCnt < 0) { ! 839: AbortCnt = BufSize; ! 840: if (InputPending = charp()) { ! 841: aborted = 1; ! 842: break; ! 843: } ! 844: } ! 845: #endif /* (defined(IBMPC) || defined(MAC)) */ ! 846: if (c == '\t') { ! 847: int nchars = (tabstop - (col % tabstop)); ! 848: ! 849: col += nchars; ! 850: if (visspace) { ! 851: soutputc('>'); ! 852: nchars -= 1; ! 853: } ! 854: while (--nchars >= 0) ! 855: soutputc(' '); ! 856: if (n <= 0) ! 857: break; ! 858: } else if (isctrl(c)) { ! 859: soutputc('^'); ! 860: soutputc((c == '\177') ? '?' : c + '@'); ! 861: col += 2; ! 862: } else { ! 863: if (c == ' ' && visspace) ! 864: c = '_'; ! 865: #ifdef IBMPC ! 866: if (c == 255) ! 867: c = 1; ! 868: #endif /* IBMPC */ ! 869: soutputc(c); ! 870: col += 1; ! 871: } ! 872: } ! 873: if (n <= 0) { ! 874: if ((*bp == '\0') && (c != '\t') && !isctrl(c)) ! 875: sputc(c); ! 876: else ! 877: sputc('!'); ! 878: } ! 879: if (cursor > Curline->s_length) ! 880: Curline->s_length = cursor; ! 881: #ifdef MAC ! 882: sputc(BUFFLUSH); ! 883: #endif ! 884: return !aborted; /* Didn't abort */ ! 885: } ! 886: ! 887: void ! 888: i_set(nline, ncol) ! 889: register int nline, ! 890: ncol; ! 891: { ! 892: Curline = &Screen[nline]; ! 893: cursor = Curline->s_line + ncol; ! 894: cursend = &Curline->s_line[CO - 1]; ! 895: i_line = nline; ! 896: i_col = ncol; ! 897: } ! 898: ! 899: /* Insert `num' lines a top, but leave all the lines BELOW `bottom' ! 900: alone (at least they won't look any different when we are done). ! 901: This changes the screen array AND does the physical changes. */ ! 902: ! 903: void ! 904: v_ins_line(num, top, bottom) ! 905: { ! 906: register int i; ! 907: ! 908: /* Save the screen pointers. */ ! 909: ! 910: for(i = 0; i < num && top + i <= bottom; i++) ! 911: Savelines[i] = Screen[bottom - i]; ! 912: ! 913: /* Num number of bottom lines will be lost. ! 914: Copy everything down num number of times. */ ! 915: ! 916: for (i = bottom; i > top && i-num >= 0; i--) ! 917: Screen[i] = Screen[i - num]; ! 918: ! 919: /* Restore the saved ones, making them blank. */ ! 920: ! 921: for (i = 0; i < num; i++) { ! 922: Screen[top + i] = Savelines[i]; ! 923: clrline(Screen[top + i].s_line, Screen[top + i].s_length); ! 924: Screen[top + i].s_length = Screen[top + i].s_line; ! 925: } ! 926: ! 927: #if !(defined(IBMPC) || defined(MAC)) ! 928: (*TTins_line)(top, bottom, num); ! 929: #endif ! 930: ! 931: #ifdef MAC ! 932: i_lines(top, bottom, num); ! 933: #endif ! 934: ! 935: #ifdef IBMPC ! 936: scr_win(-num, top, 0, bottom, CHPL-1); ! 937: #endif ! 938: } ! 939: ! 940: /* Delete `num' lines starting at `top' leaving the lines below `bottom' ! 941: alone. This updates the internal image as well as the physical image. */ ! 942: ! 943: void ! 944: v_del_line(num, top, bottom) ! 945: { ! 946: register int i, ! 947: bot; ! 948: ! 949: bot = bottom; ! 950: ! 951: /* Save the lost lines. */ ! 952: ! 953: for (i = 0; i < num && top + i <= bottom; i++) ! 954: Savelines[i] = Screen[top + i]; ! 955: ! 956: /* Copy everything up num number of lines. */ ! 957: ! 958: for (i = top; num + i <= bottom; i++) ! 959: Screen[i] = Screen[i + num]; ! 960: ! 961: /* Restore the lost ones, clearing them. */ ! 962: ! 963: for (i = 0; i < num; i++) { ! 964: Screen[bottom - i] = Savelines[i]; ! 965: clrline(Screen[bot].s_line, Screen[bot].s_length); ! 966: Screen[bot].s_length = Screen[bot].s_line; ! 967: bot -= 1; ! 968: } ! 969: ! 970: #if !(defined(IBMPC) || defined(MAC)) ! 971: (*TTdel_line)(top, bottom, num); ! 972: #endif ! 973: ! 974: #ifdef MAC ! 975: d_lines(top, bottom, num); ! 976: #endif ! 977: ! 978: #ifdef IBMPC ! 979: scr_win(num, top, 0, bottom, CHPL-1); ! 980: #endif ! 981: ! 982: } ! 983: ! 984: #ifndef MAC /* remainder of this file */ ! 985: #ifdef IBMPC ! 986: ! 987: /* No cursor optimization on an IBMPC, this simplifies things a lot. ! 988: Think about it: it would be silly! ! 989: */ ! 990: ! 991: int phystab = 8; ! 992: ! 993: void ! 994: Placur(line, col) ! 995: { ! 996: cur_mov(line, col); ! 997: CapCol = col; ! 998: CapLine = line; ! 999: } ! 1000: ! 1001: void ! 1002: SO_on() ! 1003: { ! 1004: if (Mdcolor) ! 1005: setcolor(Mdcolor&0xf, Mdcolor>>4); ! 1006: else ! 1007: setcolor(Bgcolor, Fgcolor); ! 1008: } ! 1009: ! 1010: void ! 1011: SO_off() ! 1012: { ! 1013: setcolor(Fgcolor, Bgcolor); ! 1014: } ! 1015: ! 1016: extern int EGA; ! 1017: ! 1018: void ! 1019: ! 1020: UnsetTerm(foo) ! 1021: char *foo; ! 1022: { ! 1023: Placur(ILI, 0); ! 1024: clr_eoln(); ! 1025: if (EGA) ! 1026: reset_43(); ! 1027: } ! 1028: ! 1029: ! 1030: void ! 1031: ResetTerm() ! 1032: { ! 1033: if (EGA) ! 1034: init_43(); ! 1035: else ! 1036: init_term(); ! 1037: ! 1038: do_sgtty(); /* this is so if you change baudrate or stuff ! 1039: like that, JOVE will notice. */ ! 1040: ttyset(ON); ! 1041: } ! 1042: ! 1043: #else /* IBMPC */ ! 1044: ! 1045: /* The cursor optimization happens here. You may decide that this ! 1046: is going too far with cursor optimization, or perhaps it should ! 1047: limit the amount of checking to when the output speed is slow. ! 1048: What ever turns you on ... */ ! 1049: ! 1050: private struct cursaddr { ! 1051: int cm_numchars, ! 1052: (*cm_proc)(); ! 1053: }; ! 1054: ! 1055: private char *Cmstr; ! 1056: private struct cursaddr *HorMin, ! 1057: *VertMin, ! 1058: *DirectMin; ! 1059: ! 1060: private void ! 1061: GENi_lines(), ! 1062: GENd_lines(), ! 1063: ForMotion(), ! 1064: ForTab(), ! 1065: BackMotion(), ! 1066: RetTab(), ! 1067: DownMotion(), ! 1068: UpMotion(), ! 1069: GoDirect(), ! 1070: HomeGo(), ! 1071: BottomUp(); ! 1072: ! 1073: ! 1074: private struct cursaddr WarpHor[] = { ! 1075: 0, ForMotion, ! 1076: 0, ForTab, ! 1077: 0, BackMotion, ! 1078: 0, RetTab ! 1079: }; ! 1080: ! 1081: private struct cursaddr WarpVert[] = { ! 1082: 0, DownMotion, ! 1083: 0, UpMotion ! 1084: }; ! 1085: ! 1086: private struct cursaddr WarpDirect[] = { ! 1087: 0, GoDirect, ! 1088: 0, HomeGo, ! 1089: 0, BottomUp ! 1090: }; ! 1091: ! 1092: #undef FORWARD ! 1093: #define FORWARD 0 /* Move forward */ ! 1094: #define FORTAB 1 /* Forward using tabs */ ! 1095: #undef BACKWARD ! 1096: #define BACKWARD 2 /* Move backward */ ! 1097: #define RETFORWARD 3 /* Beginning of line and then tabs */ ! 1098: #define NUMHOR 4 ! 1099: ! 1100: #define DOWN 0 /* Move down */ ! 1101: #define UPMOVE 1 /* Move up */ ! 1102: #define NUMVERT 2 ! 1103: ! 1104: #define DIRECT 0 /* Using CM */ ! 1105: #define HOME 1 /* HOME */ ! 1106: #define LOWER 2 /* Lower Line */ ! 1107: #define NUMDIRECT 3 ! 1108: ! 1109: #define home() Placur(0, 0) ! 1110: #define LowLine() putpad(LL, 1), CapLine = ILI, CapCol = 0 ! 1111: #define PrintHo() putpad(HO, 1), CapLine = CapCol = 0 ! 1112: ! 1113: int phystab = 8; ! 1114: ! 1115: private void ! 1116: GoDirect(line, col) ! 1117: register int line, ! 1118: col; ! 1119: { ! 1120: putpad(Cmstr, 1); ! 1121: CapLine = line; ! 1122: CapCol = col; ! 1123: } ! 1124: ! 1125: private void ! 1126: RetTab(col) ! 1127: register int col; ! 1128: { ! 1129: putchar('\r'); ! 1130: CapCol = 0; ! 1131: ForTab(col); ! 1132: } ! 1133: ! 1134: private void ! 1135: HomeGo(line, col) ! 1136: { ! 1137: PrintHo(); ! 1138: DownMotion(line); ! 1139: ForTab(col); ! 1140: } ! 1141: ! 1142: private void ! 1143: BottomUp(line, col) ! 1144: register int line, ! 1145: col; ! 1146: { ! 1147: LowLine(); ! 1148: UpMotion(line); ! 1149: ForTab(col); ! 1150: } ! 1151: ! 1152: /* Tries to move forward using tabs (if possible). It tabs to the ! 1153: closest tabstop which means it may go past 'destcol' and backspace ! 1154: to it. */ ! 1155: ! 1156: private void ! 1157: ForTab(destcol) ! 1158: int destcol; ! 1159: { ! 1160: register int tabgoal, ! 1161: ntabs, ! 1162: tabstp = phystab; ! 1163: ! 1164: if (TABS && (tabstp > 0)) { ! 1165: tabgoal = destcol + (tabstp / 2); ! 1166: tabgoal -= (tabgoal % tabstp); ! 1167: ! 1168: /* Don't tab to last place or else it is likely to screw up. */ ! 1169: if (tabgoal >= CO) ! 1170: tabgoal -= tabstp; ! 1171: ! 1172: ntabs = (tabgoal / tabstp) - (CapCol / tabstp); ! 1173: while (--ntabs >= 0) ! 1174: putchar('\t'); ! 1175: CapCol = tabgoal; ! 1176: } ! 1177: if (CapCol > destcol) ! 1178: BackMotion(destcol); ! 1179: else if (CapCol < destcol) ! 1180: ForMotion(destcol); ! 1181: } ! 1182: ! 1183: private void ! 1184: ForMotion(destcol) ! 1185: register int destcol; ! 1186: { ! 1187: register int nchars = destcol - CapCol; ! 1188: register char *cp = &Screen[CapLine].s_line[CapCol]; ! 1189: ! 1190: while (--nchars >= 0) ! 1191: putchar(*cp++ & CHARMASK); ! 1192: CapCol = destcol; ! 1193: } ! 1194: ! 1195: private void ! 1196: BackMotion(destcol) ! 1197: register int destcol; ! 1198: { ! 1199: register int nchars = CapCol - destcol; ! 1200: ! 1201: if (BC) ! 1202: while (--nchars >= 0) ! 1203: putpad(BC, 1); ! 1204: else ! 1205: while (--nchars >= 0) ! 1206: putchar('\b'); ! 1207: CapCol = destcol; ! 1208: } ! 1209: ! 1210: private void ! 1211: DownMotion(destline) ! 1212: register int destline; ! 1213: { ! 1214: register int nlines = destline - CapLine; ! 1215: ! 1216: while (--nlines >= 0) ! 1217: putpad(NL, 1); ! 1218: CapLine = destline; ! 1219: } ! 1220: ! 1221: private void ! 1222: UpMotion(destline) ! 1223: register int destline; ! 1224: { ! 1225: register int nchars = CapLine - destline; ! 1226: ! 1227: while (--nchars >= 0) ! 1228: putpad(UP, 1); ! 1229: CapLine = destline; ! 1230: } ! 1231: ! 1232: #ifdef ID_CHAR ! 1233: static int EIlen; ! 1234: #endif ! 1235: extern int IMlen; ! 1236: ! 1237: void ! 1238: InitCM() ! 1239: { ! 1240: HOlen = HO ? strlen(HO) : 1000; ! 1241: LLlen = LL ? strlen(LL) : 1000; ! 1242: UPlen = UP ? strlen(UP) : 1000; ! 1243: #ifdef ID_CHAR ! 1244: if (EI) ! 1245: EIlen = strlen(EI); ! 1246: #endif ! 1247: } ! 1248: ! 1249: void ! 1250: Placur(line, col) ! 1251: { ! 1252: int dline, /* Number of lines to move */ ! 1253: dcol; /* Number of columns to move */ ! 1254: register int best, ! 1255: i; ! 1256: register struct cursaddr *cp; ! 1257: int xtracost = 0; /* Misc addition to cost. */ ! 1258: ! 1259: #define CursMin(which,addrs,max) \ ! 1260: for (best = 0, cp = &addrs[1], i = 1; i < max; i++, cp++) \ ! 1261: if (cp->cm_numchars < addrs[best].cm_numchars) \ ! 1262: best = i; \ ! 1263: which = &addrs[best]; ! 1264: ! 1265: if (line == CapLine && col == CapCol) ! 1266: return; /* We are already there. */ ! 1267: ! 1268: dline = line - CapLine; ! 1269: dcol = col - CapCol; ! 1270: #ifdef ID_CHAR ! 1271: if (IN_INSmode && MI) ! 1272: xtracost = EIlen + IMlen; ! 1273: /* If we're already in insert mode, it is likely that we will ! 1274: want to be in insert mode again, after the insert. */ ! 1275: #endif ! 1276: ! 1277: /* Number of characters to move horizontally for each case. ! 1278: 1: Just move forward by typing the right character on the screen. ! 1279: 2: Print the correct number of back spaces. ! 1280: 3: Try tabbing to the correct place. ! 1281: 4: Try going to the beginning of the line, and then tab. */ ! 1282: ! 1283: if (dcol == 1 || dcol == 0) { /* Most common case. */ ! 1284: HorMin = &WarpHor[FORWARD]; ! 1285: HorMin->cm_numchars = dcol + xtracost; ! 1286: } else { ! 1287: WarpHor[FORWARD].cm_numchars = dcol >= 0 ? dcol + xtracost : 1000; ! 1288: WarpHor[BACKWARD].cm_numchars = dcol < 0 ? -(dcol + xtracost) : 1000; ! 1289: WarpHor[FORTAB].cm_numchars = dcol >= 0 && TABS ? ! 1290: ForNum(CapCol, col) + xtracost : 1000; ! 1291: WarpHor[RETFORWARD].cm_numchars = (xtracost + 1 + (TABS ? ForNum(0, col) : col)); ! 1292: ! 1293: /* Which is the shortest of the bunch */ ! 1294: ! 1295: CursMin(HorMin, WarpHor, NUMHOR); ! 1296: } ! 1297: ! 1298: /* Moving vertically is more simple. */ ! 1299: ! 1300: WarpVert[DOWN].cm_numchars = dline >= 0 ? dline : 1000; ! 1301: WarpVert[UPMOVE].cm_numchars = dline < 0 ? ((-dline) * UPlen) : 1000; ! 1302: ! 1303: /* Which of these is simpler */ ! 1304: CursMin(VertMin, WarpVert, NUMVERT); ! 1305: ! 1306: /* Homing first and lowering first are considered ! 1307: direct motions. ! 1308: Homing first's total is the sum of the cost of homing ! 1309: and the sum of tabbing (if possible) to the right. */ ! 1310: ! 1311: if (VertMin->cm_numchars + HorMin->cm_numchars <= 3) { ! 1312: DirectMin = &WarpDirect[DIRECT]; /* A dummy ... */ ! 1313: DirectMin->cm_numchars = 100; ! 1314: } else { ! 1315: WarpDirect[DIRECT].cm_numchars = CM ? ! 1316: strlen(Cmstr = tgoto(CM, col, line)) : 1000; ! 1317: WarpDirect[HOME].cm_numchars = HOlen + line + ! 1318: WarpHor[RETFORWARD].cm_numchars; ! 1319: WarpDirect[LOWER].cm_numchars = LLlen + ((ILI - line) * UPlen) + ! 1320: WarpHor[RETFORWARD].cm_numchars; ! 1321: CursMin(DirectMin, WarpDirect, NUMDIRECT); ! 1322: } ! 1323: ! 1324: if (HorMin->cm_numchars + VertMin->cm_numchars < DirectMin->cm_numchars) { ! 1325: if (line != CapLine) ! 1326: (*VertMin->cm_proc)(line); ! 1327: if (col != CapCol) { ! 1328: #ifdef ID_CHAR ! 1329: if (IN_INSmode) /* We may use real characters ... */ ! 1330: INSmode(0); ! 1331: #endif ! 1332: (*HorMin->cm_proc)(col); ! 1333: } ! 1334: } else { ! 1335: #ifdef ID_CHAR ! 1336: if (IN_INSmode && !MI) ! 1337: INSmode(0); ! 1338: #endif ! 1339: (*DirectMin->cm_proc)(line, col); ! 1340: } ! 1341: } ! 1342: ! 1343: #define abs(x) ((x) >= 0 ? (x) : -(x)) ! 1344: ! 1345: int ! 1346: ForNum(from, to) ! 1347: register int from; ! 1348: { ! 1349: register int tabgoal, ! 1350: tabstp = phystab; ! 1351: int numchars = 0; ! 1352: ! 1353: if (from >= to) ! 1354: return from - to; ! 1355: if (TABS && (tabstp > 0)) { ! 1356: tabgoal = to + (tabstp / 2); ! 1357: tabgoal -= (tabgoal % tabstp); ! 1358: if (tabgoal >= CO) ! 1359: tabgoal -= tabstp; ! 1360: numchars = (tabgoal / tabstop) - (from / tabstp); ! 1361: from = tabgoal; ! 1362: } ! 1363: return numchars + abs(from - to); ! 1364: } ! 1365: ! 1366: #ifdef WIRED_TERMS ! 1367: ! 1368: void ! 1369: BGi_lines(top, bottom, num) ! 1370: { ! 1371: printf("\033[%d;%dr\033[%dL\033[r", top + 1, bottom + 1, num); ! 1372: CapCol = CapLine = 0; ! 1373: } ! 1374: ! 1375: void ! 1376: SUNi_lines(top, bottom, num) ! 1377: { ! 1378: Placur(bottom - num + 1, 0); ! 1379: printf("\033[%dM", num); ! 1380: Placur(top, 0); ! 1381: printf("\033[%dL", num); ! 1382: } ! 1383: ! 1384: void ! 1385: C100i_lines(top, bottom, num) ! 1386: { ! 1387: if (num <= 1) { ! 1388: GENi_lines(top, bottom, num); ! 1389: return; ! 1390: } ! 1391: printf("\033v%c%c%c%c", ' ', ' ', ' ' + bottom + 1, ' ' + CO); ! 1392: CapLine = CapCol = 0; ! 1393: Placur(top, 0); ! 1394: while (num--) ! 1395: putpad(AL, ILI - CapLine); ! 1396: printf("\033v%c%c%c%c", ' ', ' ', ' ' + LI, ' ' + CO); ! 1397: CapLine = CapCol = 0; ! 1398: } ! 1399: ! 1400: #endif /* WIRED_TERMS */ ! 1401: ! 1402: private void ! 1403: GENi_lines(top, bottom, num) ! 1404: { ! 1405: register int i; ! 1406: ! 1407: if (CS) { ! 1408: putpad(tgoto(CS, bottom, top), 1); ! 1409: CapCol = CapLine = 0; ! 1410: Placur(top, 0); ! 1411: for (i = 0; i < num; i++) ! 1412: putpad(SR, bottom - top); ! 1413: putpad(tgoto(CS, ILI, 0), 1); ! 1414: CapCol = CapLine = 0; ! 1415: } else { ! 1416: Placur(bottom - num + 1, 0); ! 1417: if (M_DL && (num > 1)) { ! 1418: char minibuf[16]; ! 1419: ! 1420: sprintf(minibuf, M_DL, num); ! 1421: putpad(minibuf, ILI - CapLine); ! 1422: } else { ! 1423: for (i = 0; i < num; i++) ! 1424: putpad(DL, ILI - CapLine); ! 1425: } ! 1426: Placur(top, 0); ! 1427: if (M_AL && (num > 1)) { ! 1428: char minibuf[16]; ! 1429: ! 1430: sprintf(minibuf, M_AL, num); ! 1431: putpad(minibuf, ILI - CapLine); ! 1432: } else { ! 1433: for (i = 0; i < num; i++) ! 1434: putpad(AL, ILI - CapLine); ! 1435: } ! 1436: } ! 1437: } ! 1438: ! 1439: #ifdef WIRED_TERMS ! 1440: ! 1441: void ! 1442: BGd_lines(top, bottom, num) ! 1443: { ! 1444: printf("\033[%d;%dr\033[%dM\033[r", top + 1, bottom + 1, num); ! 1445: CapCol = CapLine = 0; ! 1446: } ! 1447: ! 1448: void ! 1449: SUNd_lines(top, bottom, num) ! 1450: { ! 1451: Placur(top, 0); ! 1452: printf("\033[%dM", num); ! 1453: Placur(bottom + 1 - num, 0); ! 1454: printf("\033[%dL", num); ! 1455: } ! 1456: ! 1457: void ! 1458: C100d_lines(top, bottom, num) ! 1459: { ! 1460: if (num <= 1) { ! 1461: GENd_lines(top, bottom, num); ! 1462: return; ! 1463: } ! 1464: printf("\033v%c%c%c%c", ' ', ' ', ' ' + bottom + 1, ' ' + CO); ! 1465: CapLine = CapCol = 0; ! 1466: Placur(top, 0); ! 1467: while (num--) ! 1468: putpad(DL, ILI - CapLine); ! 1469: printf("\033v%c%c%c%c", ' ', ' ', ' ' + LI, ' ' + CO); ! 1470: CapLine = CapCol = 0; ! 1471: } ! 1472: ! 1473: #endif /* WIRED_TERMS */ ! 1474: ! 1475: private void ! 1476: GENd_lines(top, bottom, num) ! 1477: { ! 1478: register int i; ! 1479: ! 1480: if (CS) { ! 1481: putpad(tgoto(CS, bottom, top), 1); ! 1482: CapCol = CapLine = 0; ! 1483: Placur(bottom, 0); ! 1484: for (i = 0; i < num; i++) ! 1485: putpad(SF, bottom - top); ! 1486: putpad(tgoto(CS, ILI, 0), 1); ! 1487: CapCol = CapLine = 0; ! 1488: } else { ! 1489: Placur(top, 0); ! 1490: if (M_DL && (num > 1)) { ! 1491: char minibuf[16]; ! 1492: ! 1493: sprintf(minibuf, M_DL, num); ! 1494: putpad(minibuf, ILI - top); ! 1495: } else { ! 1496: for (i = 0; i < num; i++) ! 1497: putpad(DL, ILI - top); ! 1498: } ! 1499: Placur(bottom + 1 - num, 0); ! 1500: if (M_AL && (num > 1)) { ! 1501: char minibuf[16]; ! 1502: ! 1503: sprintf(minibuf, M_AL, num); ! 1504: putpad(minibuf, ILI - CapLine); ! 1505: } else { ! 1506: for (i = 0; i < num; i++) ! 1507: putpad(AL, ILI - CapLine); ! 1508: } ! 1509: } ! 1510: } ! 1511: ! 1512: struct ID_lookup { ! 1513: char *ID_name; ! 1514: int (*I_proc)(); /* proc to insert lines */ ! 1515: int (*D_proc)(); /* proc to delete lines */ ! 1516: } ID_trms[] = { ! 1517: "generic", GENi_lines, GENd_lines, /* This should stay here */ ! 1518: #ifdef WIRED_TERMS ! 1519: "sun", SUNi_lines, SUNd_lines, ! 1520: "bg", BGi_lines, BGd_lines, ! 1521: "c1", C100i_lines, C100d_lines, ! 1522: #endif /* WIRED_TERMS */ ! 1523: 0, 0, 0 ! 1524: }; ! 1525: ! 1526: void ! 1527: IDline_setup(tname) ! 1528: char *tname; ! 1529: { ! 1530: register struct ID_lookup *idp; ! 1531: ! 1532: for (idp = &ID_trms[1]; idp->ID_name; idp++) ! 1533: if (strncmp(idp->ID_name, tname, strlen(idp->ID_name)) == 0) ! 1534: break; ! 1535: if (idp->ID_name == 0) ! 1536: idp = &ID_trms[0]; ! 1537: TTins_line = idp->I_proc; ! 1538: TTdel_line = idp->D_proc; ! 1539: } ! 1540: ! 1541: #endif /* IBMPC */ ! 1542: #endif /* MAC */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.