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