![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to curses.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 / vi|
Return to curses.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 ! root 1: /* curses.c */ ! 2: ! 3: /* Author: ! 4: * Steve Kirkendall ! 5: * 14407 SW Teal Blvd. #C ! 6: * Beaverton, OR 97005 ! 7: * [email protected] ! 8: */ ! 9: ! 10: ! 11: /* This file contains the functions & variables needed for a tiny subset of ! 12: * curses. The principle advantage of this version of curses is its ! 13: * extreme speed. Disadvantages are potentially larger code, few supported ! 14: * functions, limited compatibility with full curses, and only stdscr. ! 15: */ ! 16: ! 17: #include "config.h" ! 18: #include "vi.h" ! 19: ! 20: #if ANY_UNIX ! 21: # if UNIXV ! 22: # ifdef TERMIOS ! 23: # include <termios.h> ! 24: # else ! 25: # include <termio.h> ! 26: # endif ! 27: # ifdef S5WINSIZE ! 28: # include <sys/stream.h> /* winsize struct defined in one of these? */ ! 29: # include <sys/ptem.h> ! 30: # else ! 31: # undef TIOCGWINSZ /* we can't handle it correctly yet */ ! 32: # endif ! 33: # else ! 34: # include <sgtty.h> ! 35: # endif ! 36: #endif ! 37: ! 38: #if TOS ! 39: # include <osbind.h> ! 40: #endif ! 41: ! 42: #if OSK ! 43: # include <sgstat.h> ! 44: #endif ! 45: ! 46: #if VMS ! 47: extern int VMS_read_raw; /* Set in initscr() */ ! 48: #endif ! 49: ! 50: ! 51: extern char *getenv(); ! 52: static void starttcap(); ! 53: ! 54: /* variables, publicly available & used in the macros */ ! 55: char *termtype; /* name of terminal entry */ ! 56: short ospeed; /* speed of the tty, eg B2400 */ ! 57: #if OSK ! 58: char PC_; /* Pad char */ ! 59: char *BC; /* backspace character string */ ! 60: #else ! 61: char PC; /* Pad char */ ! 62: #endif ! 63: WINDOW *stdscr; /* pointer into kbuf[] */ ! 64: WINDOW kbuf[KBSIZ]; /* a very large output buffer */ ! 65: int LINES; /* :li#: number of rows */ ! 66: int COLS; /* :co#: number of columns */ ! 67: int AM; /* :am: boolean: auto margins? */ ! 68: int PT; /* :pt: boolean: physical tabs? */ ! 69: char *VB; /* :vb=: visible bell */ ! 70: char *UP; /* :up=: move cursor up */ ! 71: char *SO = ""; /* :so=: standout start */ ! 72: char *SE = ""; /* :se=: standout end */ ! 73: char *US = ""; /* :us=: underline start */ ! 74: char *UE = ""; /* :ue=: underline end */ ! 75: char *MD = ""; /* :md=: bold start */ ! 76: char *ME = ""; /* :me=: bold end */ ! 77: char *AS = ""; /* :as=: alternate (italic) start */ ! 78: char *AE = ""; /* :ae=: alternate (italic) end */ ! 79: #ifndef NO_VISIBLE ! 80: char *MV; /* :mv=: "visible" selection start */ ! 81: #endif ! 82: char *CM; /* :cm=: cursor movement */ ! 83: char *CE; /* :ce=: clear to end of line */ ! 84: char *CD; /* :cd=: clear to end of screen */ ! 85: char *AL; /* :al=: add a line */ ! 86: char *DL; /* :dl=: delete a line */ ! 87: #if OSK ! 88: char *SR_; /* :sr=: scroll reverse */ ! 89: #else ! 90: char *SR; /* :sr=: scroll reverse */ ! 91: #endif ! 92: char *KU; /* :ku=: key sequence sent by up arrow */ ! 93: char *KD; /* :kd=: key sequence sent by down arrow */ ! 94: char *KL; /* :kl=: key sequence sent by left arrow */ ! 95: char *KR; /* :kr=: key sequence sent by right arrow */ ! 96: char *HM; /* :HM=: key sequence sent by the <Home> key */ ! 97: char *EN; /* :EN=: key sequence sent by the <End> key */ ! 98: char *PU; /* :PU=: key sequence sent by the <PgUp> key */ ! 99: char *PD; /* :PD=: key sequence sent by the <PgDn> key */ ! 100: char *KI; /* :kI=: key sequence sent by the <Insert> key */ ! 101: #ifndef NO_FKEY ! 102: char *FKEY[NFKEYS]; /* :k0=: ... :k9=: sequences sent by function keys */ ! 103: #endif ! 104: char *IM = ""; /* :im=: insert mode start */ ! 105: char *IC = ""; /* :ic=: insert the following character */ ! 106: char *EI = ""; /* :ei=: insert mode end */ ! 107: char *DC; /* :dc=: delete a character */ ! 108: char *TI = ""; /* :ti=: terminal init */ /* GB */ ! 109: char *TE = ""; /* :te=: terminal exit */ /* GB */ ! 110: #ifndef NO_CURSORSHAPE ! 111: #if 1 ! 112: char *CQ = (char *)0;/* :cQ=: normal cursor */ ! 113: char *CX = (char *)1;/* :cX=: cursor used for EX command/entry */ ! 114: char *CV = (char *)2;/* :cV=: cursor used for VI command mode */ ! 115: char *CI = (char *)3;/* :cI=: cursor used for VI input mode */ ! 116: char *CR = (char *)4;/* :cR=: cursor used for VI replace mode */ ! 117: #else ! 118: char *CQ = ""; /* :cQ=: normal cursor */ ! 119: char *CX = ""; /* :cX=: cursor used for EX command/entry */ ! 120: char *CV = ""; /* :cV=: cursor used for VI command mode */ ! 121: char *CI = ""; /* :cI=: cursor used for VI input mode */ ! 122: char *CR = ""; /* :cR=: cursor used for VI replace mode */ ! 123: #endif ! 124: #endif ! 125: char *aend = ""; /* end an attribute -- either UE or ME */ ! 126: char ERASEKEY; /* backspace key taken from ioctl structure */ ! 127: #ifndef NO_COLOR ! 128: char normalcolor[16]; ! 129: char SOcolor[16]; ! 130: char SEcolor[16]; ! 131: char UScolor[16]; ! 132: char UEcolor[16]; ! 133: char MDcolor[16]; ! 134: char MEcolor[16]; ! 135: char AScolor[16]; ! 136: char AEcolor[16]; ! 137: # ifndef NO_POPUP ! 138: char POPUPcolor[16]; ! 139: # endif ! 140: # ifndef NO_VISIBLE ! 141: char VISIBLEcolor[16]; ! 142: # endif ! 143: #endif ! 144: ! 145: #if ANY_UNIX ! 146: # if UNIXV ! 147: # ifdef TERMIOS ! 148: static struct termios oldtermio; /* original tty mode */ ! 149: static struct termios newtermio; /* cbreak/noecho tty mode */ ! 150: # else ! 151: static struct termio oldtermio; /* original tty mode */ ! 152: static struct termio newtermio; /* cbreak/noecho tty mode */ ! 153: # endif ! 154: # else ! 155: static struct sgttyb oldsgttyb; /* original tty mode */ ! 156: static struct sgttyb newsgttyb; /* cbreak/nl/noecho tty mode */ ! 157: static int oldint; /* ^C or DEL, the "intr" character */ ! 158: # ifdef TIOCSLTC ! 159: static int oldswitch; /* ^Z, the "suspend" character */ ! 160: static int olddswitch; /* ^Y, the "delayed suspend" char */ ! 161: static int oldquote; /* ^V, the "quote next char" char */ ! 162: # endif ! 163: # endif ! 164: #endif ! 165: ! 166: #if OSK ! 167: static struct sgbuf oldsgttyb; /* orginal tty mode */ ! 168: static struct sgbuf newsgttyb; /* noecho tty mode */ ! 169: #endif ! 170: ! 171: static char *capbuf; /* capability string buffer */ ! 172: ! 173: ! 174: /* Initialize the Curses package. */ ! 175: void initscr() ! 176: { ! 177: /* make sure TERM variable is set */ ! 178: termtype = getenv("TERM"); ! 179: ! 180: #if VMS ! 181: /* VMS getenv() handles TERM as a environment setting. Foreign ! 182: * terminal support can be implemented by setting the ELVIS_TERM ! 183: * logical or symbol to match a tinytcap entry. ! 184: */ ! 185: if (!strcmp(termtype,"unknown")) ! 186: termtype = getenv("ELVIS_TERM"); ! 187: #endif ! 188: #if MSDOS ! 189: /* For MS-DOS, if TERM is unset we can default to "pcbios", or ! 190: * maybe "rainbow". ! 191: */ ! 192: if (!termtype) ! 193: { ! 194: #ifdef RAINBOW ! 195: if (*(unsigned char far*)(0xffff000eL) == 6 /* Rainbow 100a */ ! 196: || *(unsigned char far*)(0xffff000eL) == 148)/* Rainbow 100b */ ! 197: { ! 198: termtype = "rainbow"; ! 199: } ! 200: else ! 201: #endif ! 202: termtype = "pcbios"; ! 203: } ! 204: if (!strcmp(termtype, "pcbios")) ! 205: #else ! 206: if (!termtype) ! 207: #endif ! 208: { ! 209: #if ANY_UNIX ! 210: write(2, "Environment variable TERM must be set\n", (unsigned)38); ! 211: exit(2); ! 212: #endif ! 213: #if OSK ! 214: writeln(2, "Environment variable TERM must be set\n", (unsigned)38); ! 215: exit(2); ! 216: #endif ! 217: #if AMIGA ! 218: termtype = TERMTYPE; ! 219: starttcap(termtype); ! 220: #endif ! 221: #if MSDOS ! 222: starttcap("pcbios"); ! 223: #endif ! 224: #if TOS ! 225: termtype = "vt52"; ! 226: starttcap(termtype); ! 227: #endif ! 228: #if VMS ! 229: write(2, "UNKNOWN terminal: define ELVIS_TERM\n", (unsigned)36); ! 230: exit(2); ! 231: #endif ! 232: } ! 233: else ! 234: { ! 235: #if MSDOS ! 236: *o_pcbios = 0; ! 237: #endif ! 238: /* start termcap stuff */ ! 239: starttcap(termtype); ! 240: } ! 241: ! 242: /* create stdscr and curscr */ ! 243: stdscr = kbuf; ! 244: ! 245: /* change the terminal mode to cbreak/noecho */ ! 246: #if ANY_UNIX ! 247: # if UNIXV ! 248: # ifdef TERMIOS ! 249: tcgetattr(2, &oldtermio); ! 250: # else ! 251: ioctl(2, TCGETA, &oldtermio); ! 252: # endif ! 253: # else ! 254: ioctl(2, TIOCGETP, &oldsgttyb); ! 255: # endif ! 256: #endif ! 257: ! 258: #if OSK ! 259: _gs_opt(0, &oldsgttyb); ! 260: #endif ! 261: ! 262: #if VMS ! 263: VMS_read_raw = 1; /* cbreak/noecho */ ! 264: vms_open_tty(); ! 265: #endif ! 266: resume_curses(TRUE); ! 267: } ! 268: ! 269: /* Shut down the Curses package. */ ! 270: void endwin() ! 271: { ! 272: /* change the terminal mode back the way it was */ ! 273: suspend_curses(); ! 274: #if AMIGA ! 275: amiclosewin(); ! 276: #endif ! 277: } ! 278: ! 279: ! 280: static int curses_active = FALSE; ! 281: ! 282: /* Send any required termination strings. Turn off "raw" mode. */ ! 283: void suspend_curses() ! 284: { ! 285: #if ANY_UNIX && !UNIXV ! 286: struct tchars tbuf; ! 287: # ifdef TIOCSLTC ! 288: struct ltchars ltbuf; ! 289: # endif ! 290: #endif ! 291: #ifndef NO_CURSORSHAPE ! 292: if (has_CQ) ! 293: { ! 294: do_CQ(); ! 295: } ! 296: #endif ! 297: if (has_TE) /* GB */ ! 298: { ! 299: do_TE(); ! 300: } ! 301: #ifndef NO_COLOR ! 302: quitcolor(); ! 303: #endif ! 304: refresh(); ! 305: ! 306: /* change the terminal mode back the way it was */ ! 307: #if ANY_UNIX ! 308: # if UNIXV ! 309: # if TERMIOS ! 310: tcsetattr(2, TCSADRAIN, &oldtermio); ! 311: # else ! 312: ioctl(2, TCSETAW, &oldtermio); ! 313: # endif ! 314: # else ! 315: ioctl(2, TIOCSETP, &oldsgttyb); ! 316: ! 317: ioctl(2, TIOCGETC, (struct sgttyb *) &tbuf); ! 318: tbuf.t_intrc = oldint; ! 319: ioctl(2, TIOCSETC, (struct sgttyb *) &tbuf); ! 320: ! 321: # ifdef TIOCSLTC ! 322: ioctl(2, TIOCGLTC, <buf); ! 323: ltbuf.t_suspc = oldswitch; ! 324: ltbuf.t_dsuspc = olddswitch; ! 325: ltbuf.t_lnextc = oldquote; ! 326: ioctl(2, TIOCSLTC, <buf); ! 327: # endif ! 328: # endif ! 329: #endif ! 330: #if OSK ! 331: _ss_opt(0, &oldsgttyb); ! 332: #endif ! 333: #if AMIGA ! 334: ttyshutdown(); ! 335: #endif ! 336: #if MSDOS ! 337: raw_set_stdio(FALSE); ! 338: #endif ! 339: ! 340: #if VMS ! 341: VMS_read_raw = 0; ! 342: #endif ! 343: curses_active = FALSE; ! 344: } ! 345: ! 346: ! 347: /* put the terminal in RAW mode. If "quietly" is FALSE, then ask the user ! 348: * to hit a key, and wait for keystroke before returning. ! 349: */ ! 350: void resume_curses(quietly) ! 351: int quietly; ! 352: { ! 353: if (!curses_active) ! 354: { ! 355: /* change the terminal mode to cbreak/noecho */ ! 356: #if ANY_UNIX ! 357: # if UNIXV ! 358: ospeed = (oldtermio.c_cflag & CBAUD); ! 359: ERASEKEY = oldtermio.c_cc[VERASE]; ! 360: newtermio = oldtermio; ! 361: newtermio.c_iflag &= (IXON|IXOFF|IXANY|ISTRIP|IGNBRK); ! 362: newtermio.c_oflag &= ~OPOST; ! 363: newtermio.c_lflag &= ISIG; ! 364: newtermio.c_cc[VINTR] = ctrl('C'); /* always use ^C for interrupts */ ! 365: newtermio.c_cc[VMIN] = 1; ! 366: newtermio.c_cc[VTIME] = 0; ! 367: # ifdef VSWTCH ! 368: newtermio.c_cc[VSWTCH] = 0; ! 369: # endif ! 370: # ifdef VSUSP ! 371: newtermio.c_cc[VSUSP] = 0; ! 372: # endif ! 373: # ifdef TERMIOS ! 374: tcsetattr(2, TCSADRAIN, &newtermio); ! 375: # else ! 376: ioctl(2, TCSETAW, &newtermio); ! 377: # endif ! 378: # else /* BSD or V7 or Coherent or Minix */ ! 379: struct tchars tbuf; ! 380: # ifdef TIOCSLTC ! 381: struct ltchars ltbuf; ! 382: # endif ! 383: ! 384: ospeed = oldsgttyb.sg_ospeed; ! 385: ERASEKEY = oldsgttyb.sg_erase; ! 386: newsgttyb = oldsgttyb; ! 387: newsgttyb.sg_flags |= CBREAK; ! 388: newsgttyb.sg_flags &= ~(CRMOD|ECHO|XTABS); ! 389: ioctl(2, TIOCSETP, &newsgttyb); ! 390: ! 391: ioctl(2, TIOCGETC, (struct sgttyb *) &tbuf); ! 392: oldint = tbuf.t_intrc; ! 393: tbuf.t_intrc = ctrl('C'); /* always use ^C for interrupts */ ! 394: ioctl(2, TIOCSETC, (struct sgttyb *) &tbuf); ! 395: ! 396: # ifdef TIOCSLTC ! 397: ioctl(2, TIOCGLTC, <buf); ! 398: oldswitch = ltbuf.t_suspc; ! 399: ltbuf.t_suspc = 0; /* disable ^Z for elvis */ ! 400: olddswitch = ltbuf.t_dsuspc; ! 401: ltbuf.t_dsuspc = 0; /* disable ^Y for elvis */ ! 402: oldquote = ltbuf.t_lnextc; ! 403: ltbuf.t_lnextc = 0; /* disable ^V for elvis */ ! 404: ioctl(2, TIOCSLTC, <buf); ! 405: # endif ! 406: ! 407: # endif ! 408: #endif ! 409: #if OSK ! 410: newsgttyb = oldsgttyb; ! 411: newsgttyb.sg_echo = 0; ! 412: newsgttyb.sg_eofch = 0; ! 413: newsgttyb.sg_kbach = 0; ! 414: newsgttyb.sg_kbich = ctrl('C'); ! 415: _ss_opt(0, &newsgttyb); ! 416: ospeed = oldsgttyb.sg_baud; ! 417: ERASEKEY = oldsgttyb.sg_bspch; ! 418: #endif ! 419: #if AMIGA ! 420: /* turn on window resize and RAW */ ! 421: ttysetup(); ! 422: #endif ! 423: #if MSDOS ! 424: raw_set_stdio(TRUE); ! 425: #endif ! 426: ! 427: #if VMS ! 428: VMS_read_raw = 1; ! 429: { int c; ! 430: read(0,&c,0); /* Flush the tty buffer. */ ! 431: } ! 432: ERASEKEY = '\177'; /* Accept <DEL> as <^H> for VMS */ ! 433: #endif ! 434: ! 435: curses_active = TRUE; ! 436: } ! 437: ! 438: /* If we're supposed to quit quietly, then we're done */ ! 439: if (quietly) ! 440: { ! 441: if (has_TI) /* GB */ ! 442: { ! 443: do_TI(); ! 444: } ! 445: ! 446: return; ! 447: } ! 448: ! 449: signal(SIGINT, SIG_IGN); ! 450: ! 451: move(LINES - 1, 0); ! 452: do_SO(); ! 453: #if VMS ! 454: qaddstr("\n[Press <RETURN> to continue]"); ! 455: #else ! 456: qaddstr("[Press <RETURN> to continue]"); ! 457: #endif ! 458: do_SE(); ! 459: refresh(); ! 460: ttyread(kbuf, 20, 0); /* in RAW mode, so <20 is very likely */ ! 461: if (has_TI) ! 462: { ! 463: do_TI(); ! 464: } ! 465: if (kbuf[0] == ':') ! 466: { ! 467: mode = MODE_COLON; ! 468: addch('\n'); ! 469: refresh(); ! 470: } ! 471: else ! 472: { ! 473: mode = MODE_VI; ! 474: redraw(MARK_UNSET, FALSE); ! 475: } ! 476: exwrote = FALSE; ! 477: ! 478: #if TURBOC || __GNUC__ ! 479: signal(SIGINT, (void(*)()) trapint); ! 480: #else ! 481: signal(SIGINT, trapint); ! 482: #endif ! 483: } ! 484: ! 485: /* This function fetches an optional string from termcap */ ! 486: static void mayhave(T, s) ! 487: char **T; /* where to store the returned pointer */ ! 488: char *s; /* name of the capability */ ! 489: { ! 490: char *val; ! 491: ! 492: val = tgetstr(s, &capbuf); ! 493: if (val) ! 494: { ! 495: *T = val; ! 496: } ! 497: } ! 498: ! 499: ! 500: /* This function fetches a required string from termcap */ ! 501: static void musthave(T, s) ! 502: char **T; /* where to store the returned pointer */ ! 503: char *s; /* name of the capability */ ! 504: { ! 505: mayhave(T, s); ! 506: if (!*T) ! 507: { ! 508: write(2, "This termcap entry lacks the :", (unsigned)30); ! 509: write(2, s, (unsigned)2); ! 510: write(2, "=: capability\n", (unsigned)14); ! 511: #if OSK ! 512: write(2, "\l", 1); ! 513: #endif ! 514: exit(2); ! 515: } ! 516: } ! 517: ! 518: ! 519: /* This function fetches a pair of strings from termcap. If one of them is ! 520: * missing, then the other one is ignored. ! 521: */ ! 522: static void pair(T, U, sT, sU) ! 523: char **T; /* where to store the first pointer */ ! 524: char **U; /* where to store the second pointer */ ! 525: char *sT; /* name of the first capability */ ! 526: char *sU; /* name of the second capability */ ! 527: { ! 528: mayhave(T, sT); ! 529: mayhave(U, sU); ! 530: if (!**T || !**U) ! 531: { ! 532: *T = *U = ""; ! 533: } ! 534: } ! 535: ! 536: ! 537: ! 538: /* Read everything from termcap */ ! 539: static void starttcap(term) ! 540: char *term; ! 541: { ! 542: static char cbmem[800]; ! 543: ! 544: /* allocate memory for capbuf */ ! 545: capbuf = cbmem; ! 546: ! 547: /* get the termcap entry */ ! 548: switch (tgetent(kbuf, term)) ! 549: { ! 550: case -1: ! 551: write(2, "Can't read /etc/termcap\n", (unsigned)24); ! 552: #if OSK ! 553: write(2, "\l", 1); ! 554: #endif ! 555: exit(2); ! 556: ! 557: case 0: ! 558: write(2, "Unrecognized TERM type\n", (unsigned)23); ! 559: #if OSK ! 560: write(2, "\l", 1); ! 561: #endif ! 562: exit(3); ! 563: } ! 564: ! 565: /* get strings */ ! 566: musthave(&UP, "up"); ! 567: mayhave(&VB, "vb"); ! 568: musthave(&CM, "cm"); ! 569: pair(&SO, &SE, "so", "se"); ! 570: mayhave(&TI, "ti"); ! 571: mayhave(&TE, "te"); ! 572: if (tgetnum("ug") <= 0) ! 573: { ! 574: pair(&US, &UE, "us", "ue"); ! 575: pair(&MD, &ME, "md", "me"); ! 576: ! 577: /* get italics, or have it default to underline */ ! 578: pair(&AS, &AE, "as", "ae"); ! 579: if (!*AS) ! 580: { ! 581: AS = US; ! 582: AE = UE; ! 583: } ! 584: } ! 585: #ifndef NO_VISIBLE ! 586: MV = SO; /* by default */ ! 587: mayhave(&MV, "mv"); ! 588: #endif ! 589: mayhave(&AL, "al"); ! 590: mayhave(&DL, "dl"); ! 591: musthave(&CE, "ce"); ! 592: mayhave(&CD, "cd"); ! 593: #if OSK ! 594: mayhave(&SR_, "sr"); ! 595: #else ! 596: mayhave(&SR, "sr"); ! 597: #endif ! 598: pair(&IM, &EI, "im", "ei"); ! 599: mayhave(&IC, "ic"); ! 600: mayhave(&DC, "dc"); ! 601: ! 602: /* other termcap stuff */ ! 603: AM = (tgetflag("am") && !tgetflag("xn")); ! 604: PT = tgetflag("pt"); ! 605: #if AMIGA ! 606: amiopenwin(termtype); /* Must run this before ttysetup(); */ ! 607: ttysetup(); /* Must run this before getsize(0); */ ! 608: #endif ! 609: getsize(0); ! 610: ! 611: /* Key sequences */ ! 612: mayhave(&KU, "ku"); /* up */ ! 613: mayhave(&KD, "kd"); /* down */ ! 614: mayhave(&KL, "kl"); /* left */ ! 615: mayhave(&KR, "kr"); /* right */ ! 616: #if COHERENT ! 617: if (KL && KL[0]=='\b' && !KL[1]) ! 618: { ! 619: /* never use '\b' as a left arrow! */ ! 620: KL = (char *)0; ! 621: } ! 622: #else ! 623: if (KR && KR[0]=='\b' && !KR[1]) ! 624: { ! 625: /* never use '\b' as a right arrow! */ ! 626: KR = (char *)0; ! 627: } ! 628: #endif ! 629: mayhave(&PU, "kP"); /* PgUp */ ! 630: mayhave(&PD, "kN"); /* PgDn */ ! 631: mayhave(&HM, "kh"); /* Home */ ! 632: mayhave(&EN, "kH"); /* End */ ! 633: mayhave(&KI, "kI"); /* Insert */ ! 634: #ifndef CRUNCH ! 635: if (!PU) mayhave(&PU, "K2"); /* "3x3 pad" names for PgUp, etc. */ ! 636: if (!PD) mayhave(&PD, "K5"); ! 637: if (!HM) mayhave(&HM, "K1"); ! 638: if (!EN) mayhave(&EN, "K4"); ! 639: ! 640: mayhave(&PU, "PU"); /* old XENIX names for PgUp, etc. */ ! 641: mayhave(&PD, "PD"); /* (overrides others, if used.) */ ! 642: mayhave(&HM, "HM"); ! 643: mayhave(&EN, "EN"); ! 644: #endif ! 645: #ifndef NO_FKEY ! 646: mayhave(&FKEY[0], "k0"); /* function key codes */ ! 647: mayhave(&FKEY[1], "k1"); ! 648: mayhave(&FKEY[2], "k2"); ! 649: mayhave(&FKEY[3], "k3"); ! 650: mayhave(&FKEY[4], "k4"); ! 651: mayhave(&FKEY[5], "k5"); ! 652: mayhave(&FKEY[6], "k6"); ! 653: mayhave(&FKEY[7], "k7"); ! 654: mayhave(&FKEY[8], "k8"); ! 655: mayhave(&FKEY[9], "k9"); ! 656: # ifndef NO_SHIFT_FKEY ! 657: mayhave(&FKEY[10], "s0"); /* shift function key codes */ ! 658: mayhave(&FKEY[11], "s1"); ! 659: mayhave(&FKEY[12], "s2"); ! 660: mayhave(&FKEY[13], "s3"); ! 661: mayhave(&FKEY[14], "s4"); ! 662: mayhave(&FKEY[15], "s5"); ! 663: mayhave(&FKEY[16], "s6"); ! 664: mayhave(&FKEY[17], "s7"); ! 665: mayhave(&FKEY[18], "s8"); ! 666: mayhave(&FKEY[19], "s9"); ! 667: # ifndef NO_CTRL_FKEY ! 668: mayhave(&FKEY[20], "c0"); /* control function key codes */ ! 669: mayhave(&FKEY[21], "c1"); ! 670: mayhave(&FKEY[22], "c2"); ! 671: mayhave(&FKEY[23], "c3"); ! 672: mayhave(&FKEY[24], "c4"); ! 673: mayhave(&FKEY[25], "c5"); ! 674: mayhave(&FKEY[26], "c6"); ! 675: mayhave(&FKEY[27], "c7"); ! 676: mayhave(&FKEY[28], "c8"); ! 677: mayhave(&FKEY[29], "c9"); ! 678: # ifndef NO_ALT_FKEY ! 679: mayhave(&FKEY[30], "a0"); /* alt function key codes */ ! 680: mayhave(&FKEY[31], "a1"); ! 681: mayhave(&FKEY[32], "a2"); ! 682: mayhave(&FKEY[33], "a3"); ! 683: mayhave(&FKEY[34], "a4"); ! 684: mayhave(&FKEY[35], "a5"); ! 685: mayhave(&FKEY[36], "a6"); ! 686: mayhave(&FKEY[37], "a7"); ! 687: mayhave(&FKEY[38], "a8"); ! 688: mayhave(&FKEY[39], "a9"); ! 689: # endif ! 690: # endif ! 691: # endif ! 692: #endif ! 693: ! 694: #ifndef NO_CURSORSHAPE ! 695: /* cursor shapes */ ! 696: CQ = tgetstr("cQ", &capbuf); ! 697: if (has_CQ) ! 698: { ! 699: CX = tgetstr("cX", &capbuf); ! 700: if (!CX) CX = CQ; ! 701: CV = tgetstr("cV", &capbuf); ! 702: if (!CV) CV = CQ; ! 703: CI = tgetstr("cI", &capbuf); ! 704: if (!CI) CI = CQ; ! 705: CR = tgetstr("cR", &capbuf); ! 706: if (!CR) CR = CQ; ! 707: } ! 708: # ifndef CRUNCH ! 709: else ! 710: { ! 711: CQ = CV = ""; ! 712: pair(&CQ, &CV, "ve", "vs"); ! 713: CX = CI = CR = CQ; ! 714: } ! 715: # endif /* !CRUNCH */ ! 716: #endif /* !NO_CURSORSHAPE */ ! 717: ! 718: #ifndef NO_COLOR ! 719: strcpy(SOcolor, SO); ! 720: strcpy(SEcolor, SE); ! 721: strcpy(AScolor, AS); ! 722: strcpy(AEcolor, AE); ! 723: strcpy(MDcolor, MD); ! 724: strcpy(MEcolor, ME); ! 725: strcpy(UScolor, US); ! 726: strcpy(UEcolor, UE); ! 727: # ifndef NO_POPUP ! 728: strcpy(POPUPcolor, SO); ! 729: # endif ! 730: # ifndef NO_VISIBLE ! 731: strcpy(VISIBLEcolor, MV); ! 732: # endif ! 733: #endif ! 734: ! 735: } ! 736: ! 737: ! 738: /* This function gets the window size. It uses the TIOCGWINSZ ioctl call if ! 739: * your system has it, or tgetnum("li") and tgetnum("co") if it doesn't. ! 740: * This function is called once during initialization, and thereafter it is ! 741: * called whenever the SIGWINCH signal is sent to this process. ! 742: */ ! 743: int getsize(signo) ! 744: int signo; ! 745: { ! 746: int lines; ! 747: int cols; ! 748: #ifdef TIOCGWINSZ ! 749: struct winsize size; ! 750: #endif ! 751: ! 752: #ifdef SIGWINCH ! 753: /* reset the signal vector */ ! 754: signal(SIGWINCH, getsize); ! 755: #endif ! 756: ! 757: /* get the window size, one way or another. */ ! 758: lines = cols = 0; ! 759: #ifdef TIOCGWINSZ ! 760: if (ioctl(2, TIOCGWINSZ, &size) >= 0) ! 761: { ! 762: lines = size.ws_row; ! 763: cols = size.ws_col; ! 764: } ! 765: #endif ! 766: #if AMIGA ! 767: /* Amiga gets window size by asking the console.device */ ! 768: if (!strcmp(TERMTYPE, termtype)) ! 769: { ! 770: auto long len; ! 771: auto char buf[30]; ! 772: ! 773: Write(Output(), "\2330 q", 4); /* Ask the console.device */ ! 774: len = Read(Input(), buf, 29); ! 775: buf[len] = '\000'; ! 776: sscanf(&buf[5], "%d;%d", &lines, &cols); ! 777: } ! 778: #endif ! 779: if ((lines == 0 || cols == 0) && signo == 0) ! 780: { ! 781: #if COHERENT ! 782: char * temp; ! 783: ! 784: temp = getenv("COLUMNS"); ! 785: if (temp) ! 786: COLS = atoi(temp); ! 787: else ! 788: COLS = tgetnum("co"); ! 789: ! 790: temp = getenv("LINES"); ! 791: if (temp) ! 792: LINES = atoi(temp); ! 793: else ! 794: LINES = tgetnum("li"); ! 795: #else ! 796: LINES = tgetnum("li"); ! 797: COLS = tgetnum("co"); ! 798: #endif ! 799: } ! 800: #if MSDOS ! 801: # ifdef RAINBOW ! 802: if (!strcmp(termtype, "rainbow")) ! 803: { ! 804: /* Determine whether Rainbow is in 80-column or 132-column mode */ ! 805: cols = *(unsigned char far *)0xee000f57L; ! 806: } ! 807: else ! 808: # endif ! 809: { ! 810: lines = v_rows(); ! 811: cols = v_cols(); ! 812: } ! 813: #endif ! 814: if (lines >= 2 && cols >= 30) ! 815: { ! 816: LINES = lines; ! 817: COLS = cols; ! 818: } ! 819: ! 820: /* Make sure we got values that we can live with */ ! 821: if (LINES < 2 || COLS < 30) ! 822: { ! 823: write(2, "Screen too small\n", (unsigned)17); ! 824: #if OSK ! 825: write(2, "\l", 1); ! 826: #endif ! 827: endwin(); ! 828: exit(2); ! 829: } ! 830: ! 831: #if AMIGA ! 832: if (*o_lines != LINES || *o_columns != COLS) ! 833: { ! 834: *o_lines = LINES; ! 835: *o_columns = COLS; ! 836: } ! 837: #endif ! 838: ! 839: return 0; ! 840: } ! 841: ! 842: ! 843: /* This is a function version of addch() -- it is used by tputs() */ ! 844: int faddch(ch) ! 845: int ch; ! 846: { ! 847: #if 0 ! 848: if (stdscr) ! 849: addch(ch); ! 850: else ! 851: msg("OOPS! tried to access null stdscr"); ! 852: #else ! 853: addch(ch); ! 854: #endif ! 855: ! 856: return 0; ! 857: } ! 858: ! 859: /* This function quickly adds a string to the output queue. It does *NOT* ! 860: * convert \n into <CR><LF>. ! 861: */ ! 862: void qaddstr(str) ! 863: char *str; ! 864: { ! 865: REG char *s_, *d_; ! 866: ! 867: #if MSDOS ! 868: if (o_pcbios[0]) ! 869: { ! 870: while (*str) ! 871: qaddch(*str++); ! 872: return; ! 873: } ! 874: #endif ! 875: for (s_=(str), d_=stdscr; *d_++ = *s_++; ) ! 876: { ! 877: } ! 878: stdscr = d_ - 1; ! 879: } ! 880: ! 881: /* Output the ESC sequence needed to go into any video mode, if supported */ ! 882: void attrset(a) ! 883: int a; ! 884: { ! 885: do_aend(); ! 886: if (a == A_BOLD) ! 887: { ! 888: do_MD(); ! 889: aend = ME; ! 890: } ! 891: else if (a == A_UNDERLINE) ! 892: { ! 893: do_US(); ! 894: aend = UE; ! 895: } ! 896: else if (a == A_ALTCHARSET) ! 897: { ! 898: do_AS(); ! 899: aend = AE; ! 900: } ! 901: else ! 902: { ! 903: aend = ""; ! 904: } ! 905: } ! 906: ! 907: ! 908: /* Insert a single character into the display */ ! 909: void insch(ch) ! 910: int ch; ! 911: { ! 912: if (has_IM) ! 913: do_IM(); ! 914: do_IC(); ! 915: qaddch(ch); ! 916: if (has_EI) ! 917: do_EI(); ! 918: } ! 919: ! 920: void wrefresh() ! 921: { ! 922: if (stdscr != kbuf) ! 923: { ! 924: VOIDBIOS(;,ttywrite(kbuf, (unsigned)(stdscr - kbuf))); ! 925: stdscr = kbuf; ! 926: } ! 927: } ! 928: ! 929: void wqrefresh() ! 930: { ! 931: if (stdscr - kbuf > 2000) ! 932: { ! 933: VOIDBIOS(stdscr = kbuf, ! 934: { ! 935: ttywrite(kbuf, (unsigned)(stdscr - kbuf)); ! 936: stdscr = kbuf; ! 937: }); ! 938: } ! 939: } ! 940: ! 941: #ifndef NO_COLOR ! 942: /* This function is called during termination. It resets color modes */ ! 943: int ansiquit() ! 944: { ! 945: /* if ANSI color terminal, then reset the colors */ ! 946: if (!strcmp(UP, "\033[A")) ! 947: { ! 948: tputs("\033[37;40m\033[m", 1, faddch); ! 949: clrtoeol(); ! 950: return 1; ! 951: } ! 952: return 0; ! 953: } ! 954: ! 955: /* This sets the color strings that work for ANSI terminals. If the TERMCAP ! 956: * doesn't look like an ANSI terminal, then it returns FALSE. If the colors ! 957: * aren't understood, it also returns FALSE. If all goes well, it returns TRUE ! 958: */ ! 959: int ansicolor(cmode, attrbyte) ! 960: int cmode; /* mode to set, e.g. A_NORMAL */ ! 961: int attrbyte; /* IBM PC attribute byte */ ! 962: { ! 963: char temp[16]; /* hold the new mode string */ ! 964: ! 965: /* if not ANSI-ish, then fail */ ! 966: if (strcmp(UP, "\033[A") && strcmp(UP, "\033OA")) ! 967: { ! 968: #if COHERENT ! 969: return 1; ! 970: #else ! 971: msg("Don't know how to set colors for this terminal"); ! 972: return 0; ! 973: #endif ! 974: } ! 975: ! 976: /* construct the color string */ ! 977: sprintf(temp, "\033[m\033[3%c;4%c%s%sm", ! 978: "04261537"[attrbyte & 0x07], ! 979: "04261537"[(attrbyte >> 4) & 0x07], ! 980: (attrbyte & 0x08) ? ";1" : "", ! 981: (attrbyte & 0x80) ? ";5" : ""); ! 982: ! 983: /* stick it in the right place */ ! 984: switch (cmode) ! 985: { ! 986: case A_NORMAL: ! 987: if (!strcmp(MEcolor, normalcolor)) ! 988: strcpy(MEcolor, temp); ! 989: if (!strcmp(UEcolor, normalcolor)) ! 990: strcpy(UEcolor, temp); ! 991: if (!strcmp(AEcolor, normalcolor)) ! 992: strcpy(AEcolor, temp); ! 993: if (!strcmp(SEcolor, normalcolor)) ! 994: strcpy(SEcolor, temp); ! 995: ! 996: strcpy(normalcolor, temp); ! 997: tputs(normalcolor, 1, faddch); ! 998: break; ! 999: ! 1000: case A_BOLD: ! 1001: strcpy(MDcolor, temp); ! 1002: strcpy(MEcolor, normalcolor); ! 1003: break; ! 1004: ! 1005: case A_UNDERLINE: ! 1006: strcpy(UScolor, temp); ! 1007: strcpy(UEcolor, normalcolor); ! 1008: break; ! 1009: ! 1010: case A_ALTCHARSET: ! 1011: strcpy(AScolor, temp); ! 1012: strcpy(AEcolor, normalcolor); ! 1013: break; ! 1014: ! 1015: case A_STANDOUT: ! 1016: strcpy(SOcolor, temp); ! 1017: strcpy(SEcolor, normalcolor); ! 1018: break; ! 1019: ! 1020: #ifndef NO_POPUP ! 1021: case A_POPUP: ! 1022: strcpy(POPUPcolor, temp); ! 1023: break; ! 1024: #endif ! 1025: ! 1026: #ifndef NO_VISIBLE ! 1027: case A_VISIBLE: ! 1028: strcpy(VISIBLEcolor, temp); ! 1029: break; ! 1030: #endif ! 1031: } ! 1032: ! 1033: return 1; ! 1034: } ! 1035: ! 1036: ! 1037: /* This function outputs the ESC sequence needed to switch the screen back ! 1038: * to "normal" mode. On color terminals which haven't had their color set ! 1039: * yet, this is one of the termcap strings; for color terminals that really ! 1040: * have had colors defined, we just the "normal color" escape sequence. ! 1041: */ ! 1042: int ! 1043: endcolor() ! 1044: { ! 1045: if (aend == ME) ! 1046: tputs(MEcolor, 1, faddch); ! 1047: else if (aend == UE) ! 1048: tputs(UEcolor, 1, faddch); ! 1049: else if (aend == AE) ! 1050: tputs(AEcolor, 1, faddch); ! 1051: else if (aend == SE) ! 1052: tputs(SEcolor, 1, faddch); ! 1053: aend = ""; ! 1054: return 0; ! 1055: } ! 1056: ! 1057: ! 1058: #endif /* !NO_COLOR */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.