![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to more.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / more|
Return to more.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / more |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that the above copyright notice and this paragraph are
7: * duplicated in all such forms and that any documentation,
8: * advertising materials, and other materials related to such
9: * distribution and use acknowledge that the software was developed
10: * by the University of California, Berkeley. The name of the
11: * University may not be used to endorse or promote products derived
12: * from this software without specific prior written permission.
13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16: */
17:
18: #ifndef lint
19: char copyright[] =
20: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
21: All rights reserved.\n";
22: #endif /* not lint */
23:
24: #ifndef lint
25: static char sccsid[] = "@(#)more.c 5.22 (Berkeley) 7/30/89";
26: #endif /* not lint */
27:
28: /*
29: ** more.c - General purpose tty output filter and file perusal program
30: **
31: ** by Eric Shienbrood, UC Berkeley
32: **
33: ** modified by Geoff Peck, UCB to add underlining, single spacing
34: ** modified by John Foderaro, UCB to add -c and MORE environment variable
35: */
36:
37: #include <stdio.h>
38: #include <sys/param.h>
39: #include <ctype.h>
40: #include <signal.h>
41: #include <errno.h>
42: #include <sgtty.h>
43: #include <setjmp.h>
44: #include <sys/stat.h>
45: #include <sys/file.h>
46: #include <a.out.h>
47: #include <varargs.h>
48: #include "pathnames.h"
49:
50: #define Fopen(s,m) (Currline = 0,file_pos=0,fopen(s,m))
51: #define Ftell(f) file_pos
52: #define Fseek(f,off) (file_pos=off,fseek(f,off,0))
53: #define Getc(f) (++file_pos, getc(f))
54: #define Ungetc(c,f) (--file_pos, ungetc(c,f))
55:
56: #define MBIT CBREAK
57: #define stty(fd,argp) ioctl(fd,TIOCSETN,argp)
58:
59: #define TBUFSIZ 1024
60: #define LINSIZ 256
61: #define ctrl(letter) (letter & 077)
62: #define RUBOUT '\177'
63: #define ESC '\033'
64: #define QUIT '\034'
65:
66: struct sgttyb otty, savetty;
67: long file_pos, file_size;
68: int fnum, no_intty, no_tty, slow_tty;
69: int dum_opt, dlines, onquit(), end_it(), chgwinsz();
70: int onsusp();
71: int nscroll = 11; /* Number of lines scrolled by 'd' */
72: int fold_opt = 1; /* Fold long lines */
73: int stop_opt = 1; /* Stop after form feeds */
74: int ssp_opt = 0; /* Suppress white space */
75: int ul_opt = 1; /* Underline as best we can */
76: int promptlen;
77: int Currline; /* Line we are currently at */
78: int startup = 1;
79: int firstf = 1;
80: int notell = 1;
81: int docrterase = 0;
82: int docrtkill = 0;
83: int bad_so; /* True if overwriting does not turn off standout */
84: int inwait, Pause, errors;
85: int within; /* true if we are within a file,
86: false if we are between files */
87: int hard, dumb, noscroll, hardtabs, clreol, eatnl;
88: int catch_susp; /* We should catch the SIGTSTP signal */
89: char **fnames; /* The list of file names */
90: int nfiles; /* Number of files left to process */
91: char *shell; /* The name of the shell to use */
92: int shellp; /* A previous shell command exists */
93: char ch;
94: jmp_buf restore;
95: char Line[LINSIZ]; /* Line buffer */
96: int Lpp = 24; /* lines per page */
97: char *Clear; /* clear screen */
98: char *eraseln; /* erase line */
99: char *Senter, *Sexit;/* enter and exit standout mode */
100: char *ULenter, *ULexit; /* enter and exit underline mode */
101: char *chUL; /* underline character */
102: char *chBS; /* backspace character */
103: char *Home; /* go to home */
104: char *cursorm; /* cursor movement */
105: char cursorhome[40]; /* contains cursor movement to home */
106: char *EodClr; /* clear rest of screen */
107: char *tgetstr();
108: int Mcol = 80; /* number of columns */
109: int Wrap = 1; /* set if automargins */
110: int soglitch; /* terminal has standout mode glitch */
111: int ulglitch; /* terminal has underline mode glitch */
112: int pstate = 0; /* current UL state */
113: long fseek();
114: char *getenv();
115: struct {
116: long chrctr, line;
117: } context, screen_start;
118: extern char PC; /* pad character */
119: extern short ospeed;
120:
121:
122: main(argc, argv)
123: int argc;
124: char *argv[];
125: {
126: register FILE *f;
127: register char *s;
128: register char *p;
129: register char ch;
130: register int left;
131: int prnames = 0;
132: int initopt = 0;
133: int srchopt = 0;
134: int clearit = 0;
135: int initline;
136: char initbuf[80];
137: FILE *checkf();
138:
139: nfiles = argc;
140: fnames = argv;
141: initterm ();
142: nscroll = Lpp/2 - 1;
143: if (nscroll <= 0)
144: nscroll = 1;
145: if(s = getenv("MORE")) argscan(s);
146: while (--nfiles > 0) {
147: if ((ch = (*++fnames)[0]) == '-') {
148: argscan(*fnames+1);
149: }
150: else if (ch == '+') {
151: s = *fnames;
152: if (*++s == '/') {
153: srchopt++;
154: for (++s, p = initbuf; p < initbuf + 79 && *s != '\0';)
155: *p++ = *s++;
156: *p = '\0';
157: }
158: else {
159: initopt++;
160: for (initline = 0; *s != '\0'; s++)
161: if (isdigit (*s))
162: initline = initline*10 + *s -'0';
163: --initline;
164: }
165: }
166: else break;
167: }
168: /* allow clreol only if Home and eraseln and EodClr strings are
169: * defined, and in that case, make sure we are in noscroll mode
170: */
171: if(clreol)
172: {
173: if((Home == NULL) || (*Home == '\0') ||
174: (eraseln == NULL) || (*eraseln == '\0') ||
175: (EodClr == NULL) || (*EodClr == '\0') )
176: clreol = 0;
177: else noscroll = 1;
178: }
179: if (dlines == 0)
180: dlines = Lpp - (noscroll ? 1 : 2);
181: left = dlines;
182: if (nfiles > 1)
183: prnames++;
184: if (!no_intty && nfiles == 0) {
185: char *rindex();
186:
187: p = rindex(argv[0], '/');
188: fputs("usage: ",stderr);
189: fputs(p ? p + 1 : argv[0],stderr);
190: fputs(" [-dfln] [+linenum | +/pattern] name1 name2 ...\n",stderr);
191: exit(1);
192: }
193: else
194: f = stdin;
195: if (!no_tty) {
196: signal(SIGQUIT, onquit);
197: signal(SIGINT, end_it);
198: signal(SIGWINCH, chgwinsz);
199: if (signal (SIGTSTP, SIG_IGN) == SIG_DFL) {
200: signal(SIGTSTP, onsusp);
201: catch_susp++;
202: }
203: stty (fileno(stderr), &otty);
204: }
205: if (no_intty) {
206: if (no_tty)
207: copy_file (stdin);
208: else {
209: if ((ch = Getc (f)) == '\f')
210: doclear();
211: else {
212: Ungetc (ch, f);
213: if (noscroll && (ch != EOF)) {
214: if (clreol)
215: home ();
216: else
217: doclear ();
218: }
219: }
220: if (srchopt)
221: {
222: search (initbuf, stdin, 1);
223: if (noscroll)
224: left--;
225: }
226: else if (initopt)
227: skiplns (initline, stdin);
228: screen (stdin, left);
229: }
230: no_intty = 0;
231: prnames++;
232: firstf = 0;
233: }
234:
235: while (fnum < nfiles) {
236: if ((f = checkf (fnames[fnum], &clearit)) != NULL) {
237: context.line = context.chrctr = 0;
238: Currline = 0;
239: if (firstf) setjmp (restore);
240: if (firstf) {
241: firstf = 0;
242: if (srchopt)
243: {
244: search (initbuf, f, 1);
245: if (noscroll)
246: left--;
247: }
248: else if (initopt)
249: skiplns (initline, f);
250: }
251: else if (fnum < nfiles && !no_tty) {
252: setjmp (restore);
253: left = command (fnames[fnum], f);
254: }
255: if (left != 0) {
256: if ((noscroll || clearit) && (file_size != LONG_MAX))
257: if (clreol)
258: home ();
259: else
260: doclear ();
261: if (prnames) {
262: if (bad_so)
263: erase (0);
264: if (clreol)
265: cleareol ();
266: pr("::::::::::::::");
267: if (promptlen > 14)
268: erase (14);
269: printf ("\n");
270: if(clreol) cleareol();
271: printf("%s\n", fnames[fnum]);
272: if(clreol) cleareol();
273: printf("::::::::::::::\n");
274: if (left > Lpp - 4)
275: left = Lpp - 4;
276: }
277: if (no_tty)
278: copy_file (f);
279: else {
280: within++;
281: screen(f, left);
282: within = 0;
283: }
284: }
285: setjmp (restore);
286: fflush(stdout);
287: fclose(f);
288: screen_start.line = screen_start.chrctr = 0L;
289: context.line = context.chrctr = 0L;
290: }
291: fnum++;
292: firstf = 0;
293: }
294: reset_tty ();
295: exit(0);
296: }
297:
298: argscan(s)
299: char *s;
300: {
301: int seen_num = 0;
302:
303: while (*s != '\0') {
304: switch (*s) {
305: case '0': case '1': case '2':
306: case '3': case '4': case '5':
307: case '6': case '7': case '8':
308: case '9':
309: if (!seen_num) {
310: dlines = 0;
311: seen_num = 1;
312: }
313: dlines = dlines*10 + *s - '0';
314: break;
315: case 'd':
316: dum_opt = 1;
317: break;
318: case 'l':
319: stop_opt = 0;
320: break;
321: case 'f':
322: fold_opt = 0;
323: break;
324: case 'p':
325: noscroll++;
326: break;
327: case 'c':
328: clreol++;
329: break;
330: case 's':
331: ssp_opt = 1;
332: break;
333: case 'u':
334: ul_opt = 0;
335: break;
336: }
337: s++;
338: }
339: }
340:
341:
342: /*
343: ** Check whether the file named by fs is an ASCII file which the user may
344: ** access. If it is, return the opened file. Otherwise return NULL.
345: */
346:
347: FILE *
348: checkf (fs, clearfirst)
349: register char *fs;
350: int *clearfirst;
351: {
352: struct stat stbuf;
353: register FILE *f;
354: char c;
355:
356: if (stat (fs, &stbuf) == -1) {
357: (void)fflush(stdout);
358: if (clreol)
359: cleareol ();
360: perror(fs);
361: return((FILE *)NULL);
362: }
363: if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
364: printf("\n*** %s: directory ***\n\n", fs);
365: return((FILE *)NULL);
366: }
367: if ((f = Fopen(fs, "r")) == NULL) {
368: (void)fflush(stdout);
369: perror(fs);
370: return((FILE *)NULL);
371: }
372: if (magic(f, fs))
373: return((FILE *)NULL);
374: c = Getc(f);
375: *clearfirst = c == '\f';
376: Ungetc (c, f);
377: if ((file_size = stbuf.st_size) == 0)
378: file_size = LONG_MAX;
379: return(f);
380: }
381:
382: /*
383: * magic --
384: * check for file magic numbers. This code would best be shared with
385: * the file(1) program or, perhaps, more should not try and be so smart?
386: */
387: static
388: magic(f, fs)
389: FILE *f;
390: char *fs;
391: {
392: struct exec ex;
393:
394: if (fread(&ex, sizeof(ex), 1, f) == 1)
395: switch(ex.a_magic) {
396: case OMAGIC:
397: case NMAGIC:
398: case ZMAGIC:
399: case 0405:
400: case 0411:
401: case 0177545:
402: printf("\n******** %s: Not a text file ********\n\n", fs);
403: (void)fclose(f);
404: return(1);
405: }
406: (void)fseek(f, 0L, L_SET); /* rewind() not necessary */
407: return(0);
408: }
409:
410: /*
411: ** A real function, for the tputs routine in termlib
412: */
413:
414: putch (ch)
415: char ch;
416: {
417: putchar (ch);
418: }
419:
420: /*
421: ** Print out the contents of the file f, one screenful at a time.
422: */
423:
424: #define STOP -10
425:
426: screen (f, num_lines)
427: register FILE *f;
428: register int num_lines;
429: {
430: register int c;
431: register int nchars;
432: int length; /* length of current line */
433: static int prev_len = 1; /* length of previous line */
434:
435: for (;;) {
436: while (num_lines > 0 && !Pause) {
437: if ((nchars = getline (f, &length)) == EOF)
438: {
439: if (clreol)
440: clreos();
441: return;
442: }
443: if (ssp_opt && length == 0 && prev_len == 0)
444: continue;
445: prev_len = length;
446: if (bad_so || (Senter && *Senter == ' ') && promptlen > 0)
447: erase (0);
448: /* must clear before drawing line since tabs on some terminals
449: * do not erase what they tab over.
450: */
451: if (clreol)
452: cleareol ();
453: prbuf (Line, length);
454: if (nchars < promptlen)
455: erase (nchars); /* erase () sets promptlen to 0 */
456: else promptlen = 0;
457: /* is this needed?
458: * if (clreol)
459: * cleareol(); /* must clear again in case we wrapped *
460: */
461: if (nchars < Mcol || !fold_opt)
462: prbuf("\n", 1); /* will turn off UL if necessary */
463: if (nchars == STOP)
464: break;
465: num_lines--;
466: }
467: if (pstate) {
468: tputs(ULexit, 1, putch);
469: pstate = 0;
470: }
471: fflush(stdout);
472: if ((c = Getc(f)) == EOF)
473: {
474: if (clreol)
475: clreos ();
476: return;
477: }
478:
479: if (Pause && clreol)
480: clreos ();
481: Ungetc (c, f);
482: setjmp (restore);
483: Pause = 0; startup = 0;
484: if ((num_lines = command (NULL, f)) == 0)
485: return;
486: if (hard && promptlen > 0)
487: erase (0);
488: if (noscroll && num_lines >= dlines)
489: {
490: if (clreol)
491: home();
492: else
493: doclear ();
494: }
495: screen_start.line = Currline;
496: screen_start.chrctr = Ftell (f);
497: }
498: }
499:
500: /*
501: ** Come here if a quit signal is received
502: */
503:
504: onquit()
505: {
506: signal(SIGQUIT, SIG_IGN);
507: if (!inwait) {
508: putchar ('\n');
509: if (!startup) {
510: signal(SIGQUIT, onquit);
511: longjmp (restore, 1);
512: }
513: else
514: Pause++;
515: }
516: else if (!dum_opt && notell) {
517: write (2, "[Use q or Q to quit]", 20);
518: promptlen += 20;
519: notell = 0;
520: }
521: signal(SIGQUIT, onquit);
522: }
523:
524: /*
525: ** Come here if a signal for a window size change is received
526: */
527:
528: chgwinsz()
529: {
530: struct winsize win;
531:
532: (void) signal(SIGWINCH, SIG_IGN);
533: if (ioctl(fileno(stdout), TIOCGWINSZ, &win) != -1) {
534: if (win.ws_row != 0) {
535: Lpp = win.ws_row;
536: nscroll = Lpp/2 - 1;
537: if (nscroll <= 0)
538: nscroll = 1;
539: dlines = Lpp - (noscroll ? 1 : 2);
540: }
541: if (win.ws_col != 0)
542: Mcol = win.ws_col;
543: }
544: (void) signal(SIGWINCH, chgwinsz);
545: }
546:
547: /*
548: ** Clean up terminal state and exit. Also come here if interrupt signal received
549: */
550:
551: end_it ()
552: {
553:
554: reset_tty ();
555: if (clreol) {
556: putchar ('\r');
557: clreos ();
558: fflush (stdout);
559: }
560: else if (!clreol && (promptlen > 0)) {
561: kill_line ();
562: fflush (stdout);
563: }
564: else
565: write (2, "\n", 1);
566: _exit(0);
567: }
568:
569: copy_file(f)
570: register FILE *f;
571: {
572: register int c;
573:
574: while ((c = getc(f)) != EOF)
575: putchar(c);
576: }
577:
578: /* Simplified printf function */
579:
580: printf (fmt, va_alist)
581: register char *fmt;
582: va_dcl
583: {
584: va_list ap;
585: register char ch;
586: register int ccount;
587:
588: ccount = 0;
589: va_start(ap);
590: while (*fmt) {
591: while ((ch = *fmt++) != '%') {
592: if (ch == '\0')
593: return (ccount);
594: ccount++;
595: putchar (ch);
596: }
597: switch (*fmt++) {
598: case 'd':
599: ccount += printd (va_arg(ap, int));
600: break;
601: case 's':
602: ccount += pr (va_arg(ap, char *));
603: break;
604: case '%':
605: ccount++;
606: putchar ('%');
607: break;
608: case '0':
609: return (ccount);
610: default:
611: break;
612: }
613: }
614: va_end(ap);
615: return (ccount);
616:
617: }
618:
619: /*
620: ** Print an integer as a string of decimal digits,
621: ** returning the length of the print representation.
622: */
623:
624: printd (n)
625: int n;
626: {
627: int a, nchars;
628:
629: if (a = n/10)
630: nchars = 1 + printd(a);
631: else
632: nchars = 1;
633: putchar (n % 10 + '0');
634: return (nchars);
635: }
636:
637: /* Put the print representation of an integer into a string */
638: static char *sptr;
639:
640: scanstr (n, str)
641: int n;
642: char *str;
643: {
644: sptr = str;
645: Sprintf (n);
646: *sptr = '\0';
647: }
648:
649: Sprintf (n)
650: {
651: int a;
652:
653: if (a = n/10)
654: Sprintf (a);
655: *sptr++ = n % 10 + '0';
656: }
657:
658: static char bell = ctrl('G');
659:
660: strlen (s)
661: char *s;
662: {
663: register char *p;
664:
665: p = s;
666: while (*p++)
667: ;
668: return (p - s - 1);
669: }
670:
671: /* See whether the last component of the path name "path" is equal to the
672: ** string "string"
673: */
674:
675: tailequ (path, string)
676: char *path;
677: register char *string;
678: {
679: register char *tail;
680:
681: tail = path + strlen(path);
682: while (tail >= path)
683: if (*(--tail) == '/')
684: break;
685: ++tail;
686: while (*tail++ == *string++)
687: if (*tail == '\0')
688: return(1);
689: return(0);
690: }
691:
692: prompt (filename)
693: char *filename;
694: {
695: if (clreol)
696: cleareol ();
697: else if (promptlen > 0)
698: kill_line ();
699: if (!hard) {
700: promptlen = 8;
701: if (Senter && Sexit) {
702: tputs (Senter, 1, putch);
703: promptlen += (2 * soglitch);
704: }
705: if (clreol)
706: cleareol ();
707: pr("--More--");
708: if (filename != NULL) {
709: promptlen += printf ("(Next file: %s)", filename);
710: }
711: else if (!no_intty) {
712: promptlen += printf ("(%d%%)", (int)((file_pos * 100) / file_size));
713: }
714: if (dum_opt) {
715: promptlen += pr("[Press space to continue, 'q' to quit.]");
716: }
717: if (Senter && Sexit)
718: tputs (Sexit, 1, putch);
719: if (clreol)
720: clreos ();
721: fflush(stdout);
722: }
723: else
724: write (2, &bell, 1);
725: inwait++;
726: }
727:
728: /*
729: ** Get a logical line
730: */
731:
732: getline(f, length)
733: register FILE *f;
734: int *length;
735: {
736: register int c;
737: register char *p;
738: register int column;
739: static int colflg;
740:
741: p = Line;
742: column = 0;
743: c = Getc (f);
744: if (colflg && c == '\n') {
745: Currline++;
746: c = Getc (f);
747: }
748: while (p < &Line[LINSIZ - 1]) {
749: if (c == EOF) {
750: if (p > Line) {
751: *p = '\0';
752: *length = p - Line;
753: return (column);
754: }
755: *length = p - Line;
756: return (EOF);
757: }
758: if (c == '\n') {
759: Currline++;
760: break;
761: }
762: *p++ = c;
763: if (c == '\t')
764: if (!hardtabs || column < promptlen && !hard) {
765: if (hardtabs && eraseln && !dumb) {
766: column = 1 + (column | 7);
767: tputs (eraseln, 1, putch);
768: promptlen = 0;
769: }
770: else {
771: for (--p; p < &Line[LINSIZ - 1];) {
772: *p++ = ' ';
773: if ((++column & 7) == 0)
774: break;
775: }
776: if (column >= promptlen) promptlen = 0;
777: }
778: }
779: else
780: column = 1 + (column | 7);
781: else if (c == '\b' && column > 0)
782: column--;
783: else if (c == '\r')
784: column = 0;
785: else if (c == '\f' && stop_opt) {
786: p[-1] = '^';
787: *p++ = 'L';
788: column += 2;
789: Pause++;
790: }
791: else if (c == EOF) {
792: *length = p - Line;
793: return (column);
794: }
795: else if (c >= ' ' && c != RUBOUT)
796: column++;
797: if (column >= Mcol && fold_opt) break;
798: c = Getc (f);
799: }
800: if (column >= Mcol && Mcol > 0) {
801: if (!Wrap) {
802: *p++ = '\n';
803: }
804: }
805: colflg = column == Mcol && fold_opt;
806: if (colflg && eatnl && Wrap) {
807: *p++ = '\n'; /* simulate normal wrap */
808: }
809: *length = p - Line;
810: *p = 0;
811: return (column);
812: }
813:
814: /*
815: ** Erase the rest of the prompt, assuming we are starting at column col.
816: */
817:
818: erase (col)
819: register int col;
820: {
821:
822: if (promptlen == 0)
823: return;
824: if (hard) {
825: putchar ('\n');
826: }
827: else {
828: if (col == 0)
829: putchar ('\r');
830: if (!dumb && eraseln)
831: tputs (eraseln, 1, putch);
832: else
833: for (col = promptlen - col; col > 0; col--)
834: putchar (' ');
835: }
836: promptlen = 0;
837: }
838:
839: /*
840: ** Erase the current line entirely
841: */
842:
843: kill_line ()
844: {
845: erase (0);
846: if (!eraseln || dumb) putchar ('\r');
847: }
848:
849: /*
850: * force clear to end of line
851: */
852: cleareol()
853: {
854: tputs(eraseln, 1, putch);
855: }
856:
857: clreos()
858: {
859: tputs(EodClr, 1, putch);
860: }
861:
862: /*
863: ** Print string and return number of characters
864: */
865:
866: pr(s1)
867: char *s1;
868: {
869: register char *s;
870: register char c;
871:
872: for (s = s1; c = *s++; )
873: putchar(c);
874: return (s - s1 - 1);
875: }
876:
877:
878: /* Print a buffer of n characters */
879:
880: prbuf (s, n)
881: register char *s;
882: register int n;
883: {
884: register char c; /* next output character */
885: register int state; /* next output char's UL state */
886: #define wouldul(s,n) ((n) >= 2 && (((s)[0] == '_' && (s)[1] == '\b') || ((s)[1] == '\b' && (s)[2] == '_')))
887:
888: while (--n >= 0)
889: if (!ul_opt)
890: putchar (*s++);
891: else {
892: if (*s == ' ' && pstate == 0 && ulglitch && wouldul(s+1, n-1)) {
893: s++;
894: continue;
895: }
896: if (state = wouldul(s, n)) {
897: c = (*s == '_')? s[2] : *s ;
898: n -= 2;
899: s += 3;
900: } else
901: c = *s++;
902: if (state != pstate) {
903: if (c == ' ' && state == 0 && ulglitch && wouldul(s, n-1))
904: state = 1;
905: else
906: tputs(state ? ULenter : ULexit, 1, putch);
907: }
908: if (c != ' ' || pstate == 0 || state != 0 || ulglitch == 0)
909: putchar(c);
910: if (state && *chUL) {
911: pr(chBS);
912: tputs(chUL, 1, putch);
913: }
914: pstate = state;
915: }
916: }
917:
918: /*
919: ** Clear the screen
920: */
921:
922: doclear()
923: {
924: if (Clear && !hard) {
925: tputs(Clear, 1, putch);
926:
927: /* Put out carriage return so that system doesn't
928: ** get confused by escape sequences when expanding tabs
929: */
930: putchar ('\r');
931: promptlen = 0;
932: }
933: }
934:
935: /*
936: * Go to home position
937: */
938: home()
939: {
940: tputs(Home,1,putch);
941: }
942:
943: static int lastcmd, lastarg, lastp;
944: static int lastcolon;
945: char shell_line[132];
946:
947: /*
948: ** Read a command and do it. A command consists of an optional integer
949: ** argument followed by the command character. Return the number of lines
950: ** to display in the next screenful. If there is nothing more to display
951: ** in the current file, zero is returned.
952: */
953:
954: command (filename, f)
955: char *filename;
956: register FILE *f;
957: {
958: register int nlines;
959: register int retval;
960: register char c;
961: char colonch;
962: FILE *helpf;
963: int done;
964: char comchar, cmdbuf[80], *p;
965:
966: #define ret(val) retval=val;done++;break
967:
968: done = 0;
969: if (!errors)
970: prompt (filename);
971: else
972: errors = 0;
973: if (MBIT == RAW && slow_tty) {
974: otty.sg_flags |= MBIT;
975: stty(fileno(stderr), &otty);
976: }
977: for (;;) {
978: nlines = number (&comchar);
979: lastp = colonch = 0;
980: if (comchar == '.') { /* Repeat last command */
981: lastp++;
982: comchar = lastcmd;
983: nlines = lastarg;
984: if (lastcmd == ':')
985: colonch = lastcolon;
986: }
987: lastcmd = comchar;
988: lastarg = nlines;
989: if (comchar == otty.sg_erase) {
990: kill_line ();
991: prompt (filename);
992: continue;
993: }
994: switch (comchar) {
995: case ':':
996: retval = colon (filename, colonch, nlines);
997: if (retval >= 0)
998: done++;
999: break;
1000: case 'b':
1001: case ctrl('B'):
1002: {
1003: register int initline;
1004:
1005: if (no_intty) {
1006: write(2, &bell, 1);
1007: return (-1);
1008: }
1009:
1010: if (nlines == 0) nlines++;
1011:
1012: putchar ('\r');
1013: erase (0);
1014: printf ("\n");
1015: if (clreol)
1016: cleareol ();
1017: printf ("...back %d page", nlines);
1018: if (nlines > 1)
1019: pr ("s\n");
1020: else
1021: pr ("\n");
1022:
1023: if (clreol)
1024: cleareol ();
1025: pr ("\n");
1026:
1027: initline = Currline - dlines * (nlines + 1);
1028: if (! noscroll)
1029: --initline;
1030: if (initline < 0) initline = 0;
1031: Fseek(f, 0L);
1032: Currline = 0; /* skiplns() will make Currline correct */
1033: skiplns(initline, f);
1034: if (! noscroll) {
1035: ret(dlines + 1);
1036: }
1037: else {
1038: ret(dlines);
1039: }
1040: }
1041: case ' ':
1042: case 'z':
1043: if (nlines == 0) nlines = dlines;
1044: else if (comchar == 'z') dlines = nlines;
1045: ret (nlines);
1046: case 'd':
1047: case ctrl('D'):
1048: if (nlines != 0) nscroll = nlines;
1049: ret (nscroll);
1050: case 'q':
1051: case 'Q':
1052: end_it ();
1053: case 's':
1054: case 'f':
1055: if (nlines == 0) nlines++;
1056: if (comchar == 'f')
1057: nlines *= dlines;
1058: putchar ('\r');
1059: erase (0);
1060: printf ("\n");
1061: if (clreol)
1062: cleareol ();
1063: printf ("...skipping %d line", nlines);
1064: if (nlines > 1)
1065: pr ("s\n");
1066: else
1067: pr ("\n");
1068:
1069: if (clreol)
1070: cleareol ();
1071: pr ("\n");
1072:
1073: while (nlines > 0) {
1074: while ((c = Getc (f)) != '\n')
1075: if (c == EOF) {
1076: retval = 0;
1077: done++;
1078: goto endsw;
1079: }
1080: Currline++;
1081: nlines--;
1082: }
1083: ret (dlines);
1084: case '\n':
1085: if (nlines != 0)
1086: dlines = nlines;
1087: else
1088: nlines = 1;
1089: ret (nlines);
1090: case '\f':
1091: if (!no_intty) {
1092: doclear ();
1093: Fseek (f, screen_start.chrctr);
1094: Currline = screen_start.line;
1095: ret (dlines);
1096: }
1097: else {
1098: write (2, &bell, 1);
1099: break;
1100: }
1101: case '\'':
1102: if (!no_intty) {
1103: kill_line ();
1104: pr ("\n***Back***\n\n");
1105: Fseek (f, context.chrctr);
1106: Currline = context.line;
1107: ret (dlines);
1108: }
1109: else {
1110: write (2, &bell, 1);
1111: break;
1112: }
1113: case '=':
1114: kill_line ();
1115: promptlen = printd (Currline);
1116: fflush (stdout);
1117: break;
1118: case 'n':
1119: lastp++;
1120: case '/':
1121: if (nlines == 0) nlines++;
1122: kill_line ();
1123: pr ("/");
1124: promptlen = 1;
1125: fflush (stdout);
1126: if (lastp) {
1127: write (2,"\r", 1);
1128: search (NULL, f, nlines); /* Use previous r.e. */
1129: }
1130: else {
1131: ttyin (cmdbuf, 78, '/');
1132: write (2, "\r", 1);
1133: search (cmdbuf, f, nlines);
1134: }
1135: ret (dlines-1);
1136: case '!':
1137: do_shell (filename);
1138: break;
1139: case '?':
1140: case 'h':
1141: if ((helpf = fopen (HELPFILE, "r")) == NULL)
1142: error ("Can't open help file");
1143: if (noscroll) doclear ();
1144: copy_file (helpf);
1145: fclose (helpf);
1146: prompt (filename);
1147: break;
1148: case 'v': /* This case should go right before default */
1149: if (!no_intty) {
1150: kill_line ();
1151: cmdbuf[0] = '+';
1152: scanstr (Currline - dlines < 0 ? 0
1153: : Currline - (dlines + 1) / 2, &cmdbuf[1]);
1154: pr ("vi "); pr (cmdbuf); putchar (' '); pr (fnames[fnum]);
1155: execute (filename, _PATH_VI, "vi", cmdbuf, fnames[fnum], 0);
1156: break;
1157: }
1158: default:
1159: if (dum_opt) {
1160: kill_line ();
1161: if (Senter && Sexit) {
1162: tputs (Senter, 1, putch);
1163: promptlen = pr ("[Press 'h' for instructions.]") + (2 * soglitch);
1164: tputs (Sexit, 1, putch);
1165: }
1166: else
1167: promptlen = pr ("[Press 'h' for instructions.]");
1168: fflush (stdout);
1169: }
1170: else
1171: write (2, &bell, 1);
1172: break;
1173: }
1174: if (done) break;
1175: }
1176: putchar ('\r');
1177: endsw:
1178: inwait = 0;
1179: notell++;
1180: if (MBIT == RAW && slow_tty) {
1181: otty.sg_flags &= ~MBIT;
1182: stty(fileno(stderr), &otty);
1183: }
1184: return (retval);
1185: }
1186:
1187: char ch;
1188:
1189: /*
1190: * Execute a colon-prefixed command.
1191: * Returns <0 if not a command that should cause
1192: * more of the file to be printed.
1193: */
1194:
1195: colon (filename, cmd, nlines)
1196: char *filename;
1197: int cmd;
1198: int nlines;
1199: {
1200: if (cmd == 0)
1201: ch = readch ();
1202: else
1203: ch = cmd;
1204: lastcolon = ch;
1205: switch (ch) {
1206: case 'f':
1207: kill_line ();
1208: if (!no_intty)
1209: promptlen = printf ("\"%s\" line %d", fnames[fnum], Currline);
1210: else
1211: promptlen = printf ("[Not a file] line %d", Currline);
1212: fflush (stdout);
1213: return (-1);
1214: case 'n':
1215: if (nlines == 0) {
1216: if (fnum >= nfiles - 1)
1217: end_it ();
1218: nlines++;
1219: }
1220: putchar ('\r');
1221: erase (0);
1222: skipf (nlines);
1223: return (0);
1224: case 'p':
1225: if (no_intty) {
1226: write (2, &bell, 1);
1227: return (-1);
1228: }
1229: putchar ('\r');
1230: erase (0);
1231: if (nlines == 0)
1232: nlines++;
1233: skipf (-nlines);
1234: return (0);
1235: case '!':
1236: do_shell (filename);
1237: return (-1);
1238: case 'q':
1239: case 'Q':
1240: end_it ();
1241: default:
1242: write (2, &bell, 1);
1243: return (-1);
1244: }
1245: }
1246:
1247: /*
1248: ** Read a decimal number from the terminal. Set cmd to the non-digit which
1249: ** terminates the number.
1250: */
1251:
1252: number(cmd)
1253: char *cmd;
1254: {
1255: register int i;
1256:
1257: i = 0; ch = otty.sg_kill;
1258: for (;;) {
1259: ch = readch ();
1260: if (ch >= '0' && ch <= '9')
1261: i = i*10 + ch - '0';
1262: else if (ch == otty.sg_kill)
1263: i = 0;
1264: else {
1265: *cmd = ch;
1266: break;
1267: }
1268: }
1269: return (i);
1270: }
1271:
1272: do_shell (filename)
1273: char *filename;
1274: {
1275: char cmdbuf[80];
1276:
1277: kill_line ();
1278: pr ("!");
1279: fflush (stdout);
1280: promptlen = 1;
1281: if (lastp)
1282: pr (shell_line);
1283: else {
1284: ttyin (cmdbuf, 78, '!');
1285: if (expand (shell_line, cmdbuf)) {
1286: kill_line ();
1287: promptlen = printf ("!%s", shell_line);
1288: }
1289: }
1290: fflush (stdout);
1291: write (2, "\n", 1);
1292: promptlen = 0;
1293: shellp = 1;
1294: execute (filename, shell, shell, "-c", shell_line, 0);
1295: }
1296:
1297: /*
1298: ** Search for nth ocurrence of regular expression contained in buf in the file
1299: */
1300:
1301: search (buf, file, n)
1302: char buf[];
1303: FILE *file;
1304: register int n;
1305: {
1306: long startline = Ftell (file);
1307: register long line1 = startline;
1308: register long line2 = startline;
1309: register long line3 = startline;
1310: register int lncount;
1311: int saveln, rv, re_exec();
1312: char *s, *re_comp();
1313:
1314: context.line = saveln = Currline;
1315: context.chrctr = startline;
1316: lncount = 0;
1317: if ((s = re_comp (buf)) != 0)
1318: error (s);
1319: while (!feof (file)) {
1320: line3 = line2;
1321: line2 = line1;
1322: line1 = Ftell (file);
1323: rdline (file);
1324: lncount++;
1325: if ((rv = re_exec (Line)) == 1)
1326: if (--n == 0) {
1327: if (lncount > 3 || (lncount > 1 && no_intty))
1328: {
1329: pr ("\n");
1330: if (clreol)
1331: cleareol ();
1332: pr("...skipping\n");
1333: }
1334: if (!no_intty) {
1335: Currline -= (lncount >= 3 ? 3 : lncount);
1336: Fseek (file, line3);
1337: if (noscroll)
1338: if (clreol) {
1339: home ();
1340: cleareol ();
1341: }
1342: else
1343: doclear ();
1344: }
1345: else {
1346: kill_line ();
1347: if (noscroll)
1348: if (clreol) {
1349: home ();
1350: cleareol ();
1351: }
1352: else
1353: doclear ();
1354: pr (Line);
1355: putchar ('\n');
1356: }
1357: break;
1358: }
1359: else if (rv == -1)
1360: error ("Regular expression botch");
1361: }
1362: if (feof (file)) {
1363: if (!no_intty) {
1364: file->_flag &= ~_IOEOF; /* why doesn't fseek do this ??!!??! */
1365: Currline = saveln;
1366: Fseek (file, startline);
1367: }
1368: else {
1369: pr ("\nPattern not found\n");
1370: end_it ();
1371: }
1372: error ("Pattern not found");
1373: }
1374: }
1375:
1376: /*VARARGS2*/
1377: execute (filename, cmd, va_alist)
1378: char *filename;
1379: char *cmd;
1380: va_dcl
1381: {
1382: int id;
1383: int n;
1384: va_list argp;
1385:
1386: fflush (stdout);
1387: reset_tty ();
1388: for (n = 10; (id = fork ()) < 0 && n > 0; n--)
1389: sleep (5);
1390: if (id == 0) {
1391: if (!isatty(0)) {
1392: close(0);
1393: open("/dev/tty", 0);
1394: }
1395: va_start(argp);
1396: execv (cmd, argp);
1397: write (2, "exec failed\n", 12);
1398: exit (1);
1399: va_end(argp); /* balance {}'s for some UNIX's */
1400: }
1401: if (id > 0) {
1402: signal (SIGINT, SIG_IGN);
1403: signal (SIGQUIT, SIG_IGN);
1404: if (catch_susp)
1405: signal(SIGTSTP, SIG_DFL);
1406: while (wait(0) > 0);
1407: signal (SIGINT, end_it);
1408: signal (SIGQUIT, onquit);
1409: if (catch_susp)
1410: signal(SIGTSTP, onsusp);
1411: } else
1412: write(2, "can't fork\n", 11);
1413: set_tty ();
1414: pr ("------------------------\n");
1415: prompt (filename);
1416: }
1417: /*
1418: ** Skip n lines in the file f
1419: */
1420:
1421: skiplns (n, f)
1422: register int n;
1423: register FILE *f;
1424: {
1425: register char c;
1426:
1427: while (n > 0) {
1428: while ((c = Getc (f)) != '\n')
1429: if (c == EOF)
1430: return;
1431: n--;
1432: Currline++;
1433: }
1434: }
1435:
1436: /*
1437: ** Skip nskip files in the file list (from the command line). Nskip may be
1438: ** negative.
1439: */
1440:
1441: skipf (nskip)
1442: register int nskip;
1443: {
1444: if (nskip == 0) return;
1445: if (nskip > 0) {
1446: if (fnum + nskip > nfiles - 1)
1447: nskip = nfiles - fnum - 1;
1448: }
1449: else if (within)
1450: ++fnum;
1451: fnum += nskip;
1452: if (fnum < 0)
1453: fnum = 0;
1454: pr ("\n...Skipping ");
1455: pr ("\n");
1456: if (clreol)
1457: cleareol ();
1458: pr ("...Skipping ");
1459: pr (nskip > 0 ? "to file " : "back to file ");
1460: pr (fnames[fnum]);
1461: pr ("\n");
1462: if (clreol)
1463: cleareol ();
1464: pr ("\n");
1465: --fnum;
1466: }
1467:
1468: /*----------------------------- Terminal I/O -------------------------------*/
1469:
1470: initterm ()
1471: {
1472: char buf[TBUFSIZ];
1473: static char clearbuf[TBUFSIZ];
1474: char *clearptr, *padstr;
1475: int ldisc;
1476: int lmode;
1477: char *term;
1478: int tgrp;
1479: struct winsize win;
1480:
1481: retry:
1482: if (!(no_tty = gtty(fileno(stdout), &otty))) {
1483: if (ioctl(fileno(stdout), TIOCLGET, &lmode) < 0) {
1484: perror("TIOCLGET");
1485: exit(1);
1486: }
1487: docrterase = ((lmode & LCRTERA) != 0);
1488: docrtkill = ((lmode & LCRTKIL) != 0);
1489: /*
1490: * Wait until we're in the foreground before we save the
1491: * the terminal modes.
1492: */
1493: if (ioctl(fileno(stdout), TIOCGPGRP, &tgrp) < 0) {
1494: perror("TIOCGPGRP");
1495: exit(1);
1496: }
1497: if (tgrp != getpgrp(0)) {
1498: kill(0, SIGTTOU);
1499: goto retry;
1500: }
1501: if ((term = getenv("TERM")) == 0 || tgetent(buf, term) <= 0) {
1502: dumb++; ul_opt = 0;
1503: }
1504: else {
1505: if (ioctl(fileno(stdout), TIOCGWINSZ, &win) < 0) {
1506: Lpp = tgetnum("li");
1507: Mcol = tgetnum("co");
1508: } else {
1509: if ((Lpp = win.ws_row) == 0)
1510: Lpp = tgetnum("li");
1511: if ((Mcol = win.ws_col) == 0)
1512: Mcol = tgetnum("co");
1513: }
1514: if ((Lpp <= 0) || tgetflag("hc")) {
1515: hard++; /* Hard copy terminal */
1516: Lpp = 24;
1517: }
1518: if (tgetflag("xn"))
1519: eatnl++; /* Eat newline at last column + 1; dec, concept */
1520: if (Mcol <= 0)
1521: Mcol = 80;
1522:
1523: if (tailequ (fnames[0], "page") || !hard && tgetflag("ns"))
1524: noscroll++;
1525: Wrap = tgetflag("am");
1526: bad_so = tgetflag ("xs");
1527: clearptr = clearbuf;
1528: eraseln = tgetstr("ce",&clearptr);
1529: Clear = tgetstr("cl", &clearptr);
1530: Senter = tgetstr("so", &clearptr);
1531: Sexit = tgetstr("se", &clearptr);
1532: if ((soglitch = tgetnum("sg")) < 0)
1533: soglitch = 0;
1534:
1535: /*
1536: * Set up for underlining: some terminals don't need it;
1537: * others have start/stop sequences, still others have an
1538: * underline char sequence which is assumed to move the
1539: * cursor forward one character. If underline sequence
1540: * isn't available, settle for standout sequence.
1541: */
1542:
1543: if (tgetflag("ul") || tgetflag("os"))
1544: ul_opt = 0;
1545: if ((chUL = tgetstr("uc", &clearptr)) == NULL )
1546: chUL = "";
1547: if (((ULenter = tgetstr("us", &clearptr)) == NULL ||
1548: (ULexit = tgetstr("ue", &clearptr)) == NULL) && !*chUL) {
1549: if ((ULenter = Senter) == NULL || (ULexit = Sexit) == NULL) {
1550: ULenter = "";
1551: ULexit = "";
1552: } else
1553: ulglitch = soglitch;
1554: } else {
1555: if ((ulglitch = tgetnum("ug")) < 0)
1556: ulglitch = 0;
1557: }
1558:
1559: if (padstr = tgetstr("pc", &clearptr))
1560: PC = *padstr;
1561: Home = tgetstr("ho",&clearptr);
1562: if (Home == 0 || *Home == '\0')
1563: {
1564: if ((cursorm = tgetstr("cm", &clearptr)) != NULL) {
1565: strcpy(cursorhome, tgoto(cursorm, 0, 0));
1566: Home = cursorhome;
1567: }
1568: }
1569: EodClr = tgetstr("cd", &clearptr);
1570: if ((chBS = tgetstr("bc", &clearptr)) == NULL)
1571: chBS = "\b";
1572:
1573: }
1574: if ((shell = getenv("SHELL")) == NULL)
1575: shell = "/bin/sh";
1576: }
1577: no_intty = gtty(fileno(stdin), &otty);
1578: gtty(fileno(stderr), &otty);
1579: savetty = otty;
1580: ospeed = otty.sg_ospeed;
1581: slow_tty = ospeed < B1200;
1582: hardtabs = (otty.sg_flags & TBDELAY) != XTABS;
1583: if (!no_tty) {
1584: otty.sg_flags &= ~ECHO;
1585: if (MBIT == CBREAK || !slow_tty)
1586: otty.sg_flags |= MBIT;
1587: }
1588: }
1589:
1590: readch ()
1591: {
1592: char ch;
1593: extern int errno;
1594:
1595: errno = 0;
1596: if (read (2, &ch, 1) <= 0)
1597: if (errno != EINTR)
1598: end_it();
1599: else
1600: ch = otty.sg_kill;
1601: return (ch);
1602: }
1603:
1604: static char BS = '\b';
1605: static char *BSB = "\b \b";
1606: static char CARAT = '^';
1607: #define ERASEONECHAR \
1608: if (docrterase) \
1609: write (2, BSB, sizeof(BSB)); \
1610: else \
1611: write (2, &BS, sizeof(BS));
1612:
1613: ttyin (buf, nmax, pchar)
1614: char buf[];
1615: register int nmax;
1616: char pchar;
1617: {
1618: register char *sptr;
1619: register char ch;
1620: register int slash = 0;
1621: int maxlen;
1622: char cbuf;
1623:
1624: sptr = buf;
1625: maxlen = 0;
1626: while (sptr - buf < nmax) {
1627: if (promptlen > maxlen) maxlen = promptlen;
1628: ch = readch ();
1629: if (ch == '\\') {
1630: slash++;
1631: }
1632: else if ((ch == otty.sg_erase) && !slash) {
1633: if (sptr > buf) {
1634: --promptlen;
1635: ERASEONECHAR
1636: --sptr;
1637: if ((*sptr < ' ' && *sptr != '\n') || *sptr == RUBOUT) {
1638: --promptlen;
1639: ERASEONECHAR
1640: }
1641: continue;
1642: }
1643: else {
1644: if (!eraseln) promptlen = maxlen;
1645: longjmp (restore, 1);
1646: }
1647: }
1648: else if ((ch == otty.sg_kill) && !slash) {
1649: if (hard) {
1650: show (ch);
1651: putchar ('\n');
1652: putchar (pchar);
1653: }
1654: else {
1655: putchar ('\r');
1656: putchar (pchar);
1657: if (eraseln)
1658: erase (1);
1659: else if (docrtkill)
1660: while (promptlen-- > 1)
1661: write (2, BSB, sizeof(BSB));
1662: promptlen = 1;
1663: }
1664: sptr = buf;
1665: fflush (stdout);
1666: continue;
1667: }
1668: if (slash && (ch == otty.sg_kill || ch == otty.sg_erase)) {
1669: ERASEONECHAR
1670: --sptr;
1671: }
1672: if (ch != '\\')
1673: slash = 0;
1674: *sptr++ = ch;
1675: if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) {
1676: ch += ch == RUBOUT ? -0100 : 0100;
1677: write (2, &CARAT, 1);
1678: promptlen++;
1679: }
1680: cbuf = ch;
1681: if (ch != '\n' && ch != ESC) {
1682: write (2, &cbuf, 1);
1683: promptlen++;
1684: }
1685: else
1686: break;
1687: }
1688: *--sptr = '\0';
1689: if (!eraseln) promptlen = maxlen;
1690: if (sptr - buf >= nmax - 1)
1691: error ("Line too long");
1692: }
1693:
1694: expand (outbuf, inbuf)
1695: char *outbuf;
1696: char *inbuf;
1697: {
1698: register char *instr;
1699: register char *outstr;
1700: register char ch;
1701: char temp[200];
1702: int changed = 0;
1703:
1704: instr = inbuf;
1705: outstr = temp;
1706: while ((ch = *instr++) != '\0')
1707: switch (ch) {
1708: case '%':
1709: if (!no_intty) {
1710: strcpy (outstr, fnames[fnum]);
1711: outstr += strlen (fnames[fnum]);
1712: changed++;
1713: }
1714: else
1715: *outstr++ = ch;
1716: break;
1717: case '!':
1718: if (!shellp)
1719: error ("No previous command to substitute for");
1720: strcpy (outstr, shell_line);
1721: outstr += strlen (shell_line);
1722: changed++;
1723: break;
1724: case '\\':
1725: if (*instr == '%' || *instr == '!') {
1726: *outstr++ = *instr++;
1727: break;
1728: }
1729: default:
1730: *outstr++ = ch;
1731: }
1732: *outstr++ = '\0';
1733: strcpy (outbuf, temp);
1734: return (changed);
1735: }
1736:
1737: show (ch)
1738: register char ch;
1739: {
1740: char cbuf;
1741:
1742: if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) {
1743: ch += ch == RUBOUT ? -0100 : 0100;
1744: write (2, &CARAT, 1);
1745: promptlen++;
1746: }
1747: cbuf = ch;
1748: write (2, &cbuf, 1);
1749: promptlen++;
1750: }
1751:
1752: error (mess)
1753: char *mess;
1754: {
1755: if (clreol)
1756: cleareol ();
1757: else
1758: kill_line ();
1759: promptlen += strlen (mess);
1760: if (Senter && Sexit) {
1761: tputs (Senter, 1, putch);
1762: pr(mess);
1763: tputs (Sexit, 1, putch);
1764: }
1765: else
1766: pr (mess);
1767: fflush(stdout);
1768: errors++;
1769: longjmp (restore, 1);
1770: }
1771:
1772:
1773: set_tty ()
1774: {
1775: otty.sg_flags |= MBIT;
1776: otty.sg_flags &= ~ECHO;
1777: stty(fileno(stderr), &otty);
1778: }
1779:
1780: reset_tty ()
1781: {
1782: if (no_tty)
1783: return;
1784: if (pstate) {
1785: tputs(ULexit, 1, putch);
1786: fflush(stdout);
1787: pstate = 0;
1788: }
1789: otty.sg_flags |= ECHO;
1790: otty.sg_flags &= ~MBIT;
1791: stty(fileno(stderr), &savetty);
1792: }
1793:
1794: rdline (f)
1795: register FILE *f;
1796: {
1797: register char c;
1798: register char *p;
1799:
1800: p = Line;
1801: while ((c = Getc (f)) != '\n' && c != EOF && p - Line < LINSIZ - 1)
1802: *p++ = c;
1803: if (c == '\n')
1804: Currline++;
1805: *p = '\0';
1806: }
1807:
1808: /* Come here when we get a suspend signal from the terminal */
1809:
1810: onsusp ()
1811: {
1812: /* ignore SIGTTOU so we don't get stopped if csh grabs the tty */
1813: signal(SIGTTOU, SIG_IGN);
1814: reset_tty ();
1815: fflush (stdout);
1816: signal(SIGTTOU, SIG_DFL);
1817: /* Send the TSTP signal to suspend our process group */
1818: signal(SIGTSTP, SIG_DFL);
1819: sigsetmask(0);
1820: kill (0, SIGTSTP);
1821: /* Pause for station break */
1822:
1823: /* We're back */
1824: signal (SIGTSTP, onsusp);
1825: set_tty ();
1826: if (inwait)
1827: longjmp (restore);
1828: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.