![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to n1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / troff|
Return to n1.c CVS log | Up to [Research Unix] / researchv8dc / cmd / troff |
1.1 root 1: /*
2: * n1.c
3: *
4: * consume options, initialization, main loop,
5: * input routines, escape function calling
6: */
7:
8: #include <ctype.h>
9: #include <signal.h>
10: #include <sys/types.h>
11: #include <sys/stat.h>
12: #include <setjmp.h>
13: #include <sgtty.h>
14:
15: #include "tdef.h"
16: #include "ext.h"
17:
18: #ifdef NROFF
19: #include "tw.h"
20: #endif
21:
22: jmp_buf sjbuf;
23: extern char *sprintf();
24: filep ipl[NSO];
25: long offl[NSO];
26: long ioff;
27: char *ttyp;
28: char cfname[NSO][NS] = "<standard input>"; /*file name stack*/
29: int cfline[NSO]; /*input line count stack*/
30: char *progname; /* program name (troff) */
31:
32: main(argc, argv)
33: int argc;
34: char **argv;
35: {
36: register char *p, *q;
37: register j;
38: register tchar i;
39: extern catch(), kcatch();
40: char **oargv, *getenv();
41:
42: progname = argv[0];
43: signal(SIGHUP, catch);
44: if (signal(SIGINT, catch) == SIG_IGN) {
45: signal(SIGHUP, SIG_IGN);
46: signal(SIGINT, SIG_IGN);
47: signal(SIGQUIT, SIG_IGN);
48: }
49: signal(SIGPIPE, catch);
50: signal(SIGTERM, kcatch);
51: oargv = argv;
52: mrehash();
53: nrehash();
54: init0();
55: if ((p = getenv("TYPESETTER")) != 0)
56: strcpy(devname, p);
57: while (--argc > 0 && (++argv)[0][0] == '-')
58: switch (argv[0][1]) {
59:
60: case 'F': /* switch font tables from default */
61: if (argv[0][2] != '\0') {
62: strcpy(termtab, &argv[0][2]);
63: strcpy(fontfile, &argv[0][2]);
64: } else {
65: argv++; argc--;
66: strcpy(termtab, argv[0]);
67: strcpy(fontfile, argv[0]);
68: }
69: continue;
70: case 0:
71: goto start;
72: case 'i':
73: stdi++;
74: continue;
75: case 'q':
76: quiet++;
77: if (gtty(0, &ttys) >= 0)
78: ttysave = ttys.sg_flags;
79: continue;
80: case 'n':
81: npn = ctoi(&argv[0][2]);
82: continue;
83: case 'u': /* set emboldening amount */
84: bdtab[3] = ctoi(&argv[0][2]);
85: if (bdtab[3] < 0 || bdtab[3] > 50)
86: bdtab[3] = 0;
87: continue;
88: case 's':
89: if (!(stop = ctoi(&argv[0][2])))
90: stop++;
91: continue;
92: case 'r':
93: eibuf = sprintf(ibuf+strlen(ibuf), ".nr %c %s\n",
94: argv[0][2], &argv[0][3]);
95: continue;
96: case 'c':
97: case 'm':
98: if (mflg++ >= NMF) {
99: errprint("Too many macro packages: %s", argv[0]);
100: continue;
101: }
102: strcpy (mfiles[nmfi], nextf);
103: strcat (mfiles[nmfi++], &argv[0][2]);
104: continue;
105: case 'o':
106: getpn(&argv[0][2]);
107: continue;
108: case 'T':
109: strcpy(devname, &argv[0][2]);
110: dotT++;
111: continue;
112: #ifdef NROFF
113: case 'h':
114: hflg++;
115: continue;
116: case 'z':
117: no_out++;
118: continue;
119: case 'e':
120: eqflg++;
121: continue;
122: #endif
123: #ifndef NROFF
124: case 'z':
125: no_out++;
126: case 'a':
127: ascii = 1;
128: nofeed++;
129: continue;
130: case 'f':
131: nofeed++;
132: continue;
133: #endif
134: default:
135: errprint("unknown option %s", argv[0]);
136: done(02);
137: }
138:
139: start:
140: init1(oargv[0][0]);
141: argp = argv;
142: rargc = argc;
143: nmfi = 0;
144: init2();
145: setjmp(sjbuf);
146: loop:
147: copyf = lgf = nb = nflush = nlflg = 0;
148: if (ip && rbf0(ip) == 0 && ejf && frame->pframe <= ejl) {
149: nflush++;
150: trap = 0;
151: eject((struct s *)0);
152: goto loop;
153: }
154: i = getch();
155: if (pendt)
156: goto Lt;
157: if ((j = cbits(i)) == XPAR) {
158: copyf++;
159: tflg++;
160: while (cbits(i) != '\n')
161: pchar(i = getch());
162: tflg = 0;
163: copyf--;
164: goto loop;
165: }
166: if (j == cc || j == c2) {
167: if (j == c2)
168: nb++;
169: copyf++;
170: while ((j = cbits(i = getch())) == ' ' || j == '\t')
171: ;
172: ch = i;
173: copyf--;
174: control(getrq(), 1);
175: flushi();
176: goto loop;
177: }
178: Lt:
179: ch = i;
180: text();
181: if (nlflg)
182: numtab[HP].val = 0;
183: goto loop;
184: }
185:
186:
187: catch()
188: {
189: done3(01);
190: }
191:
192:
193: kcatch()
194: {
195: signal(SIGTERM, SIG_IGN);
196: done3(01);
197: }
198:
199:
200: init0()
201: {
202: eibuf = ibufp = ibuf;
203: ibuf[0] = 0;
204: numtab[NL].val = -1;
205: }
206:
207:
208: init1(a)
209: char a;
210: {
211: register char *p;
212: char *mktemp();
213: register i;
214:
215: p = mktemp("/usr/tmp/trtmpXXXXX");
216: if (a == 'a')
217: p = &p[9];
218: if ((close(creat(p, 0600))) < 0) {
219: errprint("cannot create temp file.");
220: exit(-1);
221: }
222: ibf = open(p, 2);
223: unlkp = p;
224: for (i = NTRTAB; --i; )
225: trtab[i] = i;
226: trtab[UNPAD] = ' ';
227: }
228:
229:
230: init2()
231: {
232: register i, j;
233: extern char *setbrk();
234: extern char *ttyname();
235:
236: ttyod = 2;
237: if ((ttyp=ttyname(j=0)) != 0 || (ttyp=ttyname(j=1)) != 0 || (ttyp=ttyname(j=2)) != 0)
238: ;
239: else
240: ttyp = "notty";
241: iflg = j;
242: if (ascii)
243: mesg(0);
244: obufp = obuf;
245: ptinit();
246: mchbits();
247: cvtime();
248: numtab[PID].val = getpid();
249: olinep = oline;
250: ioff = 0;
251: numtab[HP].val = init = 0;
252: numtab[NL].val = -1;
253: nfo = 0;
254: ifile = 0;
255: copyf = raw = 0;
256: eibuf = sprintf(ibuf+strlen(ibuf), ".ds .T %s\n", devname);
257: numtab[CD].val = -1; /* compensation */
258: cpushback(ibuf);
259: ibufp = ibuf;
260: nx = mflg;
261: frame = stk = (struct s *)setbrk(DELTA);
262: dip = &d[0];
263: nxf = frame + 1;
264: #ifdef INCORE
265: for (i = 0; i < NEV; i++) {
266: extern tchar corebuf[];
267: envcopy((struct env *) &corebuf[i * sizeof(env)/sizeof(tchar)], &env);
268: }
269: #else
270: for (i = NEV; i--; )
271: write(ibf, (char *) & env, sizeof(env));
272: #endif
273: }
274:
275:
276: cvtime()
277: {
278: long tt;
279: register i;
280: static int ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
281:
282: time(&tt);
283: tt -= 3600 * ZONE; /* 5hrs for EST */
284: numtab[DY].val = (tt / 86400L) + 1;
285: numtab[DW].val = (numtab[DY].val + 3) % 7 + 1;
286: for (numtab[YR].val = 70; ; numtab[YR].val++) {
287: if ((numtab[YR].val) % 4)
288: ms[1] = 28;
289: else
290: ms[1] = 29;
291: for (i = 0; i < 12; ) {
292: if (numtab[DY].val <= ms[i]) {
293: numtab[MO].val = i + 1;
294: return;
295: }
296: numtab[DY].val -= ms[i++];
297: }
298: }
299: }
300:
301:
302: ctoi(s)
303: register char *s;
304: {
305: register n;
306:
307: while (*s == ' ')
308: s++;
309: n = 0;
310: while (isdigit(*s))
311: n = 10 * n + *s++ - '0';
312: return n;
313: }
314:
315:
316: mesg(f)
317: int f;
318: {
319: static int mode;
320: struct stat stbuf;
321:
322: if (!f) {
323: stat(ttyp, &stbuf);
324: mode = stbuf.st_mode;
325: chmod(ttyp, mode & ~0122); /* turn off writing for others */
326: } else {
327: if (ttyp && *ttyp && mode)
328: chmod(ttyp, mode);
329: }
330: }
331:
332: errprint(s, s1, s2, s3, s4, s5) /* error message printer */
333: char *s, *s1, *s2, *s3, *s4, *s5;
334: {
335: fdprintf(stderr, "%s: ", progname);
336: fdprintf(stderr, s, s1, s2, s3, s4, s5);
337: if (numtab[CD].val > 0)
338: fdprintf(stderr, "; line %d, file %s", numtab[CD].val, cfname[ifi]);
339: fdprintf(stderr, "\n");
340: stackdump();
341: }
342:
343:
344: /*
345: * Scaled down version of C Library printf.
346: * Only %s %u %d (==%u) %o %c %x %D are recognized.
347: */
348: #define putchar(n) (*pfbp++ = (n)) /* NO CHECKING! */
349:
350: static char pfbuf[NTM];
351: static char *pfbp = pfbuf;
352: int stderr = 2; /* NOT stdio value */
353:
354: /* VARARGS2 */
355: fdprintf(fd, fmt, x1)
356: int fd;
357: register char *fmt;
358: unsigned x1;
359: {
360: register c;
361: register unsigned int *adx;
362: char *s;
363: register i;
364:
365: pfbp = pfbuf;
366: adx = &x1;
367: loop:
368: while ((c = *fmt++) != '%') {
369: if (c == '\0') {
370: if (fd == stderr)
371: write(stderr, pfbuf, pfbp - pfbuf);
372: else {
373: *pfbp = 0;
374: pfbp = pfbuf;
375: while (*pfbp) {
376: *obufp++ = *pfbp++;
377: if (obufp >= &obuf[OBUFSZ])
378: flusho();
379: }
380: }
381: return;
382: }
383: putchar(c);
384: }
385: c = *fmt++;
386: if (c == 'd') {
387: i = *adx;
388: if (i < 0) {
389: putchar('-');
390: i = -i;
391: }
392: printn((long)i, 10);
393: } else if (c == 'u' || c == 'o' || c == 'x')
394: printn((long)*adx, c == 'o' ? 8 : (c == 'x' ? 16 : 10));
395: else if (c == 'c') {
396: c = *adx & 0377;
397: if (c > 0177 || c < 040)
398: putchar('\\');
399: putchar(*adx & 0177);
400: } else if (c == 's') {
401: s = (char *) * adx;
402: while (c = *s++)
403: putchar(c);
404: } else if (c == 'D') {
405: printn(*(long *)adx, 10);
406: adx += (sizeof(long) / sizeof(int)) - 1;
407: } else if (c == 'O') {
408: printn(*(long *)adx, 8);
409: adx += (sizeof(long) / sizeof(int)) - 1;
410: }
411: adx++;
412: goto loop;
413: }
414:
415:
416: /*
417: * Print an unsigned integer in base b.
418: */
419: static printn(n, b)
420: register long n;
421: {
422: register long a;
423:
424: if (n < 0) { /* shouldn't happen */
425: putchar('-');
426: n = -n;
427: }
428: if (a = n / b)
429: printn(a, b);
430: putchar("0123456789ABCDEF"[(int)(n%b)]);
431: }
432:
433: /* scaled down version of library sprintf */
434: /* same limits as fdprintf */
435: /* returns pointer to \0 that ends the string */
436:
437: /* VARARGS2 */
438: char *sprintf(str, fmt, x1)
439: char *str;
440: char *fmt;
441: unsigned x1;
442: {
443: register c;
444: char *sprintn();
445: register unsigned int *adx;
446: char *s;
447: register i;
448:
449: adx = &x1;
450: loop:
451: while ((c = *fmt++) != '%') {
452: if (c == '\0') {
453: *str = 0;
454: return str;
455: }
456: *str++ = c;
457: }
458: c = *fmt++;
459: if (c == 'd') {
460: i = *adx;
461: if (i < 0) {
462: *str++ = '-';
463: i = -i;
464: }
465: str = sprintn(str, (long)i, 10);
466: } else if (c == 'u' || c == 'o' || c == 'x')
467: str = sprintn(str, (long)*adx, c == 'o' ? 8 : (c == 'x' ? 16 : 10));
468: else if (c == 'c') {
469: c = *adx & 0377;
470: if (c > 0177 || c < 040)
471: *str++ = '\\';
472: *str++ = *adx & 0177;
473: } else if (c == 's') {
474: s = (char *) * adx;
475: while (c = *s++)
476: *str++ = c;
477: } else if (c == 'D') {
478: str = sprintn(str, *(long *)adx, 10);
479: adx += (sizeof(long) / sizeof(int)) - 1;
480: } else if (c == 'O') {
481: str = sprintn(str, *(long *)adx, 8);
482: adx += (sizeof(long) / sizeof(int)) - 1;
483: }
484: adx++;
485: goto loop;
486: }
487:
488: /*
489: * Print an unsigned integer in base b.
490: */
491: static char *sprintn(s, n, b)
492: register char *s;
493: register long n;
494: {
495: register long a;
496:
497: if (n < 0) { /* shouldn't happen */
498: *s++ = '-';
499: n = -n;
500: }
501: if (a = n / b)
502: s = sprintn(s, a, b);
503: *s++ = "0123456789ABCDEF"[(int)(n%b)];
504: return s;
505: }
506:
507:
508: control(a, b)
509: register int a, b;
510: {
511: register int j;
512:
513: if (a == 0 || (j = findmn(a)) == -1)
514: return(0);
515: if (contab[j].f == 0) {
516: nxf->nargs = 0;
517: if (b)
518: collect();
519: flushi();
520: return pushi((filep)contab[j].mx, a);
521: } else if (b)
522: return((*contab[j].f)(0));
523: else
524: return(0);
525: }
526:
527:
528: getrq()
529: {
530: register i, j;
531:
532: if (((i = getach()) == 0) || ((j = getach()) == 0))
533: goto rtn;
534: i = PAIR(i, j);
535: rtn:
536: return(i);
537: }
538:
539: /*
540: * table encodes some special characters, to speed up tests
541: * in getchar, viz FLSS, RPT, f, \b, \n, fc, tabch, ldrch
542: */
543:
544: char
545: gchtab[] = {
546: 000,004,000,000,010,000,000,000, /* fc, ldr */
547: 001,002,001,000,001,000,000,000, /* \b, tab, nl, RPT */
548: 000,000,000,000,000,000,000,000,
549: 000,001,000,000,000,000,000,000, /* FLSS */
550: 000,000,000,000,000,000,000,000,
551: 000,000,000,000,000,000,000,000,
552: 000,000,000,000,000,000,000,000,
553: 000,000,000,000,000,000,000,000,
554: 000,000,000,000,000,000,000,000,
555: 000,000,000,000,000,000,000,000,
556: 000,000,000,000,000,000,000,000,
557: 000,000,000,000,000,000,000,000,
558: 000,000,000,000,000,000,001,000, /* f */
559: 000,000,000,000,000,000,000,000,
560: 000,000,000,000,000,000,000,000,
561: 000,000,000,000,000,000,000,000,
562: };
563:
564: tchar
565: getch()
566: {
567: register int k;
568: register tchar i, j;
569: tchar setht(), setslant();
570:
571: g0:
572: if (i = ch) {
573: if (cbits(i) == '\n')
574: nlflg++;
575: ch = 0;
576: return(i);
577: }
578:
579: if (nlflg)
580: return('\n');
581: i = getch0();
582: if (ismot(i))
583: return(i);
584: k = cbits(i);
585: if (k != ESC) {
586: if (gchtab[k]==0)
587: return(i);
588: if (k == '\n') {
589: if (cbits(i) == '\n') {
590: nlflg++;
591: if (ip == 0)
592: numtab[CD].val++; /* line number */
593: }
594: return(k);
595: }
596: if (k == FLSS) {
597: copyf++;
598: raw++;
599: i = getch0();
600: if (!fi)
601: flss = i;
602: copyf--;
603: raw--;
604: goto g0;
605: }
606: if (k == RPT) {
607: setrpt();
608: goto g0;
609: }
610: if (!copyf) {
611: if (k == 'f' && lg && !lgf) {
612: i = getlg(i);
613: return(i);
614: }
615: if (k == fc || k == tabch || k == ldrch) {
616: if ((i = setfield(k)) == 0)
617: goto g0;
618: else
619: return(i);
620: }
621: if (k == '\b') {
622: i = makem(-width(' ' | chbits));
623: return(i);
624: }
625: }
626: return(i);
627: }
628: k = cbits(j = getch0());
629: if (ismot(j))
630: return(j);
631: switch (k) {
632:
633: case 'X': /* \X'...' for copy through */
634: setxon();
635: goto g0;
636: case '\n': /* concealed newline */
637: goto g0;
638: case 'n': /* number register */
639: setn();
640: goto g0;
641: case '*': /* string indicator */
642: setstr();
643: goto g0;
644: case '$': /* argument indicator */
645: seta();
646: goto g0;
647: case '{': /* LEFT */
648: i = LEFT;
649: goto gx;
650: case '}': /* RIGHT */
651: i = RIGHT;
652: goto gx;
653: case '"': /* comment */
654: while (cbits(i = getch0()) != '\n')
655: ;
656: nlflg++;
657: if (ip == 0)
658: numtab[CD].val++;
659: return(i);
660: case ESC: /* double backslash */
661: i = eschar;
662: goto gx;
663: case 'e': /* printable version of current eschar */
664: i = PRESC;
665: goto gx;
666: case ' ': /* unpaddable space */
667: i = UNPAD;
668: goto gx;
669: case '\'': /* \(aa */
670: i = ACUTE;
671: goto gx;
672: case '`': /* \(ga */
673: i = GRAVE;
674: goto gx;
675: case '_': /* \(ul */
676: i = UNDERLINE;
677: goto gx;
678: case '-': /* current font minus */
679: i = MINUS;
680: goto gx;
681: case '&': /* filler */
682: i = FILLER;
683: goto gx;
684: case 'c': /* to be continued */
685: i = CONT;
686: goto gx;
687: case '!': /* transparent indicator */
688: i = XPAR;
689: goto gx;
690: case 't': /* tab */
691: i = '\t';
692: return(i);
693: case 'a': /* leader (SOH) */
694: i = LEADER;
695: return(i);
696: case '%': /* ohc */
697: i = OHC;
698: return(i);
699: case 'g': /* return format of a number register */
700: setaf();
701: goto g0;
702: case 'N': /* absolute character number */
703: i = setabs();
704: goto gx;
705: case '.': /* . */
706: i = '.';
707: gx:
708: setsfbits(i, sfbits(j));
709: return(i);
710: }
711: if (copyf) {
712: *pbp++ = j;
713: return(eschar);
714: }
715: switch (k) {
716:
717: case 'p': /* spread */
718: spread++;
719: goto g0;
720: case '(': /* special char name \(xx */
721: case 'C': /* \C'...' */
722: if ((i = setch(k)) == 0)
723: goto g0;
724: return(i);
725: case 's': /* size indicator */
726: setps();
727: goto g0;
728: case 'H': /* character height */
729: return(setht());
730: case 'S': /* slant */
731: return(setslant());
732: case 'f': /* font indicator */
733: setfont(0);
734: goto g0;
735: case 'w': /* width function */
736: setwd();
737: goto g0;
738: case 'v': /* vert mot */
739: if (i = vmot())
740: return(i);
741: goto g0;
742: case 'h': /* horiz mot */
743: if (i = hmot())
744: return(i);
745: goto g0;
746: case 'z': /* zero with char */
747: return(setz());
748: case 'l': /* hor line */
749: setline();
750: goto g0;
751: case 'L': /* vert line */
752: setvline();
753: goto g0;
754: case 'D': /* drawing function */
755: setdraw();
756: goto g0;
757: case 'b': /* bracket */
758: setbra();
759: goto g0;
760: case 'o': /* overstrike */
761: setov();
762: goto g0;
763: case 'k': /* mark hor place */
764: if ((k = findr(getsn())) != -1) {
765: numtab[k].val = numtab[HP].val;
766: }
767: goto g0;
768: case '0': /* number space */
769: return(makem(width('0' | chbits)));
770: #ifdef NROFF
771: case '|':
772: case '^':
773: goto g0;
774: #else
775: case '|': /* narrow space */
776: return(makem((int)(EM)/6));
777: case '^': /* half narrow space */
778: return(makem((int)(EM)/12));
779: #endif
780: case 'x': /* extra line space */
781: if (i = xlss())
782: return(i);
783: goto g0;
784: case 'u': /* half em up */
785: case 'r': /* full em up */
786: case 'd': /* half em down */
787: return(sethl(k));
788: default:
789: return(j);
790: }
791: /* NOTREACHED */
792: }
793:
794: setxon() /* \X'...' for copy through */
795: {
796: tchar xbuf[NC];
797: register tchar *i;
798: tchar c;
799: int delim, k;
800:
801: if (ismot(c = getch()))
802: return;
803: delim = cbits(c);
804: i = xbuf;
805: *i++ = XON | chbits;
806: while ((k = cbits(c = getch())) != delim && k != '\n' && i < xbuf+NC-1) {
807: if (k == ' ')
808: setcbits(c, UNPAD);
809: *i++ = c | ZBIT;
810: }
811: *i++ = XOFF | chbits;
812: *i = 0;
813: pushback(xbuf);
814: }
815:
816:
817: char ifilt[32] = {
818: 0, 001, 002, 003, 0, 005, 006, 007, 010, 011, 012};
819:
820: tchar getch0()
821: {
822: register int j;
823: register tchar i;
824:
825: again:
826: if (pbp > lastpbp)
827: i = *--pbp;
828: else if (ip) {
829: #ifdef INCORE
830: extern tchar corebuf[];
831: i = corebuf[ip];
832: if (i == 0)
833: i = rbf();
834: else {
835: if ((++ip & (BLK - 1)) == 0) {
836: --ip;
837: (void)rbf();
838: }
839: }
840: #else
841: i = rbf();
842: #endif
843: } else {
844: if (donef || ndone)
845: done(0);
846: if (nx || ibufp >= eibuf) {
847: if (nfo==0) {
848: g0:
849: if (nextfile()) {
850: if (ip)
851: goto again;
852: if (ibufp < eibuf)
853: goto g2;
854: }
855: }
856: nx = 0;
857: if ((j = read(ifile, ibuf, IBUFSZ)) <= 0)
858: goto g0;
859: ibufp = ibuf;
860: eibuf = ibuf + j;
861: if (ip)
862: goto again;
863: }
864: g2:
865: i = *ibufp++ & 0177;
866: ioff++;
867: if (i >= 040 && i < 0177)
868: goto g4;
869: if (i != 0177)
870: i = ifilt[i];
871: }
872: if (cbits(i) == IMP && !raw)
873: goto again;
874: if ((i == 0 || i == 0177) && !init && !raw) {
875: goto again;
876: }
877: g4:
878: if (copyf == 0 && (i & ~BYTEMASK) == 0)
879: i |= chbits;
880: if (cbits(i) == eschar && !raw)
881: setcbits(i, ESC);
882: return(i);
883: }
884:
885: pushback(b)
886: register tchar *b;
887: {
888: register tchar *ob = b;
889:
890: while (*b++)
891: ;
892: b--;
893: while (b > ob && pbp < &pbbuf[NC-3])
894: *pbp++ = *--b;
895: if (pbp >= &pbbuf[NC-3]) {
896: errprint("pushback overflow");
897: done(2);
898: }
899: }
900:
901: cpushback(b)
902: register char *b;
903: {
904: register char *ob = b;
905:
906: while (*b++)
907: ;
908: b--;
909: while (b > ob && pbp < &pbbuf[NC-3])
910: *pbp++ = *--b;
911: if (pbp >= &pbbuf[NC-3]) {
912: errprint("cpushback overflow");
913: done(2);
914: }
915: }
916:
917: nextfile()
918: {
919: register char *p;
920:
921: n0:
922: if (ifile)
923: close(ifile);
924: if (nx || nmfi < mflg) {
925: p = mfiles[nmfi++];
926: if (*p != 0)
927: goto n1;
928: }
929: if (ifi > 0) {
930: if (popf())
931: goto n0; /* popf error */
932: return(1); /* popf ok */
933: }
934: if (rargc-- <= 0) {
935: if ((nfo -= mflg) && !stdi)
936: done(0);
937: nfo++;
938: numtab[CD].val = ifile = stdi = mflg = 0;
939: strcpy(cfname[ifi], "<standard input>");
940: ioff = 0;
941: return(0);
942: }
943: p = (argp++)[0];
944: n1:
945: numtab[CD].val = 0;
946: if (p[0] == '-' && p[1] == 0) {
947: ifile = 0;
948: strcpy(cfname[ifi], "<standard input>");
949: } else if ((ifile = open(p, 0)) < 0) {
950: errprint("cannot open file %s", p);
951: nfo -= mflg;
952: done(02);
953: } else
954: strcpy(cfname[ifi],p);
955: nfo++;
956: ioff = 0;
957: return(0);
958: }
959:
960:
961: popf()
962: {
963: register i;
964: register char *p, *q;
965: extern char *ttyname();
966:
967: ioff = offl[--ifi];
968: numtab[CD].val = cfline[ifi]; /*restore line counter*/
969: ip = ipl[ifi];
970: if ((ifile = ifl[ifi]) == 0) {
971: p = xbuf;
972: q = ibuf;
973: ibufp = xbufp;
974: eibuf = xeibuf;
975: while (q < eibuf)
976: *q++ = *p++;
977: return(0);
978: }
979: if (lseek(ifile, (long)(ioff & ~(IBUFSZ-1)), 0) == (long) -1
980: || (i = read(ifile, ibuf, IBUFSZ)) < 0)
981: return(1);
982: eibuf = ibuf + i;
983: ibufp = ibuf;
984: if (ttyname(ifile) == 0)
985: /* was >= ... */
986: if ((ibufp = ibuf + (int)(ioff & (IBUFSZ - 1))) > eibuf)
987: return(1);
988: return(0);
989: }
990:
991:
992: flushi()
993: {
994: if (nflush)
995: return;
996: ch = 0;
997: copyf++;
998: while (!nlflg) {
999: if (donef && (frame == stk))
1000: break;
1001: getch();
1002: }
1003: copyf--;
1004: }
1005:
1006:
1007: getach()
1008: {
1009: register tchar i;
1010: register j;
1011:
1012: lgf++;
1013: j = cbits(i = getch());
1014: if (ismot(i) || j == ' ' || j == '\n' || j & 0200) {
1015: ch = i;
1016: j = 0;
1017: }
1018: lgf--;
1019: return(j & 0177);
1020: }
1021:
1022:
1023: casenx()
1024: {
1025: lgf++;
1026: skip();
1027: getname();
1028: nx++;
1029: if (nmfi > 0)
1030: nmfi--;
1031: strcpy(mfiles[nmfi], nextf);
1032: nextfile();
1033: nlflg++;
1034: ip = 0;
1035: pendt = 0;
1036: frame = stk;
1037: nxf = frame + 1;
1038: }
1039:
1040:
1041: getname()
1042: {
1043: register int j, k;
1044: tchar i;
1045:
1046: lgf++;
1047: for (k = 0; k < (NS - 1); k++) {
1048: if (((j = cbits(i = getch())) <= ' ') || (j > 0176))
1049: break;
1050: nextf[k] = j;
1051: }
1052: nextf[k] = 0;
1053: ch = i;
1054: lgf--;
1055: return(nextf[0]);
1056: }
1057:
1058:
1059: caseso()
1060: {
1061: register i;
1062: register char *p, *q;
1063:
1064: lgf++;
1065: nextf[0] = 0;
1066: if (skip() || !getname() || ((i = open(nextf, 0)) < 0) || (ifi >= NSO)) {
1067: errprint("can't open file %s", nextf);
1068: done(02);
1069: }
1070: strcpy(cfname[ifi+1], nextf);
1071: cfline[ifi] = numtab[CD].val; /*hold line counter*/
1072: numtab[CD].val = 0;
1073: flushi();
1074: ifl[ifi] = ifile;
1075: ifile = i;
1076: offl[ifi] = ioff;
1077: ioff = 0;
1078: ipl[ifi] = ip;
1079: ip = 0;
1080: nx++;
1081: nflush++;
1082: if (!ifl[ifi++]) {
1083: p = ibuf;
1084: q = xbuf;
1085: xbufp = ibufp;
1086: xeibuf = eibuf;
1087: while (p < eibuf)
1088: *q++ = *p++;
1089: }
1090: }
1091:
1092: caself() /* set line number and file */
1093: {
1094: int n;
1095:
1096: if (skip())
1097: return;
1098: n = atoi();
1099: cfline[ifi] = numtab[CD].val = n - 2;
1100: if (skip())
1101: return;
1102: if (getname())
1103: strcpy(cfname[ifi], nextf);
1104: }
1105:
1106:
1107: casecf()
1108: { /* copy file without change */
1109: #ifndef NROFF
1110: int fd, n;
1111: char buf[512];
1112: extern int hpos, esc, po;
1113:
1114: lgf++;
1115: nextf[0] = 0;
1116: if (skip() || !getname() || (fd = open(nextf, 0)) < 0) {
1117: errprint("can't open file %s", nextf);
1118: done(02);
1119: }
1120: lgf--;
1121: /* make it into a clean state, be sure that everything is out */
1122: tbreak();
1123: hpos = po;
1124: esc = 0;
1125: ptesc(); /* to left margin */
1126: esc = un;
1127: ptesc();
1128: ptlead();
1129: ptps();
1130: ptfont();
1131: flusho();
1132: while ((n = read(fd, buf, sizeof buf)) > 0)
1133: write(ptid, buf, n);
1134: close(fd);
1135: ptps();
1136: ptfont();
1137: #endif
1138: }
1139:
1140:
1141: casesy() /* call system */
1142: {
1143: char sybuf[NTM];
1144: int i;
1145:
1146: lgf++;
1147: copyf++;
1148: skip();
1149: for (i = 0; i < NTM - 2; i++)
1150: if ((sybuf[i] = getch()) == '\n')
1151: break;
1152: sybuf[i] = 0;
1153: system(sybuf);
1154: copyf--;
1155: lgf--;
1156: }
1157:
1158:
1159: getpn(a)
1160: register char *a;
1161: {
1162: register int n, neg;
1163:
1164: if (*a == 0)
1165: return;
1166: neg = 0;
1167: for ( ; *a; a++)
1168: switch (*a) {
1169: case '+':
1170: case ',':
1171: continue;
1172: case '-':
1173: neg = 1;
1174: continue;
1175: default:
1176: n = 0;
1177: if (isdigit(*a)) {
1178: do
1179: n = 10 * n + *a++ - '0';
1180: while (isdigit(*a));
1181: a--;
1182: } else
1183: n = 9999;
1184: *pnp++ = neg ? -n : n;
1185: neg = 0;
1186: if (pnp >= &pnlist[NPN-2]) {
1187: errprint("too many page numbers");
1188: done3(-3);
1189: }
1190: }
1191: if (neg)
1192: *pnp++ = -9999;
1193: *pnp = -32767;
1194: print = 0;
1195: pnp = pnlist;
1196: if (*pnp != -32767)
1197: chkpn();
1198: }
1199:
1200:
1201: setrpt()
1202: {
1203: tchar i, j;
1204:
1205: copyf++;
1206: raw++;
1207: i = getch0();
1208: copyf--;
1209: raw--;
1210: if (i < 0 || cbits(j = getch0()) == RPT)
1211: return;
1212: i &= BYTEMASK;
1213: while (i>0 && pbp < &pbbuf[NC-3]) {
1214: i--;
1215: *pbp++ = j;
1216: }
1217: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.