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