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