![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to charproc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / X / xterm|
Return to charproc.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / xterm |
1.1 ! root 1: #include <X/mit-copyright.h> ! 2: ! 3: /* Copyright (c) 1985 Massachusetts Institute of Technology */ ! 4: /* Copyright (c) 1985 Digital Equipment Corporation */ ! 5: ! 6: /* charproc.c */ ! 7: ! 8: #include <X/Xlib.h> ! 9: #include "ptyx.h" ! 10: #include <stdio.h> ! 11: #include <sgtty.h> ! 12: #include "chartable.h" ! 13: #include "esctable.h" ! 14: ! 15: #ifndef lint ! 16: static char *rcsid_charproc_c = "$Header: charproc.c,v 10.10 86/02/01 16:05:52 tony Rel $"; ! 17: #endif lint ! 18: ! 19: /* CAUTION: getb "knows" that the variable "c" is receiving the result */ ! 20: ! 21: #define getb(buf) (--buf_cnt >= 0 ? *buf_ptr++: \ ! 22: ((c=fill(buf)), buf_cnt=buf->cnt, buf_ptr=buf->ptr, c)) ! 23: ! 24: #define peekb(buf) (buf_cnt > 0 ? *buf_ptr : -1) ! 25: ! 26: #define ANSIflush() { arg = flushbuf(screen, term->flags, text_ptr); \ ! 27: buffermode = 0; \ ! 28: text_ptr = text_buf; \ ! 29: text_cnt = TEXT_BUF_SIZE; } ! 30: ! 31: #define TEKflush() { arg = TekFlushBuf(term, text_ptr); \ ! 32: buffermode = 0; \ ! 33: text_ptr = text_buf; \ ! 34: text_cnt = TEXT_BUF_SIZE; \ ! 35: } ! 36: ! 37: #define TEXT_BUF_SIZE 256 ! 38: ! 39: extern TekLink *tb_end_link; ! 40: extern int tb_end; ! 41: ! 42: unsigned char text_buf[TEXT_BUF_SIZE]; ! 43: ! 44: unsigned nri = 0; ! 45: unsigned nlf = 0; ! 46: unsigned ctotal = 0; ! 47: unsigned ntotal = 0; ! 48: ! 49: /* ! 50: * in normal mode, buffer up as large a string of printing characters ! 51: * as possible before flushing the buffer. buffer up LF's and RI's ! 52: * so these can be processed as a block. ! 53: */ ! 54: ANSInormal(term) ! 55: Terminal *term; ! 56: { ! 57: register int c; ! 58: register unsigned char *text_ptr; ! 59: register int text_cnt; ! 60: register unsigned char *buf_ptr; ! 61: register int buf_cnt; ! 62: register unsigned buffermode; ! 63: register Screen *screen = &term->screen; ! 64: register Buffer *trmbuf = &term->buf; ! 65: int arg; ! 66: ! 67: buffermode = 0; ! 68: arg = 0; ! 69: c = 0; ! 70: text_ptr = text_buf; ! 71: text_cnt = TEXT_BUF_SIZE; ! 72: buf_cnt = trmbuf->cnt; ! 73: buf_ptr = trmbuf->ptr; ! 74: ! 75: if (screen->TekGMode || screen->TekAMode) ! 76: return (TekMode(term)); ! 77: ! 78: for (;;) { ! 79: /* ! 80: * if special condition has occurred, c will already ! 81: * be set to EOF. otherwise, pick up a new char. ! 82: */ ! 83: if (c >= 0) ! 84: c = getb(trmbuf); ! 85: ! 86: if (ctable[c] == CPRINTING) { ! 87: buffermode = BUFFER_MODE; ! 88: if (--text_cnt >= 0) ! 89: *text_ptr++ = c; ! 90: else { ! 91: ANSIflush(); ! 92: --text_cnt, *text_ptr++ = c; ! 93: if (arg) ! 94: c = EOF; ! 95: } ! 96: continue; ! 97: ! 98: } ! 99: ! 100: switch (ctable[c]) { ! 101: case CIGNORE: ! 102: break; ! 103: ! 104: ! 105: case CLINEFEED: ! 106: if (buffermode || nri) { ! 107: ANSIflush(); ! 108: if (arg) ! 109: c = EOF; ! 110: } ! 111: ++nlf; ! 112: break; ! 113: ! 114: case CRETURN: ! 115: if (buffermode) { ! 116: ANSIflush(); ! 117: if (arg) ! 118: c = EOF; ! 119: } ! 120: screen->cur_col = 0; ! 121: screen->do_wrap = 0; ! 122: break; ! 123: ! 124: case CRI: ! 125: RI_kluge: if (buffermode || nlf) { ! 126: ANSIflush(); ! 127: if (arg) ! 128: c = EOF; ! 129: } ! 130: ++nri; ! 131: break; ! 132: ! 133: case FLUSH: ! 134: ANSIflush(); ! 135: trmbuf->cnt = buf_cnt; ! 136: trmbuf->ptr = buf_ptr; ! 137: return (arg); ! 138: ! 139: case CESC: ! 140: /* try to intercept RI's so we can buffer them */ ! 141: if (peekb(trmbuf) == 'M') { ! 142: c = getb(trmbuf); ! 143: goto RI_kluge; ! 144: } ! 145: /* no RI detected; fall into default case */ ! 146: ! 147: default: ! 148: ANSIflush(); ! 149: docontrol(term, c); ! 150: ! 151: /* ! 152: * if mode changes or event occurs, force a ! 153: * cleanup and return by setting char to EOF ! 154: */ ! 155: if (arg ! 156: || screen->mode!=ANSInormal ! 157: || screen->TekGMode ! 158: || screen->TekAMode) ! 159: c = EOF; ! 160: } ! 161: } ! 162: } ! 163: ! 164: /* ! 165: * flush the buffer of printing characters. first, process any LF's or ! 166: * RI's that have been buffered. ! 167: */ ! 168: flushbuf(screen, flags, text_ptr) ! 169: register Screen *screen; ! 170: unsigned flags; ! 171: register unsigned char *text_ptr; ! 172: { ! 173: register unsigned char *s; ! 174: register unsigned char *p; ! 175: int arg = 0; ! 176: ! 177: if (nri != 0) { ! 178: ioctl(screen->display->fd, FIONREAD, &arg); ! 179: RevIndex(screen, nri); ! 180: nri = 0; ! 181: } ! 182: if (nlf != 0) { ! 183: ioctl(screen->display->fd, FIONREAD, &arg); ! 184: Index(screen, nlf); ! 185: if (flags & LINEFEED) { /* do a carriage return */ ! 186: screen->cur_col = 0; ! 187: screen->do_wrap = 0; ! 188: } ! 189: nlf = 0; ! 190: } ! 191: ! 192: s = text_buf; ! 193: /* ! 194: * if a single shift is in effect, process ! 195: * the one character it affects. ! 196: */ ! 197: if (screen->curss!=0 && s<text_ptr) { ! 198: dotext(screen, flags, screen->gsets[screen->curss], s, s+1); ! 199: ++s; ! 200: screen->curss = 0; ! 201: } ! 202: ! 203: /* ! 204: * characters with and without the high bit set must be processed ! 205: * separately (they select different character sets). collect them ! 206: * into groups before processing for as much efficiency as possible. ! 207: */ ! 208: while (s < text_ptr) { ! 209: p = s; ! 210: if (*s < 0x80) { ! 211: /* character doesn't have high bit set */ ! 212: while (*s<0x80 && s<text_ptr) ! 213: ++s; ! 214: dotext(screen, flags, ! 215: screen->gsets[screen->curgl], p, s); ! 216: } ! 217: else { /* character has high bit set */ ! 218: while (*s>=0x80 && s<text_ptr) { ! 219: *s &= 0x7f; ! 220: ++s; ! 221: } ! 222: dotext(screen, flags, ! 223: screen->gsets[screen->curgr], p, s); ! 224: } ! 225: } ! 226: ! 227: return (arg || screen->display->qlen!=0); ! 228: } ! 229: ! 230: /* ! 231: * process a string of characters according to the character set indicated ! 232: * by charset. worry about end of line conditions (wraparound if selected). ! 233: */ ! 234: dotext(screen, flags, charset, buf, ptr) ! 235: register Screen *screen; ! 236: unsigned flags; ! 237: char charset; ! 238: unsigned char *buf; ! 239: unsigned char *ptr; ! 240: { ! 241: register unsigned char *s; ! 242: register int len; ! 243: register int n; ! 244: register int next_col; ! 245: ! 246: switch (charset) { ! 247: case 'A': /* United Kingdom set */ ! 248: for (s=buf; s<ptr; ++s) ! 249: if (*s == '#') ! 250: *s = '\036'; /* UK pound sign */ ! 251: break; ! 252: ! 253: case 'B': /* ASCII set */ ! 254: break; ! 255: ! 256: case '0': /* special graphics (line drawing) */ ! 257: for (s=buf; s<ptr; ++s) ! 258: if (*s>=0x5f && *s<=0x7e) ! 259: *s = *s - 0x5f; ! 260: break; ! 261: ! 262: default: /* any character sets we don't recognize */ ! 263: return; ! 264: } ! 265: ! 266: len = ptr - buf; ! 267: ptr = buf; ! 268: while (len > 0) { ! 269: n = screen->max_col-screen->cur_col+1; ! 270: if (n <= 1) { ! 271: if (screen->do_wrap && (flags&WRAPAROUND)) { ! 272: Index(screen, 1); ! 273: screen->cur_col = 0; ! 274: screen->do_wrap = 0; ! 275: n = screen->max_col+1; ! 276: } ! 277: else ! 278: n = 1; ! 279: } ! 280: if (len < n) ! 281: n = len; ! 282: next_col = screen->cur_col + n; ! 283: WriteText(screen, ptr, n, flags); ! 284: /* ! 285: * the call to WriteText updates screen->cur_col. ! 286: * If screen->cur_col != next_col, we must have ! 287: * hit the right margin, so set the do_wrap flag. ! 288: */ ! 289: screen->do_wrap = (screen->cur_col < next_col); ! 290: len -= n; ! 291: ptr += n; ! 292: } ! 293: } ! 294: ! 295: /* ! 296: * write a string str of length len onto the screen at ! 297: * the current cursor position. update cursor position. ! 298: */ ! 299: WriteText(screen, str, len, flags) ! 300: register Screen *screen; ! 301: register unsigned char *str; ! 302: register int len; ! 303: unsigned flags; ! 304: { ! 305: Font fnt; ! 306: ! 307: fnt = (flags & BOLD ? screen->fnt_bold : screen->fnt_norm); ! 308: if (flags & INSERT) ! 309: InsertChar(screen, len); ! 310: #ifdef JUMPSCROLL ! 311: if (!(AddToRefresh(screen))) { ! 312: if(screen->scroll_amt) ! 313: FlushScroll(screen); ! 314: #endif JUMPSCROLL ! 315: if (flags & INVERSE) ! 316: XText(screen->window, CursorX(screen), CursorY(screen), ! 317: str, len, fnt, screen->background, screen->foreground); ! 318: else ! 319: XText(screen->window, CursorX(screen), CursorY(screen), ! 320: str, len, fnt, screen->foreground, screen->background); ! 321: /* ! 322: * the following statements compile data to compute the average ! 323: * number of characters written on each call to XText. The data ! 324: * may be examined via the use of a "hidden" escape sequence. ! 325: */ ! 326: ctotal += len; ! 327: ++ntotal; ! 328: #ifdef JUMPSCROLL ! 329: } ! 330: #endif JUMPSCROLL ! 331: ScreenWrite(screen, str, flags, len); ! 332: CursorForward(screen, len); ! 333: } ! 334: ! 335: /* ! 336: * in Tek mode (graphics or alpha), buffer up as large a string of printing ! 337: * characters as possible before flushing buffer. in graphics mode the ! 338: * characters are plotted, in alpha mode they are printed. ! 339: */ ! 340: TekMode(term) ! 341: Terminal *term; ! 342: { ! 343: register int c; ! 344: register unsigned char *text_ptr; ! 345: register int text_cnt; ! 346: register unsigned char *buf_ptr; ! 347: register int buf_cnt; ! 348: register unsigned buffermode; ! 349: register Screen *screen = &term->screen; ! 350: register Buffer *trmbuf = &term->buf; ! 351: int arg; ! 352: ! 353: c = 0; ! 354: buffermode = 0; ! 355: text_ptr = text_buf; ! 356: text_cnt = TEXT_BUF_SIZE; ! 357: buf_cnt = trmbuf->cnt; ! 358: buf_ptr = trmbuf->ptr; ! 359: ! 360: for (;;) { ! 361: /* ! 362: * if special condition has occurred, c will already ! 363: * be set to EOF. otherwise, pick up a new char. ! 364: */ ! 365: if (c >= 0) ! 366: c = getb(trmbuf); ! 367: ! 368: if (c > 0) ! 369: c &= 0x7f; ! 370: ! 371: if (ctable[c]==CPRINTING || (c==DEL && screen->TekGMode)) { ! 372: buffermode = BUFFER_MODE; ! 373: if (--text_cnt >= 0) ! 374: *text_ptr++ = c; ! 375: else { ! 376: TEKflush(); ! 377: --text_cnt, *text_ptr++ = c; ! 378: if (arg) ! 379: c = EOF; ! 380: } ! 381: continue; ! 382: ! 383: } ! 384: ! 385: switch (ctable[c]) { ! 386: case CIGNORE: ! 387: break; ! 388: ! 389: case CTEKINIT: ! 390: if (buffermode) ! 391: TEKflush(); ! 392: TekInit(term, c); ! 393: if (arg) ! 394: c = EOF; ! 395: break; ! 396: ! 397: case FLUSH: ! 398: TEKflush(); ! 399: trmbuf->cnt = buf_cnt; ! 400: trmbuf->ptr = buf_ptr; ! 401: return (arg); ! 402: ! 403: default: /* BEL, BS, HT, LF, VT, FF, CR, ESC, US */ ! 404: /* and also SI, SO, CAN, SUB */ ! 405: TEKflush(); ! 406: if (screen->TekGMode) ! 407: TekAlph(term, c); ! 408: docontrol(term, c); ! 409: ! 410: /* ! 411: * if mode changes or event occurs, force a ! 412: * cleanup and return by setting char to EOF ! 413: */ ! 414: if (arg || screen->mode!=ANSInormal ! 415: || (screen->TekGMode==0 && screen->TekAMode==0)) ! 416: c = EOF; ! 417: } ! 418: } ! 419: } ! 420: ! 421: /* ! 422: * flush the buffer of printing characters. ! 423: * use TekString, TekPoint, or TekPlot according to current mode. ! 424: */ ! 425: TekFlushBuf(term, text_ptr) ! 426: Terminal *term; ! 427: register unsigned char *text_ptr; ! 428: { ! 429: register Screen *screen = &term->screen; ! 430: register unsigned char *s; ! 431: ! 432: s = text_buf; ! 433: if (text_ptr != text_buf) { ! 434: if (screen->TekGMode) { ! 435: if (screen->TekIMode) ! 436: while (s < text_ptr) { ! 437: TekBufPut(*s); ! 438: TekPoint(term, *s++); ! 439: } ! 440: else ! 441: while (s < text_ptr) { ! 442: TekBufPut(*s); ! 443: TekPlot(term, *s++); ! 444: } ! 445: } ! 446: else ! 447: TekString(term, text_buf, text_ptr-text_buf); ! 448: } ! 449: ! 450: return (screen->display->qlen != 0); ! 451: } ! 452: ! 453: /* ! 454: * a string (DCS, OSC, PM, APC) has been encountered in ANSI mode. ! 455: * all printing characters are ignored until a string terminator ! 456: * is seen (other possible exits are CAN, SUB, ESC, and C1 controls). ! 457: */ ! 458: ANSIstring(term) ! 459: Terminal *term; ! 460: { ! 461: register int c; ! 462: register Screen *screen = &term->screen; ! 463: register Buffer *trmbuf = &term->buf; ! 464: register unsigned char *buf_ptr; ! 465: register int buf_cnt; ! 466: ! 467: buf_cnt = trmbuf->cnt; ! 468: buf_ptr = trmbuf->ptr; ! 469: while (screen->mode==ANSIstring && screen->display->qlen==0) { ! 470: if ((c=getb(trmbuf)) == -1) ! 471: break; ! 472: if ((c=parseseq(c, &screen->ansi, screen->TekEmu)) != -1) { ! 473: switch (ctable[c]) { ! 474: case CIGNORE: ! 475: case CPRINTING: ! 476: break; ! 477: case CESC: ! 478: case CCSI: ! 479: screen->mode = ANSInormal; ! 480: procseq(term); ! 481: break; ! 482: case CDCS: ! 483: screen->mode = ANSIstring; ! 484: procseq(term); ! 485: break; ! 486: case CCANCEL: ! 487: screen->mode = ANSInormal; ! 488: break; ! 489: default: ! 490: break; ! 491: } ! 492: } ! 493: } ! 494: trmbuf->cnt = buf_cnt; ! 495: trmbuf->ptr = buf_ptr; ! 496: return (screen->display->qlen != 0); ! 497: } ! 498: ! 499: /* ! 500: * call parseseq with each new character until the sequence has been ! 501: * parsed. once parsed, call procseq to process the sequence. DEC ! 502: * standard says C0 controls in the middle of a sequence are acted ! 503: * on just as if they weren't in the middle of a sequence (ANSI says ! 504: * this is an error condition, but as always doesn't specify how to ! 505: * handle the error). ! 506: */ ! 507: ANSIparse(term) ! 508: Terminal *term; ! 509: { ! 510: register int c, ch; ! 511: register Screen *screen = &term->screen; ! 512: register Buffer *trmbuf = &term->buf; ! 513: register unsigned char *buf_ptr; ! 514: register int buf_cnt; ! 515: ! 516: c = 0; ! 517: buf_cnt = trmbuf->cnt; ! 518: buf_ptr = trmbuf->ptr; ! 519: ! 520: for (;;) { ! 521: /* ! 522: * if special condition has occurred, c will already ! 523: * be set to EOF. otherwise, pick up a new char. ! 524: */ ! 525: if (c >= 0) ! 526: c = getb(trmbuf); ! 527: ! 528: if (c == EOF) { ! 529: trmbuf->cnt = buf_cnt; ! 530: trmbuf->ptr = buf_ptr; ! 531: return (screen->display->qlen != 0); ! 532: } ! 533: ! 534: if ((ch=parseseq(c, &screen->ansi, screen->TekEmu)) != -1) { ! 535: switch (ctable[ch]) { ! 536: case CIGNORE: ! 537: break; ! 538: ! 539: case CESC: ! 540: case CCSI: ! 541: screen->mode = ANSInormal; ! 542: procseq(term); ! 543: break; ! 544: ! 545: case CDCS: ! 546: screen->mode = ANSIstring; ! 547: procseq(term); ! 548: break; ! 549: ! 550: default: ! 551: docontrol(term, ch); ! 552: break; ! 553: } ! 554: ! 555: /* ! 556: * if mode changes or event occurs, force a ! 557: * cleanup and return by setting char to EOF ! 558: */ ! 559: if (screen->mode!=ANSIparse || screen->ansi.a_type==0) { ! 560: c = EOF; ! 561: if (screen->mode==ANSIparse) ! 562: screen->mode = ANSInormal; ! 563: screen->ansi.a_type = 0; ! 564: screen->ansi.a_pintro = 0; ! 565: screen->ansi.a_final = 0; ! 566: } ! 567: if (screen->display->qlen != 0); ! 568: c = EOF; ! 569: ! 570: } ! 571: } ! 572: } ! 573: ! 574: /* ! 575: * some sort of ANSI sequence has been parsed. look through the ! 576: * esctable to look for a match. if found, apply default parameters ! 577: * and dispatch. ! 578: */ ! 579: procseq(term) ! 580: Terminal *term; ! 581: { ! 582: register ANSI *ap = &term->screen.ansi; ! 583: register int i; ! 584: register long *p; ! 585: register long a_funct; ! 586: #define SEQKEY p[0] /* type, private, & final in a long */ ! 587: #define INTERS p[1] /* intermediate(s) in a long */ ! 588: #define SEQTYPE p[2] /* sequence type (dispatch value) */ ! 589: #define NDEFLT p[3] /* number of default parameters */ ! 590: #define DEFAULT(n) p[4+n] /* the n'th default parameter (0 origin)*/ ! 591: #define FIXEDLEN 4 /* fixed (min) length of table entries */ ! 592: ! 593: /* ! 594: * just return if any error encountered ! 595: */ ! 596: if (ap->a_nastyf != 0) ! 597: return; ! 598: ! 599: a_funct = (ap->a_final << 16) | (ap->a_pintro << 8) | ap->a_type; ! 600: ! 601: /* ! 602: * step through table, looking for an ! 603: * entry which matches the current sequence. ! 604: */ ! 605: for (p=esctable; *p!=0; p+=NDEFLT+FIXEDLEN) { ! 606: if (SEQKEY==a_funct ! 607: && (INTERS==ap->a_inters || INTERS==WILD)) { ! 608: /* ! 609: * we have a match. ! 610: * get default values from table. ! 611: */ ! 612: for (i=0; i<NDEFLT; ++i) { ! 613: if (ap->a_dflt[i] || i>=ap->a_nparam) ! 614: ap->a_param[i] = DEFAULT(i); ! 615: } ! 616: if (ap->a_nparam < NDEFLT) ! 617: ap->a_nparam = NDEFLT; ! 618: /* ! 619: * ready to process the sequence. ! 620: */ ! 621: doescape(term, SEQTYPE, ap); ! 622: break; ! 623: } ! 624: } ! 625: } ! 626: ! 627: /* ! 628: * this is a big switch of all the ANSI (and other) sequences ! 629: * we know how to handle. the cases of the switch must ! 630: * have a corresponding entry in the esctable. ! 631: */ ! 632: doescape(term, kind, ap) ! 633: Terminal *term; ! 634: long kind; ! 635: ANSI *ap; ! 636: { ! 637: register Screen *screen = &term->screen; ! 638: register row, col; ! 639: register i, top, bot; ! 640: ANSI reply; ! 641: int bitset(), bitclr(); ! 642: register unsigned char *text_ptr; ! 643: register int text_cnt; ! 644: ! 645: switch (kind) { ! 646: case DECKPAM: ! 647: term->keyboard.flags |= KYPD_APL; ! 648: break; ! 649: ! 650: case DECKPNM: ! 651: term->keyboard.flags &= ~KYPD_APL; ! 652: break; ! 653: ! 654: case DECTC1: ! 655: screen->rx8bit = 0; ! 656: break; ! 657: ! 658: case DECSC: ! 659: screen->sc.row = screen->cur_row; ! 660: screen->sc.col = screen->cur_col; ! 661: screen->sc.flags = term->flags; ! 662: break; ! 663: ! 664: case DECAC1: ! 665: screen->rx8bit = 1; ! 666: break; ! 667: ! 668: case S7C1T: ! 669: screen->tx8bit = 0; ! 670: break; ! 671: ! 672: case S8C1T: ! 673: screen->tx8bit = 1; ! 674: break; ! 675: ! 676: case DECRC: ! 677: term->flags &= ~(BOLD|INVERSE); ! 678: term->flags |= screen->sc.flags&(BOLD|INVERSE); ! 679: CursorSet(screen, screen->sc.row, ! 680: screen->sc.col, term->flags); ! 681: break; ! 682: ! 683: case LS2: ! 684: screen->curgl = 2; ! 685: break; ! 686: ! 687: case LS3: ! 688: screen->curgl = 3; ! 689: break; ! 690: ! 691: case LS3R: ! 692: screen->curgr = 3; ! 693: break; ! 694: ! 695: case LS2R: ! 696: screen->curgr = 2; ! 697: break; ! 698: ! 699: case LS1R: ! 700: screen->curgr = 1; ! 701: break; ! 702: ! 703: case DESIGNATE: ! 704: switch (ap->a_inters) { ! 705: case '(': ! 706: screen->gsets[0] = ap->a_final; ! 707: break; ! 708: ! 709: case ')': ! 710: screen->gsets[1] = ap->a_final; ! 711: break; ! 712: ! 713: case '*': ! 714: screen->gsets[2] = ap->a_final; ! 715: break; ! 716: ! 717: case '+': ! 718: screen->gsets[3] = ap->a_final; ! 719: break; ! 720: ! 721: case '#': /* special "hidden" sequence */ ! 722: if (ap->a_final == '1') ! 723: fprintf(stderr, "avg call = %d char\n", ! 724: ctotal/ntotal); ! 725: ! 726: default: ! 727: break; ! 728: } ! 729: break; ! 730: ! 731: case DA1: ! 732: if (ap->a_param[0]==0) { ! 733: reply.a_type = CSI; ! 734: reply.a_pintro = '?'; ! 735: reply.a_nparam = 1; ! 736: reply.a_param[0] = 6; /* VT102 */ ! 737: reply.a_inters = 0; ! 738: reply.a_final = 'c'; ! 739: unparseseq(&reply, screen->tx8bit, screen->respond); ! 740: } ! 741: break; ! 742: ! 743: case TBC: ! 744: if (ap->a_param[0]==0) ! 745: TabClear(term->tabs, screen->cur_col); ! 746: else if (ap->a_param[0] == 3) ! 747: TabZonk(term->tabs); ! 748: break; ! 749: ! 750: case SET: ! 751: modes(term, bitset); ! 752: break; ! 753: ! 754: case DECSET: ! 755: dpmodes(term, bitset); ! 756: break; ! 757: ! 758: case RST: ! 759: modes(term, bitclr); ! 760: break; ! 761: ! 762: case DECRST: ! 763: dpmodes(term, bitclr); ! 764: break; ! 765: ! 766: case SGR: ! 767: for (i=0; i<ap->a_nparam; ++i) { ! 768: switch (ap->a_param[i]) { ! 769: case 0: ! 770: term->flags &= ~(INVERSE|BOLD); ! 771: break; ! 772: ! 773: case 1: ! 774: case 4: /* Underscore, really */ ! 775: case 5: /* Blink, really. */ ! 776: term->flags |= BOLD; ! 777: break; ! 778: ! 779: case 7: ! 780: term->flags |= INVERSE; ! 781: } ! 782: } ! 783: break; ! 784: ! 785: case CPR: ! 786: if (ap->a_param[0]==5) { ! 787: reply.a_type = CSI; ! 788: reply.a_pintro = 0; ! 789: reply.a_nparam = 1; ! 790: reply.a_param[0] = 0; ! 791: reply.a_inters = 0; ! 792: reply.a_final = 'n'; ! 793: unparseseq(&reply, screen->tx8bit, screen->respond); ! 794: break; ! 795: } ! 796: if (ap->a_param[0]==6) { ! 797: reply.a_type = CSI; ! 798: reply.a_pintro = 0; ! 799: reply.a_nparam = 2; ! 800: reply.a_param[0] = screen->cur_row+1; ! 801: reply.a_param[1] = screen->cur_col+1; ! 802: reply.a_inters = 0; ! 803: reply.a_final = 'R'; ! 804: unparseseq(&reply, screen->tx8bit, screen->respond); ! 805: break; ! 806: } ! 807: break; ! 808: ! 809: case DECSTBM: ! 810: top = ap->a_param[0]; ! 811: bot = ap->a_param[1]; ! 812: if (top < 1) ! 813: top = 1; ! 814: if (bot > screen->max_row+1) ! 815: bot = screen->max_row+1; ! 816: if (bot > top) { ! 817: #ifdef JUMPSCROLL ! 818: if(screen->scroll_amt) ! 819: FlushScroll(screen); ! 820: #endif JUMPSCROLL ! 821: screen->top_marg = top-1; ! 822: screen->bot_marg = bot-1; ! 823: CursorSet(screen, 0, 0, term->flags); ! 824: } ! 825: break; ! 826: ! 827: case ICH: ! 828: InsertChar(screen, ap->a_param[0]); ! 829: break; ! 830: ! 831: case CUU: ! 832: CursorUp(screen, ap->a_param[0]); ! 833: break; ! 834: ! 835: case CUD: ! 836: CursorDown(screen, ap->a_param[0]); ! 837: break; ! 838: ! 839: case CUF: ! 840: CursorForward(screen, ap->a_param[0]); ! 841: break; ! 842: ! 843: case CUB: ! 844: CursorBack(screen, ap->a_param[0]); ! 845: break; ! 846: ! 847: case HVP: ! 848: case CUP: ! 849: row = ap->a_param[0]; ! 850: col = ap->a_param[1]; ! 851: ! 852: screen->cur_x = screen->cur_y = 0; ! 853: screen->TekAMode = 0; ! 854: CursorSet(screen, row-1, col-1, term->flags); ! 855: break; ! 856: ! 857: case ED: ! 858: switch (ap->a_param[0]) { ! 859: case 0: ClearBelow(screen); ! 860: break; ! 861: ! 862: case 1: ClearAbove(screen); ! 863: break; ! 864: ! 865: case 2: ClearScreen(screen); ! 866: if (screen->TekEmu) ! 867: TekErase(term); ! 868: break; ! 869: } ! 870: break; ! 871: ! 872: case EL: ! 873: switch (ap->a_param[0]) { ! 874: case 0: ClearRight(screen); ! 875: break; ! 876: ! 877: case 1: ClearLeft(screen); ! 878: break; ! 879: ! 880: case 2: ClearLine(screen); ! 881: break; ! 882: } ! 883: break; ! 884: ! 885: case IL: ! 886: InsertLine(screen, ap->a_param[0]); ! 887: break; ! 888: ! 889: case DL: ! 890: DeleteLine(screen, ap->a_param[0]); ! 891: break; ! 892: ! 893: case DCH: ! 894: DeleteChar(screen, ap->a_param[0]); ! 895: break; ! 896: ! 897: case DECALN: ! 898: text_ptr = text_buf; ! 899: text_cnt = TEXT_BUF_SIZE; ! 900: for (i=0; i<256; ++i) { ! 901: if (--text_cnt >= 0) ! 902: *text_ptr++ = i; ! 903: else { ! 904: flushbuf(screen, term->flags, text_ptr); ! 905: text_ptr = text_buf; ! 906: text_cnt = TEXT_BUF_SIZE-1; ! 907: *text_ptr++ = i; ! 908: } ! 909: } ! 910: flushbuf(screen, term->flags, text_ptr); ! 911: break; ! 912: ! 913: case TEKESCFF: ! 914: case TEKCSIUS: ! 915: CursorSet(screen, 0, 0, term->flags); ! 916: ClearScreen(screen); ! 917: TekErase(term); ! 918: break; ! 919: ! 920: case TEKESCSUB: ! 921: TekCursor(term); ! 922: break; ! 923: ! 924: case TEKESCINQ: ! 925: TekInq(term); ! 926: break; ! 927: ! 928: default: ! 929: Panic("unexpected dispatch (%d) encountered in doescape", kind); ! 930: break; ! 931: } ! 932: } ! 933: ! 934: /* ! 935: * this is a big switch of all the control characters we know how to handle. ! 936: * the cases of the switch have a corresponding entry in the ctable. ! 937: */ ! 938: docontrol(term, c) ! 939: Terminal *term; ! 940: { ! 941: register Screen *screen = &term->screen; ! 942: ! 943: switch (ctable[c]) { ! 944: case CIGNORE: ! 945: break; ! 946: ! 947: case CBELL: ! 948: XFeep(0); ! 949: break; ! 950: ! 951: case CBACKSPACE: ! 952: CursorBack(screen, 1); ! 953: break; ! 954: ! 955: case CTAB: ! 956: screen->cur_col = TabNext(term->tabs, screen->cur_col); ! 957: if (screen->cur_col > screen->max_col) ! 958: screen->cur_col = screen->max_col; ! 959: break; ! 960: ! 961: case CLINEFEED: /* actually both VT and LF map here */ ! 962: case CFORMFEED: ! 963: if (screen->TekAMode) ! 964: TekReset(term); ! 965: Index(screen, 1); ! 966: if (term->flags & LINEFEED) ! 967: CarriageReturn(screen); ! 968: break; ! 969: ! 970: case CRETURN: ! 971: if (screen->TekAMode) ! 972: TekReset(term); ! 973: CarriageReturn(screen); ! 974: break; ! 975: ! 976: case CLS1: ! 977: screen->curgl = 1; ! 978: break; ! 979: ! 980: case CLS0: ! 981: screen->curgl = 0; ! 982: break; ! 983: ! 984: case CCANCEL: ! 985: screen->mode = ANSInormal; ! 986: break; ! 987: ! 988: case CESC: ! 989: case CDCS: ! 990: case CCSI: ! 991: screen->ansi.a_type = c; ! 992: screen->ansi.a_pintro = 0; ! 993: screen->ansi.a_final = 0; ! 994: screen->ansi.a_inters = 0; ! 995: screen->ansi.a_nparam = 0; ! 996: screen->ansi.a_nastyf = 0; ! 997: screen->mode = ANSIparse; ! 998: break; ! 999: ! 1000: case CTEKINIT: /* come here from FS, GS, or RS */ ! 1001: if (screen->TekEmu) ! 1002: TekInit(term, c); ! 1003: break; ! 1004: ! 1005: case CTEKALPH: /* US */ ! 1006: break; /* just ignore; can only get to alpha */ ! 1007: /* mode from Tek graphics mode */ ! 1008: ! 1009: case CIND: ! 1010: Index(screen, 1); ! 1011: break; ! 1012: ! 1013: case CNEL: ! 1014: Index(screen, 1); ! 1015: CarriageReturn(screen); ! 1016: break; ! 1017: ! 1018: case CRI: ! 1019: RevIndex(screen, 1); ! 1020: break; ! 1021: ! 1022: case CSS2: ! 1023: screen->curss = 2; ! 1024: break; ! 1025: ! 1026: case CSS3: ! 1027: screen->curss = 3; ! 1028: break; ! 1029: ! 1030: default: ! 1031: Panic("unexpected char (0x%x) encountered in docontrol", c); ! 1032: break; ! 1033: } ! 1034: } ! 1035: ! 1036: /* ! 1037: * process ANSI modes set, reset ! 1038: */ ! 1039: modes(term, func) ! 1040: Terminal *term; ! 1041: int (*func)(); ! 1042: { ! 1043: register Screen *screen = &term->screen; ! 1044: register ANSI *ansi; ! 1045: register int i; ! 1046: ! 1047: ansi = &screen->ansi; ! 1048: for (i=0; i<ansi->a_nparam; ++i) { ! 1049: switch (ansi->a_param[i]) { ! 1050: case 4: /* IRM */ ! 1051: (*func)(&term->flags, INSERT); ! 1052: break; ! 1053: ! 1054: case 20: /* LNM */ ! 1055: (*func)(&term->flags, LINEFEED); ! 1056: break; ! 1057: } ! 1058: } ! 1059: } ! 1060: ! 1061: /* ! 1062: * process DEC private modes set, reset ! 1063: */ ! 1064: dpmodes(term, func) ! 1065: Terminal *term; ! 1066: int (*func)(); ! 1067: { ! 1068: register Screen *screen = &term->screen; ! 1069: register ANSI *ap; ! 1070: register int i; ! 1071: ! 1072: ap = &screen->ansi; ! 1073: for (i=0; i<ap->a_nparam; ++i) { ! 1074: switch (ap->a_param[i]) { ! 1075: case 1: /* DECCKM */ ! 1076: (*func)(&term->keyboard.flags, CURSOR_APL); ! 1077: break; ! 1078: ! 1079: #ifdef JUMPSCROLL ! 1080: case 4: /* DECSCLM (slow scroll) */ ! 1081: if (func == bitset) { ! 1082: screen->jumpscroll = 0; ! 1083: if (screen->scroll_amt) ! 1084: FlushScroll(screen); ! 1085: } else if (!screen->TekEmu) ! 1086: screen->jumpscroll = 1; ! 1087: (*func)(&term->flags, SMOOTHSCROLL); ! 1088: break; ! 1089: #endif JUMPSCROLL ! 1090: case 5: /* DECSCNM */ ! 1091: i = term->flags; ! 1092: (*func)(&term->flags, REVERSE_VIDEO); ! 1093: if ((term->flags ^ i) & REVERSE_VIDEO) ! 1094: ReverseVideo(term); ! 1095: break; ! 1096: ! 1097: case 6: /* DECOM */ ! 1098: (*func)(&term->flags, ORIGIN); ! 1099: CursorSet(screen, 0, 0, term->flags); ! 1100: break; ! 1101: ! 1102: case 7: /* DECAWM */ ! 1103: (*func)(&term->flags, WRAPAROUND); ! 1104: break; ! 1105: case 9: /* MIT bogus sequence */ ! 1106: (*func)(&screen->send_mouse_pos, 1); ! 1107: break; ! 1108: case 38: /* DECTEK */ ! 1109: (*func)(&screen->TekEmu, 1); ! 1110: /* ! 1111: * probably need to do some work here to get ! 1112: * into or out of Tek emulation cleanly ! 1113: */ ! 1114: break; ! 1115: } ! 1116: } ! 1117: } ! 1118: ! 1119: /* ! 1120: * set a bit in a word given a pointer to the word and a mask. ! 1121: */ ! 1122: bitset(p, mask) ! 1123: int *p; ! 1124: { ! 1125: *p |= mask; ! 1126: } ! 1127: ! 1128: /* ! 1129: * clear a bit in a word given a pointer to the word and a mask. ! 1130: */ ! 1131: bitclr(p, mask) ! 1132: int *p; ! 1133: { ! 1134: *p &= ~mask; ! 1135: } ! 1136: ! 1137: ReverseVideo (term) ! 1138: Terminal *term; ! 1139: { ! 1140: register Screen *screen = &term->screen; ! 1141: int tmp; ! 1142: ! 1143: XDefineCursor(screen->window, ! 1144: (term->flags & REVERSE_VIDEO) ? screen->rcurs : screen->curs); ! 1145: tmp = screen->background; ! 1146: if (screen->cursorcolor == screen->foreground) ! 1147: screen->cursorcolor = tmp; ! 1148: screen->background = screen->foreground; ! 1149: screen->foreground = tmp; ! 1150: XFreePixmap(screen->bgndtile); ! 1151: screen->bgndtile = XMakeTile(screen->background); ! 1152: if (screen->borderwidth && ! 1153: screen->background < 2 && ! 1154: screen->foreground < 2) { ! 1155: if (screen->bgndtile == BlackPixmap) ! 1156: screen->bordertile = WhitePixmap; ! 1157: else if (screen->bgndtile == WhitePixmap) ! 1158: screen->bordertile = BlackPixmap; ! 1159: XChangeBorder (screen->window, screen->bordertile); ! 1160: } ! 1161: XChangeBackground (screen->window, screen->bgndtile); ! 1162: XClear (screen->window); ! 1163: ScrnRefresh (screen, 0, 0, screen->max_row +1, screen->max_col + 1); ! 1164: if (screen->TekEmu) TekRefresh (term); ! 1165: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.