![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmh.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip|
Return to vmh.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip |
1.1 ! root 1: /* vmh.c - visual front-end to mh */ ! 2: ! 3: /* TODO: ! 4: Pass signals to client during execution ! 5: ! 6: Get stand-alone SO/SE/CE to work under #ifdef SYS5 ! 7: ! 8: Figure out a way for the user to say how big the Scan/Display ! 9: windows should be. ! 10: ! 11: If curses ever gets fixed, then XYZ code can be removed ! 12: */ ! 13: ! 14: #include <curses.h> ! 15: #undef OK /* tricky */ ! 16: #include "../h/mh.h" ! 17: #include "../h/vmhsbr.h" ! 18: #include <ctype.h> ! 19: #include <errno.h> ! 20: #include <setjmp.h> ! 21: #include <signal.h> ! 22: #ifndef sigmask ! 23: #define sigmask(s) (1 << ((s) - 1)) ! 24: #endif not sigmask ! 25: #ifndef BSD42 ! 26: struct iovec { ! 27: char *iov_base; ! 28: int iov_len; ! 29: }; ! 30: #else BSD42 ! 31: #include <sys/types.h> ! 32: #include <sys/uio.h> ! 33: #endif BSD42 ! 34: ! 35: #define ALARM ((unsigned int) 10) ! 36: #define PAUSE ((unsigned int) 2) ! 37: ! 38: #define abs(a) ((a) > 0 ? (a) : -(a)) ! 39: #define SMALLMOVE 1 ! 40: #define LARGEMOVE 10 ! 41: ! 42: ! 43: #define XYZ /* XXX */ ! 44: ! 45: /* */ ! 46: ! 47: static struct swit switches[] = { ! 48: #define PRMPTSW 0 ! 49: "prompt string", 6, ! 50: ! 51: #define PROGSW 1 ! 52: "vmhproc program", 7, ! 53: #define NPROGSW 2 ! 54: "novmhproc", 9, ! 55: ! 56: #define HELPSW 3 ! 57: "help", 4, ! 58: ! 59: NULL, NULL ! 60: }; ! 61: ! 62: /* */ ! 63: /* PEERS */ ! 64: static int PEERpid = NOTOK; ! 65: ! 66: static jmp_buf PEERctx; ! 67: ! 68: ! 69: /* WINDOWS */ ! 70: static char *myprompt = "(%s) "; ! 71: ! 72: static WINDOW *Scan; ! 73: static WINDOW *Status; ! 74: static WINDOW *Display; ! 75: static WINDOW *Command; ! 76: ! 77: #define NWIN 3 ! 78: static int numwins; ! 79: WINDOW *windows[NWIN + 1]; ! 80: ! 81: ! 82: /* LINES */ ! 83: ! 84: struct line { ! 85: int l_no; ! 86: char *l_buf; ! 87: struct line *l_prev; ! 88: struct line *l_next; ! 89: }; ! 90: ! 91: static struct line *lhead = NULL; ! 92: static struct line *ltop = NULL; ! 93: static struct line *ltail = NULL; ! 94: ! 95: static int did_less = 0; ! 96: static int smallmove = SMALLMOVE; ! 97: static int largemove = LARGEMOVE; ! 98: ! 99: ! 100: /* TTYS */ ! 101: ! 102: static int tty_ready = NOTOK; ! 103: ! 104: static int intrc; ! 105: #ifndef SYS5 ! 106: #define ERASE sg.sg_erase ! 107: #define KILL sg.sg_kill ! 108: static struct sgttyb sg; ! 109: ! 110: #define EOFC tc.t_eofc ! 111: #define INTR tc.t_intrc ! 112: static struct tchars tc; ! 113: #else SYS5 ! 114: #define ERASE sg.c_cc[VERASE] ! 115: #define KILL sg.c_cc[VKILL] ! 116: #define EOFC sg.c_cc[VEOF] ! 117: #define INTR sg.c_cc[VINTR] ! 118: static struct termio sg; ! 119: #endif SYS5 ! 120: ! 121: #ifndef TIOCGLTC ! 122: #define WERASC ('W' & 037) ! 123: #else TIOCGLTC ! 124: #define WERASC ltc.t_werasc ! 125: static struct ltchars ltc; ! 126: #endif TIOCGLTC ! 127: ! 128: ! 129: #ifndef SYS5 ! 130: int _putchar (); ! 131: #endif not SYS5 ! 132: char *tgoto (); ! 133: ! 134: ! 135: /* SIGNALS */ ! 136: int ALRMser (), PIPEser (), SIGser (); ! 137: #ifdef SIGTSTP ! 138: int TSTPser (); ! 139: #endif SIGTSTP ! 140: ! 141: ! 142: /* MISCELLANY */ ! 143: extern int errno; ! 144: extern int sys_nerr; ! 145: extern char *sys_errlist[]; ! 146: ! 147: void adorn (); ! 148: ! 149: /* */ ! 150: ! 151: /* ARGSUSED */ ! 152: ! 153: main (argc, argv) ! 154: int argc; ! 155: char *argv[]; ! 156: { ! 157: int vecp = 1, ! 158: nprog = 0; ! 159: char *cp, ! 160: buffer[BUFSIZ], ! 161: **ap, ! 162: **argp, ! 163: *arguments[MAXARGS], ! 164: *vec[MAXARGS]; ! 165: ! 166: invo_name = r1bindex (argv[0], '/'); ! 167: if ((cp = m_find (invo_name)) != NULL) { ! 168: ap = brkstring (cp = getcpy (cp), " ", "\n"); ! 169: ap = copyip (ap, arguments); ! 170: } ! 171: else ! 172: ap = arguments; ! 173: (void) copyip (argv + 1, ap); ! 174: argp = arguments; ! 175: ! 176: /* */ ! 177: ! 178: while (cp = *argp++) ! 179: if (*cp == '-') ! 180: switch (smatch (++cp, switches)) { ! 181: case AMBIGSW: ! 182: ambigsw (cp, switches); ! 183: done (1); ! 184: case UNKWNSW: ! 185: vec[vecp++] = --cp; ! 186: continue; ! 187: case HELPSW: ! 188: (void) sprintf (buffer, "%s [switches for vmhproc]", ! 189: invo_name); ! 190: help (buffer, switches); ! 191: done (1); ! 192: ! 193: case PRMPTSW: ! 194: if (!(myprompt = *argp++) || *myprompt == '-') ! 195: adios (NULLCP, "missing argument to %s", argp[-2]); ! 196: continue; ! 197: ! 198: case PROGSW: ! 199: if (!(vmhproc = *argp++) || *vmhproc == '-') ! 200: adios (NULLCP, "missing argument to %s", argp[-2]); ! 201: continue; ! 202: case NPROGSW: ! 203: nprog++; ! 204: continue; ! 205: } ! 206: else ! 207: vec[vecp++] = cp; ! 208: ! 209: /* */ ! 210: ! 211: if (TTYinit (nprog) == NOTOK || WINinit (nprog) == NOTOK) { ! 212: vec[vecp] = NULL; ! 213: ! 214: vec[0] = r1bindex (vmhproc, '/'); ! 215: execvp (vmhproc, vec); ! 216: adios (vmhproc, "unable to exec"); ! 217: } ! 218: TTYoff (); ! 219: (void) PEERinit (vecp, vec); ! 220: TTYon (); ! 221: ! 222: vmh (); ! 223: ! 224: done (0); ! 225: } ! 226: ! 227: /* */ ! 228: ! 229: static vmh () { ! 230: char buffer[BUFSIZ]; ! 231: ! 232: for (;;) { ! 233: (void) pLOOP (RC_QRY, NULLCP); ! 234: ! 235: wmove (Command, 0, 0); ! 236: wprintw (Command, myprompt, invo_name); ! 237: wclrtoeol (Command); ! 238: wrefresh (Command); ! 239: ! 240: switch (WINgetstr (Command, buffer)) { ! 241: case NOTOK: ! 242: break; ! 243: ! 244: case OK: ! 245: done (0); /* NOTREACHED */ ! 246: ! 247: default: ! 248: if (*buffer) ! 249: (void) pLOOP (RC_CMD, buffer); ! 250: break; ! 251: } ! 252: } ! 253: } ! 254: ! 255: /* PEERS */ ! 256: ! 257: static int PEERinit (vecp, vec) ! 258: int vecp; ! 259: char *vec[]; ! 260: { ! 261: int pfd0[2], ! 262: pfd1[2]; ! 263: char buf1[BUFSIZ], ! 264: buf2[BUFSIZ]; ! 265: ! 266: if (pipe (pfd0) == NOTOK || pipe (pfd1) == NOTOK) ! 267: adios ("pipe", "unable to"); ! 268: switch (PEERpid = vfork ()) { ! 269: case NOTOK: ! 270: adios ("vfork", "unable to");/* NOTREACHED */ ! 271: ! 272: case OK: ! 273: (void) close (pfd0[0]); ! 274: (void) close (pfd1[1]); ! 275: ! 276: vec[vecp++] = "-vmhread"; ! 277: (void) sprintf (buf1, "%d", pfd1[0]); ! 278: vec[vecp++] = buf1; ! 279: vec[vecp++] = "-vmhwrite"; ! 280: (void) sprintf (buf2, "%d", pfd0[1]); ! 281: vec[vecp++] = buf2; ! 282: vec[vecp] = NULL; ! 283: ! 284: (void) signal (SIGINT, SIG_DFL); ! 285: (void) signal (SIGQUIT, SIG_DFL); ! 286: ! 287: vec[0] = r1bindex (vmhproc, '/'); ! 288: execvp (vmhproc, vec); ! 289: perror (vmhproc); ! 290: _exit (-1); /* NOTREACHED */ ! 291: ! 292: default: ! 293: (void) close (pfd0[1]); ! 294: (void) close (pfd1[0]); ! 295: ! 296: (void) rcinit (pfd0[0], pfd1[1]); ! 297: return pINI (); ! 298: } ! 299: } ! 300: ! 301: /* */ ! 302: ! 303: static int pINI () { ! 304: register char *bp; ! 305: char buffer[BUFSIZ]; ! 306: struct record rcs; ! 307: register struct record *rc = &rcs; ! 308: register WINDOW **w; ! 309: ! 310: initrc (rc); ! 311: ! 312: bp = buffer; ! 313: (void) sprintf (bp, "%d %d", RC_VRSN, numwins); ! 314: bp += strlen (bp); ! 315: for (w = windows; *w; w++) { ! 316: (void) sprintf (bp, " %d", (*w) -> _maxy); ! 317: bp += strlen (bp); ! 318: } ! 319: ! 320: switch (str2rc (RC_INI, buffer, rc)) { ! 321: case RC_ACK: ! 322: return OK; ! 323: ! 324: case RC_ERR: ! 325: if (rc -> rc_len) ! 326: adios (NULLCP, "%s", rc -> rc_data); ! 327: else ! 328: adios (NULLCP, "pINI peer error"); ! 329: ! 330: case RC_XXX: ! 331: adios (NULLCP, "%s", rc -> rc_data); ! 332: ! 333: default: ! 334: adios (NULLCP, "pINI protocol screw-up"); ! 335: } ! 336: /* NOTREACHED */ ! 337: } ! 338: ! 339: /* */ ! 340: ! 341: static int pLOOP (code, str) ! 342: char code, ! 343: *str; ! 344: { ! 345: int i; ! 346: struct record rcs; ! 347: register struct record *rc = &rcs; ! 348: ! 349: initrc (rc); ! 350: ! 351: (void) str2peer (code, str); ! 352: for (;;) ! 353: switch (peer2rc (rc)) { ! 354: case RC_TTY: ! 355: if (pTTY (rc) == NOTOK) ! 356: return NOTOK; ! 357: break; ! 358: ! 359: case RC_WIN: ! 360: if (sscanf (rc -> rc_data, "%d", &i) != 1 ! 361: || i <= 0 ! 362: || i > numwins) { ! 363: (void) fmt2peer (RC_ERR, "no such window \"%s\"", ! 364: rc -> rc_data); ! 365: return NOTOK; ! 366: } ! 367: if (pWIN (windows[i - 1]) == NOTOK) ! 368: return NOTOK; ! 369: break; ! 370: ! 371: case RC_EOF: ! 372: return OK; ! 373: ! 374: case RC_ERR: ! 375: if (rc -> rc_len) ! 376: adorn (NULLCP, "%s", rc -> rc_data); ! 377: else ! 378: adorn (NULLCP, "pLOOP(%s) peer error", ! 379: code == RC_QRY ? "QRY" : "CMD"); ! 380: return NOTOK; ! 381: ! 382: case RC_FIN: ! 383: if (rc -> rc_len) ! 384: adorn (NULLCP, "%s", rc -> rc_data); ! 385: (void) rcdone (); ! 386: i = pidwait (PEERpid, OK); ! 387: PEERpid = NOTOK; ! 388: done (i); ! 389: ! 390: case RC_XXX: ! 391: adios (NULLCP, "%s", rc -> rc_data); ! 392: ! 393: default: ! 394: adios (NULLCP, "pLOOP(%s) protocol screw-up", ! 395: code == RC_QRY ? "QRY" : "CMD"); ! 396: } ! 397: } ! 398: ! 399: /* */ ! 400: ! 401: static int pTTY (r) ! 402: register struct record *r; ! 403: { ! 404: int (*hstat) (), (*istat) (), (*qstat) (), (*tstat) (); ! 405: struct record rcs; ! 406: register struct record *rc = &rcs; ! 407: ! 408: initrc (rc); ! 409: ! 410: TTYoff (); ! 411: ! 412: hstat = signal (SIGHUP, SIG_IGN); ! 413: istat = signal (SIGINT, SIG_IGN); ! 414: qstat = signal (SIGQUIT, SIG_IGN); ! 415: tstat = signal (SIGTERM, SIG_IGN); ! 416: ! 417: (void) rc2rc (RC_ACK, 0, NULLCP, rc); ! 418: ! 419: (void) signal (SIGHUP, hstat); ! 420: (void) signal (SIGINT, istat); ! 421: (void) signal (SIGQUIT, qstat); ! 422: (void) signal (SIGTERM, tstat); ! 423: ! 424: TTYon (); ! 425: ! 426: if (r -> rc_len && strcmp (r -> rc_data, "FAST") == 0) ! 427: goto no_refresh; ! 428: ! 429: #ifdef SIGTSTP ! 430: (void) signal (SIGTSTP, SIG_IGN); ! 431: #endif SIGTSTP ! 432: #ifndef SYS5 ! 433: if (SO) ! 434: tputs (SO, 0, _putchar); ! 435: #endif not SYS5 ! 436: fprintf (stdout, "Type any key to continue... "); ! 437: (void) fflush (stdout); ! 438: #ifndef SYS5 ! 439: if (SE) ! 440: tputs (SE, 0, _putchar); ! 441: #endif not SYS5 ! 442: (void) getc (stdin); ! 443: #ifdef SIGTSTP ! 444: (void) signal (SIGTSTP, TSTPser); ! 445: #endif SIGTSTP ! 446: ! 447: wrefresh (curscr); ! 448: ! 449: no_refresh: ; ! 450: switch (rc -> rc_type) { ! 451: case RC_EOF: ! 452: (void) rc2peer (RC_ACK, 0, NULLCP); ! 453: return OK; ! 454: ! 455: case RC_ERR: ! 456: if (rc -> rc_len) ! 457: adorn (NULLCP, "%s", rc -> rc_data); ! 458: else ! 459: adorn (NULLCP, "pTTY peer error"); ! 460: return NOTOK; ! 461: ! 462: case RC_XXX: ! 463: adios (NULLCP, "%s", rc -> rc_data); ! 464: ! 465: default: ! 466: adios (NULLCP, "pTTY protocol screw-up"); ! 467: } ! 468: /* NOTREACHED */ ! 469: } ! 470: ! 471: /* */ ! 472: ! 473: static int pWIN (w) ! 474: register WINDOW *w; ! 475: { ! 476: int i; ! 477: ! 478: did_less = 0; ! 479: if ((i = pWINaux (w)) == OK && did_less) ! 480: (void) WINless (w, 1); ! 481: ! 482: lreset (); ! 483: ! 484: return i; ! 485: } ! 486: ! 487: /* */ ! 488: ! 489: static int pWINaux (w) ! 490: register WINDOW *w; ! 491: { ! 492: register int n; ! 493: int eol; ! 494: register char c, ! 495: *bp; ! 496: struct record rcs; ! 497: register struct record *rc = &rcs; ! 498: ! 499: initrc (rc); ! 500: ! 501: werase (w); ! 502: wmove (w, 0, 0); ! 503: #ifdef XYZ ! 504: if (w == Status) ! 505: wstandout (w); ! 506: #endif XYZ ! 507: ! 508: for (eol = 0;;) ! 509: switch (rc2rc (RC_ACK, 0, NULLCP, rc)) { ! 510: case RC_DATA: ! 511: if (eol && WINputc (w, '\n') == ERR && WINless (w, 0)) ! 512: goto flush; ! 513: for (bp = rc -> rc_data, n = rc -> rc_len; n-- > 0; ) { ! 514: if ((c = *bp++) == '\n') ! 515: linsert (w); ! 516: if (WINputc (w, c) == ERR) ! 517: if (n == 0 && c == '\n') ! 518: eol++; ! 519: else ! 520: if (WINless (w, 0)) { ! 521: flush: ; ! 522: (void) fmt2peer (RC_ERR, "flush window"); ! 523: #ifdef XYZ /* should NEVER happen... */ ! 524: if (w == Status) ! 525: wstandend (w); ! 526: #endif XYZ ! 527: wrefresh (w); ! 528: return NOTOK; ! 529: } ! 530: } ! 531: break; ! 532: ! 533: case RC_EOF: ! 534: (void) rc2peer (RC_ACK, 0, NULLCP); ! 535: #ifdef XYZ ! 536: if (w == Status) ! 537: wstandend (w); ! 538: #endif XYZ ! 539: wrefresh (w); ! 540: return OK; ! 541: ! 542: case RC_ERR: ! 543: if (rc -> rc_len) ! 544: adorn (NULLCP, "%s", rc -> rc_data); ! 545: else ! 546: adorn (NULLCP, "pWIN peer error"); ! 547: return NOTOK; ! 548: ! 549: case RC_XXX: ! 550: adios (NULLCP, "%s", rc -> rc_data); ! 551: ! 552: default: ! 553: adios (NULLCP, "pWIN protocol screw-up"); ! 554: } ! 555: /* NOTREACHED */ ! 556: } ! 557: ! 558: /* */ ! 559: ! 560: static int pFIN () { ! 561: int status; ! 562: ! 563: if (PEERpid <= OK) ! 564: return OK; ! 565: ! 566: (void) rc2peer (RC_FIN, 0, NULLCP); ! 567: (void) rcdone (); ! 568: ! 569: switch (setjmp (PEERctx)) { ! 570: case OK: ! 571: (void) signal (SIGALRM, ALRMser); ! 572: (void) alarm (ALARM); ! 573: ! 574: status = pidwait (PEERpid, OK); ! 575: ! 576: (void) alarm (0); ! 577: break; ! 578: ! 579: default: ! 580: (void) kill (PEERpid, SIGKILL); ! 581: status = NOTOK; ! 582: break; ! 583: } ! 584: PEERpid = NOTOK; ! 585: ! 586: return status; ! 587: } ! 588: ! 589: /* WINDOWS */ ! 590: ! 591: static int WINinit (nprog) { ! 592: register int lines, ! 593: top, ! 594: bottom; ! 595: ! 596: foreground (); ! 597: if (initscr () == ERR) ! 598: if (nprog) ! 599: return NOTOK; ! 600: else ! 601: adios (NULLCP, "could not initialize terminal"); ! 602: #ifdef SIGTSTP ! 603: (void) signal (SIGTSTP, SIG_DFL); ! 604: #endif SIGTSTP ! 605: sideground (); ! 606: ! 607: if (CM == NULL) ! 608: if (nprog) ! 609: return NOTOK; ! 610: else ! 611: adios (NULLCP, ! 612: "sorry, your terminal isn't powerful enough to run %s", ! 613: invo_name); ! 614: ! 615: #ifndef SYS5 ! 616: if (tgetflag ("xt") || tgetnum ("sg") > 0) ! 617: SO = SE = US = UE = NULL; ! 618: #endif not SYS5 ! 619: ! 620: if ((lines = LINES - 1) < 11) ! 621: adios (NULLCP, "screen too small"); ! 622: if ((top = lines / 3 + 1) > LINES / 4 + 2) ! 623: top--; ! 624: bottom = lines - top - 2; ! 625: ! 626: numwins = 0; ! 627: Scan = windows[numwins++] = newwin (top, COLS, 0, 0); ! 628: Status = windows[numwins++] = newwin (1, COLS, top, 0); ! 629: #ifndef XYZ ! 630: wstandout (Status); ! 631: #endif XYZ ! 632: Display = windows[numwins++] = newwin (bottom, COLS, top + 1, 0); ! 633: Command = newwin (1, COLS - 1, top + 1 + bottom, 0); ! 634: windows[numwins] = NULL; ! 635: ! 636: largemove = Display -> _maxy / 2 + 2; ! 637: return OK; ! 638: } ! 639: ! 640: /* */ ! 641: ! 642: static int WINgetstr (w, buffer) ! 643: register WINDOW *w; ! 644: char *buffer; ! 645: { ! 646: register int c; ! 647: register char *bp; ! 648: ! 649: bp = buffer; ! 650: *bp = NULL; ! 651: ! 652: for (;;) { ! 653: switch (c = toascii (wgetch (w))) { ! 654: case ERR: ! 655: adios (NULLCP, "wgetch lost"); ! 656: ! 657: case '\f': ! 658: wrefresh (curscr); ! 659: break; ! 660: ! 661: case '\r': ! 662: case '\n': ! 663: *bp = NULL; ! 664: if (bp > buffer) { ! 665: leaveok (curscr, FALSE); ! 666: wmove (w, 0, w -> _curx - (bp - buffer)); ! 667: wrefresh (w); ! 668: leaveok (curscr, TRUE); ! 669: } ! 670: return DONE; ! 671: ! 672: default: ! 673: if (c == intrc) { ! 674: wprintw (w, " "); ! 675: wstandout (w); ! 676: wprintw (w, "Interrupt"); ! 677: wstandend (w); ! 678: wrefresh (w); ! 679: *buffer = NULL; ! 680: return NOTOK; ! 681: } ! 682: if (c == EOFC) { ! 683: if (bp <= buffer) ! 684: return OK; ! 685: break; ! 686: } ! 687: if (c == ERASE) { ! 688: if (bp <= buffer) ! 689: continue; ! 690: bp--, w -> _curx--; ! 691: wclrtoeol (w); ! 692: break; ! 693: } ! 694: if (c == KILL) { ! 695: if (bp <= buffer) ! 696: continue; ! 697: w -> _curx -= bp - buffer; ! 698: bp = buffer; ! 699: wclrtoeol (w); ! 700: break; ! 701: } ! 702: if (c == WERASC) { ! 703: if (bp <= buffer) ! 704: continue; ! 705: do { ! 706: bp--, w -> _curx--; ! 707: } while (isspace (*bp) && bp > buffer); ! 708: ! 709: if (bp > buffer) { ! 710: do { ! 711: bp--, w -> _curx--; ! 712: } while (!isspace (*bp) && bp > buffer); ! 713: if (isspace (*bp)) ! 714: bp++, w -> _curx++; ! 715: } ! 716: wclrtoeol (w); ! 717: break; ! 718: } ! 719: ! 720: if (c >= ' ') ! 721: (void) waddch (w, *bp++ = c); ! 722: break; ! 723: } ! 724: ! 725: wrefresh (w); ! 726: } ! 727: } ! 728: ! 729: /* */ ! 730: ! 731: static int WINwritev (w, iov, n) ! 732: register WINDOW *w; ! 733: register struct iovec *iov; ! 734: register int n; ! 735: { ! 736: register int i; ! 737: ! 738: werase (w); ! 739: wmove (w, 0, 0); ! 740: for (i = 0; i < n; i++, iov++) ! 741: wprintw (w, "%*.*s", iov -> iov_len, iov -> iov_len, iov -> iov_base); ! 742: wrefresh (w); ! 743: ! 744: sleep (PAUSE); ! 745: ! 746: return OK; ! 747: } ! 748: ! 749: /* */ ! 750: ! 751: static struct { ! 752: char *h_msg; ! 753: int *h_val; ! 754: } hlpmsg[] = { ! 755: " forward backwards", NULL, ! 756: " ------- ---------", NULL, ! 757: "next screen SPACE", NULL, ! 758: "next %d line%s RETURN y", &smallmove, ! 759: "next %d line%s EOT u", &largemove, ! 760: "go g G", NULL, ! 761: "", NULL, ! 762: "refresh CTRL-L", NULL, ! 763: "quit q", NULL, ! 764: ! 765: NULL, NULL ! 766: }; ! 767: ! 768: /* */ ! 769: ! 770: static int WINless (w, fin) ! 771: register WINDOW *w; ! 772: int fin; ! 773: { ! 774: register int c, ! 775: i, ! 776: n; ! 777: int nfresh, ! 778: #ifdef notdef ! 779: nlatch, ! 780: #endif notdef ! 781: nwait; ! 782: char *cp; ! 783: register struct line *lbottom; ! 784: ! 785: did_less++; ! 786: ! 787: cp = NULL; ! 788: #ifdef notdef ! 789: if (fin) ! 790: ltop = NULL; ! 791: #endif notdef ! 792: lbottom = NULL; ! 793: nfresh = 1; ! 794: nwait = 0; ! 795: wrefresh (w); ! 796: ! 797: for (;;) { ! 798: if (nfresh || nwait) { ! 799: nfresh = 0; ! 800: #ifdef notdef ! 801: nlatch = 1; ! 802: ! 803: once_only: ; ! 804: #endif notdef ! 805: werase (w); ! 806: wmove (w, 0, 0); ! 807: ! 808: if (ltop == NULL) ! 809: if (fin) { ! 810: (void) lgo (ltail -> l_no - w -> _maxy + 1); ! 811: if (ltop == NULL) ! 812: ltop = lhead; ! 813: } ! 814: else ! 815: ltop = lbottom && lbottom -> l_prev ? lbottom -> l_prev ! 816: : lbottom; ! 817: ! 818: for (lbottom = ltop; lbottom; lbottom = lbottom -> l_next) ! 819: if (waddstr (w, lbottom -> l_buf) == ERR ! 820: || waddch (w, '\n') == ERR) ! 821: break; ! 822: if (lbottom == NULL) ! 823: if (fin) { ! 824: #ifdef notdef ! 825: if (nlatch && (ltail -> l_no >= w -> _maxy)) { ! 826: (void) lgo (ltail -> l_no - w -> _maxy + 1); ! 827: nlatch = 0; ! 828: goto once_only; ! 829: } ! 830: #endif notdef ! 831: lbottom = ltail; ! 832: while (waddstr (w, "~\n") != ERR) ! 833: continue; ! 834: } ! 835: else { ! 836: wrefresh (w); ! 837: return 0; ! 838: } ! 839: ! 840: if (!nwait) ! 841: wrefresh (w); ! 842: } ! 843: ! 844: wmove (Command, 0, 0); ! 845: if (cp) { ! 846: wstandout (Command); ! 847: wprintw (Command, "%s", cp); ! 848: wstandend (Command); ! 849: cp = NULL; ! 850: } ! 851: else ! 852: wprintw (Command, fin ? "top:%d bot:%d end:%d" : "top:%d bot:%d", ! 853: ltop -> l_no, lbottom -> l_no, ltail -> l_no); ! 854: wprintw (Command, ">> "); ! 855: wclrtoeol (Command); ! 856: wrefresh (Command); ! 857: ! 858: c = toascii (wgetch (Command)); ! 859: ! 860: werase (Command); ! 861: wrefresh (Command); ! 862: ! 863: if (nwait) { ! 864: nwait = 0; ! 865: wrefresh (w); ! 866: } ! 867: ! 868: n = 0; ! 869: again: ; ! 870: switch (c) { ! 871: case ' ': ! 872: ltop = lbottom -> l_next; ! 873: nfresh++; ! 874: break; ! 875: ! 876: case '\r': ! 877: case '\n': ! 878: case 'e': ! 879: case 'j': ! 880: if (n) ! 881: smallmove = n; ! 882: if (ladvance (smallmove)) ! 883: nfresh++; ! 884: break; ! 885: ! 886: case 'y': ! 887: case 'k': ! 888: if (n) ! 889: smallmove = n; ! 890: if (lretreat (smallmove)) ! 891: nfresh++; ! 892: break; ! 893: ! 894: case 'd': ! 895: eof: ; ! 896: if (n) ! 897: largemove = n; ! 898: if (ladvance (largemove)) ! 899: nfresh++; ! 900: break; ! 901: ! 902: case 'u': ! 903: if (n) ! 904: largemove = n; ! 905: if (lretreat (largemove)) ! 906: nfresh++; ! 907: break; ! 908: ! 909: case 'g': ! 910: if (lgo (n ? n : 1)) ! 911: nfresh++; ! 912: break; ! 913: ! 914: case 'G': ! 915: if (lgo (n ? n : ltail -> l_no - w -> _maxy + 1)) ! 916: nfresh++; ! 917: break; ! 918: ! 919: case '\f': ! 920: case 'r': ! 921: wrefresh (curscr); ! 922: break; ! 923: ! 924: case 'h': ! 925: case '?': ! 926: werase (w); ! 927: wmove (w, 0, 0); ! 928: for (i = 0; hlpmsg[i].h_msg; i++) { ! 929: if (hlpmsg[i].h_val) ! 930: wprintw (w, hlpmsg[i].h_msg, *hlpmsg[i].h_val, ! 931: *hlpmsg[i].h_val != 1 ? "s" : ""); ! 932: else ! 933: (void) waddstr (w, hlpmsg[i].h_msg); ! 934: (void) waddch (w, '\n'); ! 935: } ! 936: wrefresh (w); ! 937: nwait++; ! 938: break; ! 939: ! 940: case 'q': ! 941: return 1; ! 942: ! 943: default: ! 944: if (c == EOFC) ! 945: goto eof; ! 946: ! 947: if (isdigit (c)) { ! 948: wmove (Command, 0, 0); ! 949: i = 0; ! 950: while (isdigit (c)) { ! 951: wprintw (Command, "%c", c); ! 952: wrefresh (Command); ! 953: i = i * 10 + c - '0'; ! 954: c = toascii (wgetch (Command)); ! 955: } ! 956: werase (Command); ! 957: wrefresh (Command); ! 958: ! 959: if (i > 0) { ! 960: n = i; ! 961: goto again; ! 962: } ! 963: cp = "bad number"; ! 964: } ! 965: else ! 966: cp = "not understood"; ! 967: break; ! 968: } ! 969: } ! 970: } ! 971: ! 972: /* */ ! 973: ! 974: static int WINputc (w, c) ! 975: register WINDOW *w; ! 976: register char c; ! 977: { ! 978: register int x, ! 979: y; ! 980: ! 981: if (w != Scan) ! 982: return waddch (w, c); ! 983: ! 984: if ((x = w -> _curx) < 0 || x >= w -> _maxx ! 985: || (y = w -> _cury) < 0 || y >= w -> _maxy) ! 986: return DONE; ! 987: ! 988: switch (c) { ! 989: case '\t': ! 990: for (x = 8 - (x & 0x07); x > 0; x--) ! 991: if (WINputc (w, ' ') == ERR) ! 992: return ERR; ! 993: break; ! 994: ! 995: case '\n': ! 996: if (++y < w -> _maxy) ! 997: (void) waddch (w, c); ! 998: else ! 999: wclrtoeol (w); ! 1000: break; ! 1001: ! 1002: default: ! 1003: if (++x < w -> _maxx) ! 1004: (void) waddch (w, c); ! 1005: break; ! 1006: } ! 1007: return DONE; ! 1008: } ! 1009: ! 1010: /* LINES */ ! 1011: ! 1012: static lreset () { ! 1013: register struct line *lp, ! 1014: *mp; ! 1015: ! 1016: for (lp = lhead; lp; lp = mp) { ! 1017: mp = lp -> l_next; ! 1018: free (lp -> l_buf); ! 1019: free ((char *) lp); ! 1020: } ! 1021: lhead = ltop = ltail = NULL; ! 1022: } ! 1023: ! 1024: ! 1025: static linsert (w) ! 1026: WINDOW *w; ! 1027: { ! 1028: register char *cp; ! 1029: register struct line *lp; ! 1030: ! 1031: if ((lp = (struct line *) calloc ((unsigned) 1, sizeof *lp)) == NULL) ! 1032: adios (NULLCP, "unable to allocate line storage"); ! 1033: ! 1034: lp -> l_no = (ltail ? ltail -> l_no : 0) + 1; ! 1035: lp -> l_buf = getcpy (w -> _y[w -> _cury]); ! 1036: for (cp = lp -> l_buf + strlen (lp -> l_buf) - 1; cp >= lp -> l_buf; cp--) ! 1037: if (isspace (*cp)) ! 1038: *cp = NULL; ! 1039: else ! 1040: break; ! 1041: ! 1042: if (lhead == NULL) ! 1043: lhead = lp; ! 1044: if (ltop == NULL) ! 1045: ltop = lp; ! 1046: if (ltail) ! 1047: ltail -> l_next = lp; ! 1048: lp -> l_prev = ltail; ! 1049: ltail = lp; ! 1050: } ! 1051: ! 1052: /* */ ! 1053: ! 1054: static int ladvance (n) ! 1055: int n; ! 1056: { ! 1057: register int i; ! 1058: register struct line *lp; ! 1059: ! 1060: for (i = 0, lp = ltop; i < n && lp; i++, lp = lp -> l_next) ! 1061: continue; ! 1062: ! 1063: if (ltop == lp) ! 1064: return 0; ! 1065: ! 1066: ltop = lp; ! 1067: return 1; ! 1068: } ! 1069: ! 1070: ! 1071: static int lretreat (n) ! 1072: int n; ! 1073: { ! 1074: register int i; ! 1075: register struct line *lp; ! 1076: ! 1077: for (i = 0, lp = ltop; i < n && lp; i++, lp = lp -> l_prev) ! 1078: if (!lp -> l_prev) ! 1079: break; ! 1080: ! 1081: if (ltop == lp) ! 1082: return 0; ! 1083: ! 1084: ltop = lp; ! 1085: return 1; ! 1086: } ! 1087: ! 1088: /* */ ! 1089: ! 1090: static int lgo (n) ! 1091: int n; ! 1092: { ! 1093: register int i, ! 1094: j; ! 1095: register struct line *lp; ! 1096: ! 1097: if ((i = n - (lp = lhead) -> l_no) > (j = abs (n - ltop -> l_no))) ! 1098: i = j, lp = ltop; ! 1099: if (i > (j = abs (ltail -> l_no - n))) ! 1100: i = j, lp = ltail; ! 1101: ! 1102: if (n >= lp -> l_no) { ! 1103: for (; lp; lp = lp -> l_next) ! 1104: if (lp -> l_no == n) ! 1105: break; ! 1106: } ! 1107: else { ! 1108: for (; lp; lp = lp -> l_prev) ! 1109: if (lp -> l_no == n) ! 1110: break; ! 1111: if (!lp) ! 1112: lp = lhead; ! 1113: } ! 1114: ! 1115: if (ltop == lp) ! 1116: return 0; ! 1117: ! 1118: ltop = lp; ! 1119: return 1; ! 1120: } ! 1121: ! 1122: /* TTYS */ ! 1123: ! 1124: static int TTYinit (nprog) { ! 1125: if (!isatty (fileno (stdin)) || !isatty (fileno (stdout))) ! 1126: if (nprog) ! 1127: return NOTOK; ! 1128: else ! 1129: adios (NULLCP, "not a tty"); ! 1130: ! 1131: foreground (); ! 1132: #ifndef SYS5 ! 1133: if (ioctl (fileno (stdin), TIOCGETP, (char *) &sg) == NOTOK) ! 1134: adios ("failed", "ioctl TIOCGETP"); ! 1135: if (ioctl (fileno (stdin), TIOCGETC, (char *) &tc) == NOTOK) ! 1136: adios ("failed", "ioctl TIOCGETC"); ! 1137: #else SYS5 ! 1138: if (ioctl (fileno (stdin), TCGETA, &sg) == NOTOK) ! 1139: adios ("failed", "ioctl TCGETA"); ! 1140: #endif SYS5 ! 1141: #ifdef TIOCGLTC ! 1142: if (ioctl (fileno (stdin), TIOCGLTC, (char *) <c) == NOTOK) ! 1143: adios ("failed", "ioctl TIOCGLTC"); ! 1144: #endif TIOCGLTC ! 1145: intrc = INTR; ! 1146: sideground (); ! 1147: ! 1148: tty_ready = OK; ! 1149: ! 1150: (void) signal (SIGPIPE, PIPEser); ! 1151: ! 1152: return OK; ! 1153: } ! 1154: ! 1155: /* */ ! 1156: ! 1157: static TTYon () { ! 1158: if (tty_ready == DONE) ! 1159: return; ! 1160: ! 1161: INTR = NOTOK; ! 1162: #ifndef SYS5 ! 1163: (void) ioctl (fileno (stdin), TIOCSETC, (char *) &tc); ! 1164: #else SYS5 ! 1165: (void) ioctl (fileno (stdin), TCSETA, &sg); ! 1166: #endif SYS5 ! 1167: ! 1168: (void) crmode (); ! 1169: (void) noecho (); ! 1170: (void) nonl (); ! 1171: scrollok (curscr, FALSE); ! 1172: ! 1173: discard (stdin); ! 1174: ! 1175: tty_ready = DONE; ! 1176: ! 1177: (void) signal (SIGHUP, SIGser); ! 1178: (void) signal (SIGINT, SIGser); ! 1179: (void) signal (SIGQUIT, SIGser); ! 1180: #ifdef SIGTSTP ! 1181: (void) signal (SIGTSTP, TSTPser); ! 1182: #endif SIGTSTP ! 1183: } ! 1184: ! 1185: /* */ ! 1186: ! 1187: static TTYoff () { ! 1188: if (tty_ready == NOTOK) ! 1189: return; ! 1190: ! 1191: INTR = intrc; ! 1192: #ifndef SYS5 ! 1193: (void) ioctl (fileno (stdin), TIOCSETC, (char *) &tc); ! 1194: #else SYS5 ! 1195: (void) ioctl (fileno (stdin), TCSETA, &sg); ! 1196: #endif SYS5 ! 1197: ! 1198: leaveok (curscr, TRUE); ! 1199: mvcur (0, COLS - 1, LINES - 1, 0); ! 1200: endwin (); ! 1201: if (tty_ready == DONE) { ! 1202: #ifndef SYS5 ! 1203: if (CE) ! 1204: tputs (CE, 0, _putchar); ! 1205: else ! 1206: #endif SYS5 ! 1207: fprintf (stdout, "\r\n"); ! 1208: } ! 1209: (void) fflush (stdout); ! 1210: ! 1211: tty_ready = NOTOK; ! 1212: ! 1213: (void) signal (SIGHUP, SIG_DFL); ! 1214: (void) signal (SIGINT, SIG_DFL); ! 1215: (void) signal (SIGQUIT, SIG_DFL); ! 1216: #ifdef SIGTSTP ! 1217: (void) signal (SIGTSTP, SIG_DFL); ! 1218: #endif SIGTSTP ! 1219: } ! 1220: ! 1221: /* */ ! 1222: ! 1223: static foreground () { ! 1224: #ifdef TIOCGPGRP ! 1225: int pgrp, ! 1226: tpgrp; ! 1227: int (*tstat) (); ! 1228: ! 1229: if ((pgrp = getpgrp (0)) == NOTOK) ! 1230: adios ("process group", "unable to determine"); ! 1231: for (;;) { ! 1232: if (ioctl (fileno (stdin), TIOCGPGRP, (char *) &tpgrp) == NOTOK) ! 1233: adios ("tty's process group", "unable to determine"); ! 1234: if (pgrp == tpgrp) ! 1235: break; ! 1236: ! 1237: tstat = signal (SIGTTIN, SIG_DFL); ! 1238: (void) kill (0, SIGTTIN); ! 1239: (void) signal (SIGTTIN, tstat); ! 1240: } ! 1241: ! 1242: (void) signal (SIGTTIN, SIG_IGN); ! 1243: (void) signal (SIGTTOU, SIG_IGN); ! 1244: (void) signal (SIGTSTP, SIG_IGN); ! 1245: #endif TIOCGPGRP ! 1246: } ! 1247: ! 1248: ! 1249: sideground () { ! 1250: #ifdef TIOCGPGRP ! 1251: (void) signal (SIGTTIN, SIG_DFL); ! 1252: (void) signal (SIGTTOU, SIG_DFL); ! 1253: (void) signal (SIGTSTP, SIG_DFL); ! 1254: #endif TIOCGPGRP ! 1255: } ! 1256: ! 1257: /* SIGNALS */ ! 1258: ! 1259: /* ARGSUSED */ ! 1260: ! 1261: static int ALRMser (sig) ! 1262: int sig; ! 1263: { ! 1264: longjmp (PEERctx, DONE); ! 1265: } ! 1266: ! 1267: ! 1268: #ifdef BSD42 ! 1269: /* ARGSUSED */ ! 1270: #endif BSD42 ! 1271: ! 1272: static int PIPEser (sig) ! 1273: int sig; ! 1274: { ! 1275: #ifndef BSD42 ! 1276: (void) signal (sig, SIG_IGN); ! 1277: #endif BSD42 ! 1278: ! 1279: adios (NULLCP, "lost peer"); ! 1280: } ! 1281: ! 1282: ! 1283: #ifdef BSD42 ! 1284: /* ARGSUSED */ ! 1285: #endif BSD42 ! 1286: ! 1287: static int SIGser (sig) ! 1288: int sig; ! 1289: { ! 1290: #ifndef BSD42 ! 1291: (void) signal (sig, SIG_IGN); ! 1292: #endif BSD42 ! 1293: ! 1294: done (1); ! 1295: } ! 1296: ! 1297: ! 1298: #ifdef SIGTSTP ! 1299: static int TSTPser (sig) ! 1300: int sig; ! 1301: { ! 1302: tputs (tgoto (CM, 0, LINES - 1), 0, _putchar); ! 1303: (void) fflush (stdout); ! 1304: ! 1305: TTYoff (); ! 1306: #ifdef BSD42 ! 1307: (void) sigsetmask (sigblock (0) & ~sigmask (SIGTSTP)); ! 1308: #endif BSD42 ! 1309: ! 1310: (void) kill (getpid (), sig); ! 1311: ! 1312: #ifdef BSD42 ! 1313: (void) sigblock (sigmask (SIGTSTP)); ! 1314: #endif BSD42 ! 1315: TTYon (); ! 1316: ! 1317: wrefresh (curscr); ! 1318: } ! 1319: #endif SIGTSTP ! 1320: ! 1321: /* MISCELLANY */ ! 1322: ! 1323: void done (status) ! 1324: int status; ! 1325: { ! 1326: TTYoff (); ! 1327: (void) pFIN (); ! 1328: ! 1329: exit (status); ! 1330: } ! 1331: ! 1332: /* */ ! 1333: ! 1334: /* VARARGS2 */ ! 1335: ! 1336: static void adorn (what, fmt, a, b, c, d, e, f) ! 1337: char *what, ! 1338: *fmt, ! 1339: *a, ! 1340: *b, ! 1341: *c, ! 1342: *d, ! 1343: *e, ! 1344: *f; ! 1345: { ! 1346: char *cp = invo_name; ! 1347: ! 1348: invo_name = NULL; ! 1349: advise (what, fmt, a, b, c, d, e, f); ! 1350: invo_name = cp; ! 1351: } ! 1352: ! 1353: /* */ ! 1354: ! 1355: /* VARARGS3 */ ! 1356: ! 1357: void advertise (what, tail, fmt, a, b, c, d, e, f) ! 1358: char *what, ! 1359: *tail, ! 1360: *fmt, ! 1361: *a, ! 1362: *b, ! 1363: *c, ! 1364: *d, ! 1365: *e, ! 1366: *f; ! 1367: { ! 1368: int eindex = errno; ! 1369: char buffer[BUFSIZ], ! 1370: err[BUFSIZ]; ! 1371: struct iovec iob[20]; ! 1372: register struct iovec *iov = iob; ! 1373: ! 1374: (void) fflush (stdout); ! 1375: ! 1376: (void) fflush (stderr); ! 1377: ! 1378: if (invo_name) { ! 1379: iov -> iov_len = strlen (iov -> iov_base = invo_name); ! 1380: iov++; ! 1381: iov -> iov_len = strlen (iov -> iov_base = ": "); ! 1382: iov++; ! 1383: } ! 1384: ! 1385: (void) sprintf (buffer, fmt, a, b, c, d, e, f); ! 1386: iov -> iov_len = strlen (iov -> iov_base = buffer); ! 1387: iov++; ! 1388: if (what) { ! 1389: if (*what) { ! 1390: iov -> iov_len = strlen (iov -> iov_base = " "); ! 1391: iov++; ! 1392: iov -> iov_len = strlen (iov -> iov_base = what); ! 1393: iov++; ! 1394: iov -> iov_len = strlen (iov -> iov_base = ": "); ! 1395: iov++; ! 1396: } ! 1397: if (eindex > 0 && eindex < sys_nerr) ! 1398: iov -> iov_len = strlen (iov -> iov_base = sys_errlist[eindex]); ! 1399: else { ! 1400: (void) sprintf (err, "Error %d", eindex); ! 1401: iov -> iov_len = strlen (iov -> iov_base = err); ! 1402: } ! 1403: iov++; ! 1404: } ! 1405: if (tail && *tail) { ! 1406: iov -> iov_len = strlen (iov -> iov_base = ", "); ! 1407: iov++; ! 1408: iov -> iov_len = strlen (iov -> iov_base = tail); ! 1409: iov++; ! 1410: } ! 1411: iov -> iov_len = strlen (iov -> iov_base = "\n"); ! 1412: iov++; ! 1413: ! 1414: if (tty_ready == DONE) ! 1415: (void) WINwritev (Display, iob, iov - iob); ! 1416: else ! 1417: (void) writev (fileno (stderr), iob, iov - iob); ! 1418: } ! 1419: ! 1420: /* */ ! 1421: ! 1422: #ifndef BSD42 ! 1423: static int writev (fd, iov, n) ! 1424: register int fd; ! 1425: register struct iovec *iov; ! 1426: register int n; ! 1427: { ! 1428: register int i, ! 1429: j; ! 1430: ! 1431: for (i = j = 0; i < n; i++, iov++) ! 1432: if (write (fd, iov -> iov_base, iov -> iov_len) != iov -> iov_len) ! 1433: break; ! 1434: else ! 1435: j += iov -> iov_len; ! 1436: ! 1437: return j; ! 1438: } ! 1439: #endif BSD42
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.