![[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] / 40BSD / cmd|
Return to more.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd |
1.1 root 1: static char *SCCS_ID = "@(#)more.c 4.1 (Berkeley) 10/16/80";
2: /*
3: ** more.c - General purpose tty output filter and file perusal program
4: **
5: ** by Eric Shienbrood, UC Berkeley
6: */
7:
8: #include <whoami.h>
9: #ifdef V6
10: #include <retrofit.h>
11: #endif
12: #include <stdio.h>
13: #include <ctype.h>
14: #include <signal.h>
15: #include <errno.h>
16: #include <sgtty.h>
17: #include <setjmp.h>
18: #include <sys/types.h>
19: #include <sys/dir.h>
20: #include <sys/stat.h>
21: #include <local/uparm.h>
22:
23: /* Help file will eventually go in libpath(more.help) on all systems */
24:
25: #ifdef INGRES
26: #define VI "/usr/bin/vi"
27: #define HELPFILE "/mntp/doucette/more/more.help"
28: #endif
29:
30: #ifndef INGRES
31: #ifndef HELPFILE
32: #define HELPFILE libpath(more.help)
33: #endif
34: #define VI binpath(vi)
35: #endif
36:
37: #define Fopen(s,m) (Currline = 0,file_pos=0,fopen(s,m))
38: #define Ftell(f) file_pos
39: #define Fseek(f,off) (file_pos=off,fseek(f,off,0))
40: #define Getc(f) (++file_pos, getc(f))
41: #define Ungetc(c,f) (--file_pos, ungetc(c,f))
42:
43: #ifdef V6
44: #define MBIT RAW
45: #define CBREAK ~RAW
46: #else
47: #define MBIT CBREAK
48: #define stty(fd,argp) ioctl(fd,TIOCSETN,argp)
49: #endif
50:
51: #define TBUFSIZ 1024
52: #define LINSIZ 256
53: #define ctrl(letter) ('letter' & 077)
54: #define RUBOUT '\177'
55: #define ESC '\033'
56: #define QUIT '\034'
57:
58: struct sgttyb otty;
59: long file_pos, file_size;
60: int fnum, no_intty, no_tty, slow_tty;
61: int dum_opt, dlines, onquit(), end_it();
62: #ifdef SIGTSTP
63: int onsusp();
64: #endif
65: int nscroll = 11; /* Number of lines scrolled by 'd' */
66: int fold_opt = 1; /* Fold long lines */
67: int stop_opt = 1; /* Stop after form feeds */
68: int promptlen;
69: int Currline; /* Line we are currently at */
70: int startup = 1;
71: int firstf = 1;
72: int notell = 1;
73: int bad_so; /* True if overwriting does not turn off standout */
74: int inwait, Pause, errors;
75: int within; /* true if we are within a file,
76: false if we are between files */
77: int hard, dumb, noscroll, hardtabs;
78: int catch_susp; /* We should catch the SIGTSTP signal */
79: char **fnames; /* The list of file names */
80: int nfiles; /* Number of files left to process */
81: char *shell; /* The name of the shell to use */
82: int shellp; /* A previous shell command exists */
83: char ch;
84: jmp_buf restore;
85: char obuf[BUFSIZ]; /* stdout buffer */
86: char Line[LINSIZ]; /* Line buffer */
87: int Lpp = 24; /* lines per page */
88: char *Clear; /* clear screen */
89: char *eraseln; /* erase line */
90: char *Senter, *Sexit;/* enter and exit standout mode */
91: char *tgetstr();
92: int Mcol = 80; /* number of columns */
93: int Wrap = 1; /* set if automargins */
94: long fseek();
95: struct {
96: long chrctr, line;
97: } context, screen_start;
98: extern char PC; /* pad character */
99: extern short ospeed;
100:
101:
102: main(argc, argv)
103: int argc;
104: char *argv[];
105: {
106: register FILE *f;
107: register char *s;
108: register char *p;
109: register char ch;
110: register int left;
111: int prnames = 0;
112: int initopt = 0;
113: int srchopt = 0;
114: int clearit = 0;
115: int initline;
116: char initbuf[80];
117: FILE *checkf();
118:
119: nfiles = argc;
120: fnames = argv;
121: initterm ();
122: while (--nfiles > 0) {
123: if ((ch = (*++fnames)[0]) == '-') {
124: for (s = fnames[0] + 1, dlines = 0; *s != '\0'; s++)
125: if (isdigit(*s))
126: dlines = dlines*10 + *s - '0';
127: else if (*s == 'd')
128: dum_opt = 1;
129: else if (*s == 'l')
130: stop_opt = 0;
131: else if (*s == 'f')
132: fold_opt = 0;
133: }
134: else if (ch == '+') {
135: s = *fnames;
136: if (*++s == '/') {
137: srchopt++;
138: for (++s, p = initbuf; p < initbuf + 79 && *s != '\0';)
139: *p++ = *s++;
140: *p = '\0';
141: }
142: else {
143: initopt++;
144: for (initline = 0; *s != '\0'; s++)
145: if (isdigit (*s))
146: initline = initline*10 + *s -'0';
147: --initline;
148: }
149: }
150: else break;
151: }
152: if (dlines == 0)
153: dlines = Lpp - (noscroll ? 1 : 2);
154: left = dlines;
155: if (nfiles > 1)
156: prnames++;
157: if (!no_intty && nfiles == 0) {
158: fputs("Usage: ",stderr);
159: fputs(argv[0],stderr);
160: fputs(" [-dfln] [+linenum | +/pattern] name1 name2 ...\n",stderr);
161: exit(1);
162: }
163: else
164: f = stdin;
165: if (!no_tty) {
166: signal(SIGQUIT, onquit);
167: signal(SIGINT, end_it);
168: #ifdef SIGTSTP
169: if (signal (SIGTSTP, SIG_IGN) == SIG_DFL) {
170: signal(SIGTSTP, onsusp);
171: catch_susp++;
172: }
173: #endif
174: stty (2, &otty);
175: }
176: if (no_intty) {
177: if (no_tty)
178: copy_file (stdin);
179: else {
180: if ((ch = Getc (f)) == '\f')
181: doclear ();
182: else {
183: Ungetc (ch, f);
184: if (noscroll)
185: doclear ();
186: }
187: if (srchopt)
188: search (initbuf, stdin, 1);
189: else if (initopt)
190: skiplns (initline, stdin);
191: screen (stdin, left);
192: }
193: no_intty = 0;
194: prnames++;
195: firstf = 0;
196: }
197:
198: while (fnum < nfiles) {
199: if ((f = checkf (fnames[fnum], &clearit)) != NULL) {
200: context.line = context.chrctr = 0;
201: Currline = 0;
202: if (firstf) setjmp (restore);
203: if (firstf) {
204: firstf = 0;
205: if (srchopt)
206: search (initbuf, f, 1);
207: else if (initopt)
208: skiplns (initline, f);
209: }
210: else if (fnum < nfiles && !no_tty) {
211: setjmp (restore);
212: left = command (fnames[fnum], f);
213: }
214: if (left != 0) {
215: if (noscroll || clearit)
216: doclear ();
217: if (prnames) {
218: if (bad_so)
219: erase (0);
220: pr("::::::::::::::");
221: if (promptlen > 14)
222: erase (14);
223: printf ("\n%s\n::::::::::::::\n", fnames[fnum]);
224: if (left > Lpp - 4)
225: left = Lpp - 4;
226: }
227: if (no_tty)
228: copy_file (f);
229: else {
230: within++;
231: screen(f, left);
232: within = 0;
233: }
234: }
235: setjmp (restore);
236: fflush(stdout);
237: fclose(f);
238: screen_start.line = screen_start.chrctr = 0L;
239: context.line = context.chrctr = 0L;
240: }
241: fnum++;
242: firstf = 0;
243: }
244: reset_tty ();
245: exit(0);
246: }
247:
248: /*
249: ** Check whether the file named by fs is an ASCII file which the user may
250: ** access. If it is, return the opened file. Otherwise return NULL.
251: */
252:
253: FILE *
254: checkf (fs, clearfirst)
255: register char *fs;
256: int *clearfirst;
257: {
258: struct stat stbuf;
259: register FILE *f;
260: char c;
261:
262: if (stat (fs, &stbuf) == -1) {
263: fflush(stdout);
264: perror(fs);
265: return (NULL);
266: }
267: if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
268: printf("\n*** %s: directory ***\n\n", fs);
269: return (NULL);
270: }
271: if ((f=Fopen(fs, "r")) == NULL) {
272: fflush(stdout);
273: perror(fs);
274: return (NULL);
275: }
276: c = Getc(f);
277:
278: /* Try to see whether it is an ASCII file */
279:
280: switch ((c | *f->_ptr << 8) & 0177777) {
281: case 0405:
282: case 0407:
283: case 0410:
284: case 0411:
285: case 0413:
286: case 0177545:
287: printf("\n******** %s: Not a text file ********\n\n", fs);
288: fclose (f);
289: return (NULL);
290: default:
291: break;
292: }
293: if (c == '\f')
294: *clearfirst = 1;
295: else {
296: *clearfirst = 0;
297: Ungetc (c, f);
298: }
299: if ((file_size = stbuf.st_size) == 0)
300: file_size = 0x7fffffffffffffffL;
301: return (f);
302: }
303:
304: /*
305: ** A real function, for the tputs routine in termlib
306: */
307:
308: putch (ch)
309: char ch;
310: {
311: putchar (ch);
312: }
313:
314: /*
315: ** Print out the contents of the file f, one screenful at a time.
316: */
317:
318: #define STOP -10
319:
320: screen (f, num_lines)
321: register FILE *f;
322: register int num_lines;
323: {
324: register int c;
325: register int nchars;
326: int length;
327:
328: for (;;) {
329: while (num_lines > 0 && !Pause) {
330: if ((nchars = getline (f, &length)) == EOF)
331: return;
332: if (bad_so || (Senter && *Senter == ' ') && promptlen > 0)
333: erase (0);
334: prbuf (Line, length);
335: if (nchars < promptlen)
336: erase (nchars); /* erase () sets promptlen to 0 */
337: else promptlen = 0;
338: if (nchars < Mcol || !fold_opt)
339: putchar('\n');
340: if (nchars == STOP)
341: break;
342: num_lines--;
343: }
344: fflush(stdout);
345: if ((c = Getc(f)) == EOF)
346: return;
347: Ungetc (c, f);
348: setjmp (restore);
349: Pause = 0; startup = 0;
350: if ((num_lines = command (NULL, f)) == 0)
351: return;
352: if (hard && promptlen > 0)
353: erase (0);
354: if (noscroll && num_lines == dlines)
355: doclear ();
356: screen_start.line = Currline;
357: screen_start.chrctr = Ftell (f);
358: }
359: }
360:
361: /*
362: ** Come here if a quit signal is received
363: */
364:
365: onquit()
366: {
367: signal(SIGQUIT, SIG_IGN);
368: if (!inwait) {
369: putchar ('\n');
370: if (!startup) {
371: signal(SIGQUIT, onquit);
372: longjmp (restore, 1);
373: }
374: else
375: Pause++;
376: }
377: else if (!dum_opt && notell) {
378: write (2, "[Use q or Q to quit]", 20);
379: promptlen += 20;
380: notell = 0;
381: }
382: signal(SIGQUIT, onquit);
383: }
384:
385: /*
386: ** Clean up terminal state and exit. Also come here if interrupt signal received
387: */
388:
389: end_it ()
390: {
391:
392: reset_tty ();
393: if (promptlen > 0) {
394: kill_line ();
395: fflush (stdout);
396: }
397: else
398: write (2, "\n", 1);
399: _exit(0);
400: }
401:
402: copy_file(f)
403: register FILE *f;
404: {
405: register int c;
406:
407: while ((c = getc(f)) != EOF)
408: putchar(c);
409: }
410:
411: /* Simplified printf function */
412:
413: printf (fmt, args)
414: register char *fmt;
415: int args;
416: {
417: register int *argp;
418: register char ch;
419: register int ccount;
420:
421: ccount = 0;
422: argp = &args;
423: while (*fmt) {
424: while ((ch = *fmt++) != '%') {
425: if (ch == '\0')
426: return (ccount);
427: ccount++;
428: putchar (ch);
429: }
430: switch (*fmt++) {
431: case 'd':
432: ccount += printd (*argp);
433: break;
434: case 's':
435: ccount += pr ((char *)*argp);
436: break;
437: case '%':
438: ccount++;
439: argp--;
440: putchar ('%');
441: break;
442: case '0':
443: return (ccount);
444: default:
445: break;
446: }
447: ++argp;
448: }
449: return (ccount);
450:
451: }
452:
453: /*
454: ** Print an integer as a string of decimal digits,
455: ** returning the length of the print representation.
456: */
457:
458: printd (n)
459: int n;
460: {
461: int a, nchars;
462:
463: if (a = n/10)
464: nchars = 1 + printd(a);
465: else
466: nchars = 1;
467: putchar (n % 10 + '0');
468: return (nchars);
469: }
470:
471: /* Put the print representation of an integer into a string */
472: static char *sptr;
473:
474: scanstr (n, str)
475: int n;
476: char *str;
477: {
478: sptr = str;
479: sprintf (n);
480: *sptr = '\0';
481: }
482:
483: sprintf (n)
484: {
485: int a;
486:
487: if (a = n/10)
488: sprintf (a);
489: *sptr++ = n % 10 + '0';
490: }
491:
492: static char bell = ctrl(G);
493:
494: strlen (s)
495: char *s;
496: {
497: register char *p;
498:
499: p = s;
500: while (*p++)
501: ;
502: return (p - s - 1);
503: }
504:
505: /* See whether the last component of the path name "path" is equal to the
506: ** string "string"
507: */
508:
509: tailequ (path, string)
510: char *path;
511: register char *string;
512: {
513: register char *tail;
514:
515: tail = path + strlen(path);
516: while (tail >= path)
517: if (*(--tail) == '/')
518: break;
519: ++tail;
520: while (*tail++ == *string++)
521: if (*tail == '\0')
522: return(1);
523: return(0);
524: }
525:
526: prompt (filename)
527: char *filename;
528: {
529: if (promptlen > 0)
530: kill_line ();
531: if (!hard) {
532: promptlen = 8;
533: if (Senter && Sexit)
534: tputs (Senter, 1, putch);
535: pr("--More--");
536: if (filename != NULL) {
537: promptlen += printf ("(Next file: %s)", filename);
538: }
539: else if (!no_intty) {
540: promptlen += printf ("(%d%%)", (int)((file_pos * 100) / file_size));
541: }
542: if (dum_opt) {
543: promptlen += pr("[Hit space to continue, Rubout to abort]");
544: }
545: if (Senter && Sexit)
546: tputs (Sexit, 1, putch);
547: fflush(stdout);
548: }
549: else
550: write (2, &bell, 1);
551: inwait++;
552: }
553:
554: /*
555: ** Get a logical line
556: */
557:
558: getline(f, length)
559: register FILE *f;
560: int *length;
561: {
562: register int c;
563: register char *p;
564: register int column;
565: static int colflg;
566:
567: p = Line;
568: column = 0;
569: c = Getc (f);
570: if (colflg && c == '\n') {
571: Currline++;
572: c = Getc (f);
573: }
574: while (p < &Line[LINSIZ - 1]) {
575: if (c == EOF) {
576: if (p > Line) {
577: *p = '\0';
578: *length = p - Line;
579: return (column);
580: }
581: *length = p - Line;
582: return (EOF);
583: }
584: if (c == '\n') {
585: Currline++;
586: break;
587: }
588: *p++ = c;
589: if (c == '\t')
590: if (hardtabs && column < promptlen && !hard) {
591: if (eraseln && !dumb) {
592: column = 1 + (column | 7);
593: tputs (eraseln, 1, putch);
594: promptlen = 0;
595: }
596: else {
597: for (--p; column & 7 && p < &Line[LINSIZ - 1]; column++) {
598: *p++ = ' ';
599: }
600: if (column >= promptlen) promptlen = 0;
601: }
602: }
603: else
604: column = 1 + (column | 7);
605: else if (c == '\b')
606: column--;
607: else if (c == '\r')
608: column = 0;
609: else if (c == '\f' && stop_opt) {
610: p[-1] = '^';
611: *p++ = 'L';
612: column += 2;
613: Pause++;
614: }
615: else if (c == EOF) {
616: *length = p - Line;
617: return (column);
618: }
619: else if (c >= ' ' && c != RUBOUT)
620: column++;
621: if (column >= Mcol && fold_opt) break;
622: c = Getc (f);
623: }
624: if (column >= Mcol && Mcol > 0) {
625: if (!Wrap) {
626: *p++ = '\n';
627: }
628: }
629: colflg = column == Mcol && fold_opt;
630: *length = p - Line;
631: *p = 0;
632: return (column);
633: }
634:
635: /*
636: ** Erase the rest of the prompt, assuming we are starting at column col.
637: */
638:
639: erase (col)
640: register int col;
641: {
642:
643: if (promptlen == 0)
644: return;
645: if (hard) {
646: putchar ('\n');
647: }
648: else {
649: if (col == 0)
650: putchar ('\r');
651: if (!dumb && eraseln)
652: tputs (eraseln, 1, putch);
653: else
654: for (col = promptlen - col; col > 0; col--)
655: putchar (' ');
656: }
657: promptlen = 0;
658: }
659:
660: /*
661: ** Erase the current line entirely
662: */
663:
664: kill_line ()
665: {
666: erase (0);
667: if (!eraseln || dumb) putchar ('\r');
668: }
669:
670: /*
671: ** Print string and return number of characters
672: */
673:
674: pr(s1)
675: char *s1;
676: {
677: register char *s;
678: register char c;
679:
680: for (s = s1; c = *s++; )
681: putchar(c);
682: return (s - s1 - 1);
683: }
684:
685:
686: /* Print a buffer of n characters */
687:
688: prbuf (s, n)
689: register char *s;
690: register int n;
691: {
692: while (n-- > 0)
693: putchar (*s++);
694: }
695:
696: /*
697: ** Clear the screen
698: */
699:
700: doclear()
701: {
702: if (Clear && !hard) {
703: tputs(Clear, 1, putch);
704:
705: /* Put out carriage return so that system doesn't
706: ** get confused by escape sequences when expanding tabs
707: */
708: putchar ('\r');
709: promptlen = 0;
710: }
711: }
712:
713: static int lastcmd, lastarg, lastp;
714: static int lastcolon;
715: char shell_line[132];
716:
717: /*
718: ** Read a command and do it. A command consists of an optional integer
719: ** argument followed by the command character. Return the number of lines
720: ** to display in the next screenful. If there is nothing more to display
721: ** in the current file, zero is returned.
722: */
723:
724: command (filename, f)
725: char *filename;
726: register FILE *f;
727: {
728: register int nlines;
729: register int retval;
730: register char c;
731: char colonch;
732: FILE *helpf;
733: int done;
734: char comchar, cmdbuf[80], *p;
735:
736: #define ret(val) retval=val;done++;break
737:
738: done = 0;
739: if (!errors)
740: prompt (filename);
741: else
742: errors = 0;
743: if (MBIT == RAW && slow_tty) {
744: otty.sg_flags |= MBIT;
745: stty(2, &otty);
746: }
747: for (;;) {
748: nlines = number (&comchar);
749: lastp = colonch = 0;
750: if (comchar == '.') { /* Repeat last command */
751: lastp++;
752: comchar = lastcmd;
753: nlines = lastarg;
754: if (lastcmd == ':')
755: colonch = lastcolon;
756: }
757: lastcmd = comchar;
758: lastarg = nlines;
759: if (comchar == otty.sg_erase) {
760: kill_line ();
761: prompt (filename);
762: continue;
763: }
764: switch (comchar) {
765: case ':':
766: retval = colon (filename, colonch, nlines);
767: if (retval >= 0)
768: done++;
769: break;
770: case ' ':
771: case 'z':
772: if (nlines == 0) nlines = dlines;
773: else if (comchar == 'z') dlines = nlines;
774: ret (nlines);
775: case 'd':
776: case ctrl(D):
777: if (nlines != 0) nscroll = nlines;
778: ret (nscroll);
779: case RUBOUT:
780: case 'q':
781: case 'Q':
782: end_it ();
783: case 's':
784: case 'f':
785: if (nlines == 0) nlines++;
786: if (comchar == 'f')
787: nlines *= dlines;
788: putchar ('\r');
789: erase (0);
790: printf("\n...skipping %d line", nlines);
791: if (nlines > 1)
792: pr("s\n\n");
793: else
794: pr("\n\n");
795: while (nlines > 0) {
796: while ((c = Getc (f)) != '\n')
797: if (c == EOF) {
798: retval = 0;
799: done++;
800: goto endsw;
801: }
802: Currline++;
803: nlines--;
804: }
805: ret (dlines);
806: case '\n':
807: if (nlines != 0)
808: dlines = nlines;
809: else
810: nlines = 1;
811: ret (nlines);
812: case '\f':
813: if (!no_intty) {
814: doclear ();
815: Fseek (f, screen_start.chrctr);
816: Currline = screen_start.line;
817: ret (dlines);
818: }
819: else {
820: write (2, &bell, 1);
821: break;
822: }
823: case '\'':
824: if (!no_intty) {
825: kill_line ();
826: pr ("\n***Back***\n\n");
827: Fseek (f, context.chrctr);
828: Currline = context.line;
829: ret (dlines);
830: }
831: else {
832: write (2, &bell, 1);
833: break;
834: }
835: case '=':
836: kill_line ();
837: promptlen = printd (Currline);
838: fflush (stdout);
839: break;
840: case 'n':
841: lastp++;
842: case '/':
843: if (nlines == 0) nlines++;
844: kill_line ();
845: pr ("/");
846: promptlen = 1;
847: fflush (stdout);
848: if (lastp) {
849: write (2,"\r", 1);
850: search (NULL, f, nlines); /* Use previous r.e. */
851: }
852: else {
853: ttyin (cmdbuf, 78, '/');
854: write (2, "\r", 1);
855: search (cmdbuf, f, nlines);
856: }
857: ret (dlines);
858: case '!':
859: do_shell (filename);
860: break;
861: case 'h':
862: if ((helpf = fopen (HELPFILE, "r")) == NULL)
863: error ("Can't open help file");
864: if (noscroll) doclear ();
865: copy_file (helpf);
866: close (helpf);
867: prompt (filename);
868: break;
869: case 'v': /* This case should go right before default */
870: if (!no_intty) {
871: kill_line ();
872: cmdbuf[0] = '+';
873: scanstr (Currline, &cmdbuf[1]);
874: pr ("vi "); pr (cmdbuf); putchar (' '); pr (fnames[fnum]);
875: execute (filename, VI, "vi", cmdbuf, fnames[fnum], 0);
876: break;
877: }
878: default:
879: write (2, &bell, 1);
880: break;
881: }
882: if (done) break;
883: }
884: putchar ('\r');
885: endsw:
886: inwait = 0;
887: notell++;
888: if (MBIT == RAW && slow_tty) {
889: otty.sg_flags &= ~MBIT;
890: stty(2, &otty);
891: }
892: return (retval);
893: }
894:
895: char ch;
896:
897: /*
898: * Execute a colon-prefixed command.
899: * Returns <0 if not a command that should cause
900: * more of the file to be printed.
901: */
902:
903: colon (filename, cmd, nlines)
904: char *filename;
905: int cmd;
906: int nlines;
907: {
908: if (cmd == 0)
909: ch = readch ();
910: else
911: ch = cmd;
912: lastcolon = ch;
913: switch (ch) {
914: case 'f':
915: kill_line ();
916: if (!no_intty)
917: promptlen = printf ("\"%s\" line %d", fnames[fnum], Currline);
918: else
919: promptlen = printf ("[Not a file] line %d", Currline);
920: fflush (stdout);
921: return (-1);
922: case 'n':
923: if (nlines == 0) {
924: if (fnum >= nfiles - 1)
925: end_it ();
926: nlines++;
927: }
928: putchar ('\r');
929: erase (0);
930: skipf (nlines);
931: return (0);
932: case 'p':
933: if (no_intty) {
934: write (2, &bell, 1);
935: return (-1);
936: }
937: putchar ('\r');
938: erase (0);
939: if (nlines == 0)
940: nlines++;
941: skipf (-nlines);
942: return (0);
943: case '!':
944: do_shell (filename);
945: return (-1);
946: case 'q':
947: case 'Q':
948: end_it ();
949: default:
950: write (2, &bell, 1);
951: return (-1);
952: }
953: }
954:
955: /*
956: ** Read a decimal number from the terminal. Set cmd to the non-digit which
957: ** terminates the number.
958: */
959:
960: number(cmd)
961: char *cmd;
962: {
963: register int i;
964:
965: i = 0; ch = otty.sg_kill;
966: for (;;) {
967: ch = readch ();
968: if (ch >= '0' && ch <= '9')
969: i = i*10 + ch - '0';
970: else if (ch == otty.sg_kill)
971: i = 0;
972: else {
973: *cmd = ch;
974: break;
975: }
976: }
977: return (i);
978: }
979:
980: do_shell (filename)
981: char *filename;
982: {
983: char cmdbuf[80];
984:
985: kill_line ();
986: pr ("!");
987: fflush (stdout);
988: promptlen = 1;
989: if (lastp)
990: pr (shell_line);
991: else {
992: ttyin (cmdbuf, 78, '!');
993: if (expand (shell_line, cmdbuf)) {
994: kill_line ();
995: promptlen = printf ("!%s", shell_line);
996: }
997: }
998: fflush (stdout);
999: write (2, "\n", 1);
1000: promptlen = 0;
1001: shellp = 1;
1002: execute (filename, shell, shell, "-c", shell_line, 0);
1003: }
1004:
1005: /*
1006: ** Search for nth ocurrence of regular expression contained in buf in the file
1007: */
1008:
1009: search (buf, file, n)
1010: char buf[];
1011: FILE *file;
1012: register int n;
1013: {
1014: long startline = Ftell (file);
1015: register long line1 = startline;
1016: register long line2 = startline;
1017: register long line3 = startline;
1018: register int lncount;
1019: int saveln, rv, re_exec();
1020: char *s, *re_comp();
1021:
1022: context.line = saveln = Currline;
1023: context.chrctr = startline;
1024: lncount = 0;
1025: if ((s = re_comp (buf)) != 0)
1026: error (s);
1027: while (!feof (file)) {
1028: line3 = line2;
1029: line2 = line1;
1030: line1 = Ftell (file);
1031: rdline (file);
1032: lncount++;
1033: if ((rv = re_exec (Line)) == 1)
1034: if (--n == 0) {
1035: if (lncount > 3 || (lncount > 1 && no_intty))
1036: pr ("\n...skipping\n");
1037: if (!no_intty) {
1038: Currline -= (lncount >= 3 ? 3 : lncount);
1039: Fseek (file, line3);
1040: }
1041: else {
1042: kill_line ();
1043: pr (Line);
1044: putchar ('\n');
1045: }
1046: break;
1047: }
1048: else if (rv == -1)
1049: error ("Regular expression botch");
1050: }
1051: if (feof (file)) {
1052: if (!no_intty) {
1053: #ifdef V6
1054: file->_flag &= ~_IOEOF; /* why doesn't fseek do this ??!!??! */
1055: #endif
1056: Currline = saveln;
1057: Fseek (file, startline);
1058: }
1059: else {
1060: pr ("\nPattern not found\n");
1061: end_it ();
1062: }
1063: error ("Pattern not found");
1064: }
1065: }
1066:
1067: execute (filename, cmd, args)
1068: char *filename;
1069: char *cmd, *args;
1070: {
1071: int id;
1072:
1073: fflush (stdout);
1074: reset_tty ();
1075: while ((id = fork ()) < 0)
1076: sleep (5);
1077: if (id == 0) {
1078: execv (cmd, &args);
1079: write (2, "exec failed\n", 12);
1080: exit (1);
1081: }
1082: signal (SIGINT, SIG_IGN);
1083: signal (SIGQUIT, SIG_IGN);
1084: #ifdef SIGTSTP
1085: if (catch_susp)
1086: signal(SIGTSTP, SIG_DFL);
1087: #endif
1088: wait (0);
1089: signal (SIGINT, end_it);
1090: signal (SIGQUIT, onquit);
1091: #ifdef SIGTSTP
1092: if (catch_susp)
1093: signal(SIGTSTP, onsusp);
1094: #endif
1095: set_tty ();
1096: pr ("------------------------\n");
1097: prompt (filename);
1098: }
1099: /*
1100: ** Skip n lines in the file f
1101: */
1102:
1103: skiplns (n, f)
1104: register int n;
1105: register FILE *f;
1106: {
1107: register char c;
1108:
1109: while (n > 0) {
1110: while ((c = Getc (f)) != '\n')
1111: if (c == EOF)
1112: return;
1113: n--;
1114: Currline++;
1115: }
1116: }
1117:
1118: /*
1119: ** Skip nskip files in the file list (from the command line). Nskip may be
1120: ** negative.
1121: */
1122:
1123: skipf (nskip)
1124: register int nskip;
1125: {
1126: if (nskip == 0) return;
1127: if (nskip > 0) {
1128: if (fnum + nskip > nfiles - 1)
1129: nskip = nfiles - fnum - 1;
1130: }
1131: else if (within)
1132: ++fnum;
1133: fnum += nskip;
1134: if (fnum < 0)
1135: fnum = 0;
1136: pr ("\n...Skipping ");
1137: pr (nskip > 0 ? "to file " : "back to file ");
1138: pr (fnames[fnum]);
1139: pr ("\n\n");
1140: --fnum;
1141: }
1142:
1143: /*----------------------------- Terminal I/O -------------------------------*/
1144:
1145: initterm ()
1146: {
1147: char buf[TBUFSIZ];
1148: char clearbuf[100];
1149: char *clearptr, *padstr;
1150: char *getenv();
1151: int ldisc;
1152:
1153: setbuf(stdout, obuf);
1154: if (!(no_tty = gtty(1, &otty))) {
1155: if (tgetent(buf, getenv("TERM")) <= 0) {
1156: dumb++;
1157: }
1158: else {
1159: if (((Lpp = tgetnum("li")) < 0) || tgetflag("hc")) {
1160: hard++; /* Hard copy terminal */
1161: Lpp = 24;
1162: }
1163: if (tailequ (fnames[0], "page") || !hard && tgetflag("ns"))
1164: noscroll++;
1165: if ((Mcol = tgetnum("co")) < 0)
1166: Mcol = 80;
1167: Wrap = tgetflag("am");
1168: bad_so = tgetflag ("xs");
1169: clearptr = clearbuf;
1170: eraseln = tgetstr("ce",&clearptr);
1171: Clear = tgetstr("cl", &clearptr);
1172: Senter = tgetstr("so", &clearptr);
1173: Sexit = tgetstr("se", &clearptr);
1174: if (padstr = tgetstr("pc", &clearptr))
1175: PC = *padstr;
1176: }
1177: if ((shell = getenv("SHELL")) == NULL)
1178: shell = "/bin/sh";
1179: }
1180: no_intty = gtty(0, &otty);
1181: gtty(2, &otty);
1182: ospeed = otty.sg_ospeed;
1183: slow_tty = ospeed < B1200;
1184: hardtabs = !(otty.sg_flags & XTABS);
1185: if (!no_tty) {
1186: otty.sg_flags &= ~ECHO;
1187: if (MBIT == CBREAK || !slow_tty)
1188: otty.sg_flags |= MBIT;
1189: }
1190: }
1191:
1192: readch ()
1193: {
1194: char ch;
1195: extern int errno;
1196:
1197: if (read (2, &ch, 1) <= 0)
1198: if (errno != EINTR)
1199: exit(0);
1200: else
1201: ch = otty.sg_kill;
1202: return (ch);
1203: }
1204:
1205: static char BS = '\b';
1206: static char CARAT = '^';
1207:
1208: ttyin (buf, nmax, pchar)
1209: char buf[];
1210: register int nmax;
1211: char pchar;
1212: {
1213: register char *sptr;
1214: register char ch;
1215: register int slash = 0;
1216: int maxlen;
1217: char cbuf;
1218:
1219: sptr = buf;
1220: maxlen = 0;
1221: while (sptr - buf < nmax) {
1222: if (promptlen > maxlen) maxlen = promptlen;
1223: ch = readch ();
1224: if (ch == '\\') {
1225: slash++;
1226: }
1227: else if ((ch == otty.sg_erase) && !slash) {
1228: if (sptr > buf) {
1229: --promptlen;
1230: write (2, &BS, 1);
1231: --sptr;
1232: if ((*sptr < ' ' && *sptr != '\n') || *sptr == RUBOUT) {
1233: --promptlen;
1234: write (2, &BS, 1);
1235: }
1236: continue;
1237: }
1238: else {
1239: if (!eraseln) promptlen = maxlen;
1240: longjmp (restore, 1);
1241: }
1242: }
1243: else if ((ch == otty.sg_kill) && !slash) {
1244: if (hard) {
1245: show (ch);
1246: putchar ('\n');
1247: putchar (pchar);
1248: }
1249: else {
1250: putchar ('\r');
1251: putchar (pchar);
1252: if (eraseln)
1253: erase (1);
1254: promptlen = 1;
1255: }
1256: sptr = buf;
1257: fflush (stdout);
1258: continue;
1259: }
1260: if (slash && (ch == otty.sg_kill || ch == otty.sg_erase)) {
1261: write (2, &BS, 1);
1262: --sptr;
1263: }
1264: if (ch != '\\')
1265: slash = 0;
1266: *sptr++ = ch;
1267: if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) {
1268: ch += ch == RUBOUT ? -0100 : 0100;
1269: write (2, &CARAT, 1);
1270: promptlen++;
1271: }
1272: cbuf = ch;
1273: if (ch != '\n' && ch != ESC) {
1274: write (2, &cbuf, 1);
1275: promptlen++;
1276: }
1277: else
1278: break;
1279: }
1280: *--sptr = '\0';
1281: if (!eraseln) promptlen = maxlen;
1282: if (sptr - buf >= nmax - 1)
1283: error ("Line too long");
1284: }
1285:
1286: expand (outbuf, inbuf)
1287: char *outbuf;
1288: char *inbuf;
1289: {
1290: register char *instr;
1291: register char *outstr;
1292: register char ch;
1293: char temp[200];
1294: int changed = 0;
1295:
1296: instr = inbuf;
1297: outstr = temp;
1298: while ((ch = *instr++) != '\0')
1299: switch (ch) {
1300: case '%':
1301: if (!no_intty) {
1302: strcpy (outstr, fnames[fnum]);
1303: outstr += strlen (fnames[fnum]);
1304: changed++;
1305: }
1306: else
1307: *outstr++ = ch;
1308: break;
1309: case '!':
1310: if (!shellp)
1311: error ("No previous command to substitute for");
1312: strcpy (outstr, shell_line);
1313: outstr += strlen (shell_line);
1314: changed++;
1315: break;
1316: case '\\':
1317: if (*instr == '%' || *instr == '!') {
1318: *outstr++ = *instr++;
1319: break;
1320: }
1321: default:
1322: *outstr++ = ch;
1323: }
1324: *outstr++ = '\0';
1325: strcpy (outbuf, temp);
1326: return (changed);
1327: }
1328:
1329: show (ch)
1330: register char ch;
1331: {
1332: char cbuf;
1333:
1334: if ((ch < ' ' && ch != '\n' && ch != ESC) || ch == RUBOUT) {
1335: ch += ch == RUBOUT ? -0100 : 0100;
1336: write (2, &CARAT, 1);
1337: promptlen++;
1338: }
1339: cbuf = ch;
1340: write (2, &cbuf, 1);
1341: promptlen++;
1342: }
1343:
1344: error (mess)
1345: char *mess;
1346: {
1347: kill_line ();
1348: promptlen += strlen (mess);
1349: if (Senter && Sexit) {
1350: tputs (Senter, 1, putch);
1351: pr(mess);
1352: tputs (Sexit, 1, putch);
1353: }
1354: else
1355: pr (mess);
1356: fflush(stdout);
1357: errors++;
1358: longjmp (restore, 1);
1359: }
1360:
1361:
1362: set_tty ()
1363: {
1364: otty.sg_flags |= MBIT;
1365: otty.sg_flags &= ~ECHO;
1366: stty(2, &otty);
1367: }
1368:
1369: reset_tty ()
1370: {
1371: otty.sg_flags |= ECHO;
1372: otty.sg_flags &= ~MBIT;
1373: stty(2, &otty);
1374: }
1375:
1376: rdline (f)
1377: register FILE *f;
1378: {
1379: register char c;
1380: register char *p;
1381:
1382: p = Line;
1383: while ((c = Getc (f)) != '\n' && c != EOF && p - Line < LINSIZ - 1)
1384: *p++ = c;
1385: if (c == '\n')
1386: Currline++;
1387: *p = '\0';
1388: }
1389:
1390: /* Come here when we get a suspend signal from the terminal */
1391:
1392: #ifdef SIGTSTP
1393: onsusp ()
1394: {
1395: reset_tty ();
1396: fflush (stdout);
1397: /* Send the TSTP signal to suspend our process group */
1398: kill (0, SIGTSTP);
1399: /* Pause for station break */
1400:
1401: /* We're back */
1402: signal (SIGTSTP, onsusp);
1403: set_tty ();
1404: if (inwait)
1405: longjmp (restore);
1406: }
1407: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.