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