![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to n3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / troff|
Return to n3.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / troff |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)n3.c 4.2 10/28/82";
3: #endif lint
4:
5: #include "tdef.h"
6: extern
7: #include "d.h"
8: extern
9: #include "v.h"
10: #ifdef NROFF
11: extern
12: #include "tw.h"
13: #endif
14: #include "sdef.h"
15:
16: /*
17: troff3.c
18:
19: macro and string routines, storage allocation
20: */
21:
22: unsigned blist[NBLIST];
23: extern struct s *frame, *stk, *nxf;
24: extern filep ip;
25: extern filep offset;
26: extern filep nextb;
27: extern char *enda;
28:
29: extern int ch;
30: extern int ibf;
31: extern int lgf;
32: extern int copyf;
33: extern int ch0;
34: extern int app;
35: extern int ds;
36: extern int nlflg;
37: extern int *argtop;
38: extern int *ap;
39: extern int nchar;
40: extern int pendt;
41: extern int rchar;
42: extern int dilev;
43: extern int nonumb;
44: extern int lt;
45: extern int nrbits;
46: extern int nform;
47: extern int fmt[];
48: extern int oldmn;
49: extern int newmn;
50: extern int macerr;
51: extern filep apptr;
52: extern int diflg;
53: extern filep woff;
54: extern filep roff;
55: extern int wbfi;
56: extern int po;
57: extern int *cp;
58: extern int xxx;
59: int pagech = '%';
60: int strflg;
61: extern struct contab {
62: int rq;
63: union {
64: int (*f)();
65: unsigned mx;
66: }x;
67: }contab[NM];
68: #ifndef VMUNIX
69: int wbuf[BLK];
70: int rbuf[BLK];
71: #else
72: int *wbuf;
73: int *rbuf;
74: int Buf[NBLIST*BLK + NEV*EVS];
75: #endif
76:
77: caseig(){
78: register i;
79:
80: offset = 0;
81: if((i = copyb()) != '.')control(i,1);
82: }
83: casern(){
84: register i,j;
85:
86: lgf++;
87: skip();
88: if(((i=getrq())==0) || ((oldmn=findmn(i)) < 0))return;
89: skip();
90: clrmn(findmn(j=getrq()));
91: if(j)contab[oldmn].rq = (contab[oldmn].rq & MMASK) | j;
92: }
93: caserm(){
94: lgf++;
95: while(!skip()){
96: clrmn(findmn(getrq()));
97: }
98: }
99: caseas(){
100: app++;
101: caseds();
102: }
103: caseds(){
104: ds++;
105: casede();
106: }
107: caseam(){
108: app++;
109: casede();
110: }
111: casede(){
112: register i, req;
113: register filep savoff;
114: extern filep finds();
115:
116: if(dip != d)wbfl();
117: req = '.';
118: lgf++;
119: skip();
120: if((i=getrq())==0)goto de1;
121: if((offset=finds(i)) == 0)goto de1;
122: if(ds)copys();
123: else req = copyb();
124: wbfl();
125: clrmn(oldmn);
126: if(newmn)contab[newmn].rq = i | MMASK;
127: if(apptr){
128: savoff = offset;
129: offset = apptr;
130: wbt(IMP);
131: offset = savoff;
132: }
133: offset = dip->op;
134: if(req != '.')control(req,1);
135: de1:
136: ds = app = 0;
137: return;
138: }
139: findmn(i)
140: int i;
141: {
142: register j;
143:
144: for(j=0;j<NM;j++){
145: if(i == (contab[j].rq & ~MMASK))break;
146: }
147: if(j==NM)j = -1;
148: return(j);
149: }
150: clrmn(i)
151: int i;
152: {
153: extern filep boff();
154: if(i >= 0){
155: if(contab[i].rq & MMASK)ffree(((filep)contab[i].x.mx)<<BLKBITS);
156: contab[i].rq = 0;
157: contab[i].x.mx = 0;
158: }
159: }
160: filep finds(mn)
161: int mn;
162: {
163: register i;
164: extern filep boff();
165: register filep savip;
166: extern filep alloc();
167: extern filep incoff();
168:
169: oldmn = findmn(mn);
170: newmn = 0;
171: apptr = (filep)0;
172: if(app && (oldmn >= 0) && (contab[oldmn].rq & MMASK)){
173: savip = ip;
174: ip = (((filep)contab[oldmn].x.mx)<<BLKBITS);
175: oldmn = -1;
176: while((i=rbf()) != 0);
177: apptr = ip;
178: if(!diflg)ip = incoff(ip);
179: nextb = ip;
180: ip = savip;
181: }else{
182: for(i=0;i<NM;i++){
183: if(contab[i].rq == 0)break;
184: }
185: if((i==NM) ||
186: (nextb = alloc()) == 0){
187: app = 0;
188: if(macerr++ > 1)done2(02);
189: prstr("Too many string/macro names.\n");
190: edone(04);
191: return(offset = 0);
192: }
193: contab[i].x.mx = (unsigned)(nextb>>BLKBITS);
194: if(!diflg){
195: newmn = i;
196: if(oldmn == -1)contab[i].rq = -1;
197: }else{
198: contab[i].rq = mn | MMASK;
199: }
200: }
201:
202: app = 0;
203: return(offset = nextb);
204: }
205: skip(){
206: register i;
207:
208: while(((i=getch()) & CMASK) == ' ');
209: ch=i;
210: return(nlflg);
211: }
212: copyb()
213: {
214: register i, j, k;
215: int ii, req, state;
216: filep savoff;
217:
218: if(skip() || !(j=getrq()))j = '.';
219: req = j;
220: k = j>>BYTE;
221: j &= BMASK;
222: copyf++;
223: flushi();
224: nlflg = 0;
225: state = 1;
226: while(1){
227: i = (ii = getch()) & CMASK;
228: if(state == 3){
229: if(i == k)break;
230: if(!k){
231: ch = ii;
232: i = getach();
233: ch = ii;
234: if(!i)break;
235: }
236: state = 0;
237: goto c0;
238: }
239: if(i == '\n'){
240: state = 1;
241: nlflg = 0;
242: goto c0;
243: }
244: if((state == 1) && (i == '.')){
245: state++;
246: savoff = offset;
247: goto c0;
248: }
249: if((state == 2) && (i == j)){
250: state++;
251: goto c0;
252: }
253: state = 0;
254: c0:
255: if(offset)wbf(ii);
256: }
257: if(offset){
258: wbfl();
259: offset = savoff;
260: wbt(0);
261: }
262: copyf--;
263: return(req);
264: }
265: copys()
266: {
267: register i;
268:
269: copyf++;
270: if(skip())goto c0;
271: if(((i=getch()) & CMASK) != '"')wbf(i);
272: while(((i=getch()) & CMASK) != '\n')wbf(i);
273: c0:
274: wbt(0);
275: copyf--;
276: }
277: filep alloc()
278: {
279: register i;
280: extern filep boff();
281: filep j;
282:
283: for(i=0;i<NBLIST;i++){
284: if(blist[i] == 0)break;
285: }
286: if(i==NBLIST){
287: j = 0;
288: }else{
289: blist[i] = -1;
290: if((j = boff(i)) < NEV*EVS)j = 0;
291: }
292: return(nextb = j);
293: }
294: ffree(i)
295: filep i;
296: {
297: register j;
298:
299: while((blist[j = blisti(i)]) != -1){
300: i = ((filep)blist[j])<<BLKBITS;
301: blist[j] = 0;
302: }
303: blist[j] = 0;
304: }
305: filep boff(i)
306: int i;
307: {
308: return(((filep)i)*BLK + NEV*EVS);
309: }
310: wbt(i)
311: int i;
312: {
313: wbf(i);
314: wbfl();
315: }
316: wbf(i)
317: int i;
318: {
319: register j;
320:
321: if(!offset)return;
322: if(!woff){
323: woff = offset;
324: #ifdef VMUNIX
325: wbuf = &Buf[woff];
326: #endif
327: wbfi = 0;
328: }
329: wbuf[wbfi++] = i;
330: if(!((++offset) & (BLK-1))){
331: wbfl();
332: if(blist[j = blisti(--offset)] == -1){
333: if(alloc() == 0){
334: prstr("Out of temp file space.\n");
335: done2(01);
336: }
337: blist[j] = (unsigned)(nextb>>BLKBITS);
338: }
339: offset = ((filep)blist[j])<<BLKBITS;
340: }
341: if(wbfi >= BLK)wbfl();
342: }
343: wbfl(){
344: if(woff == 0)return;
345: #ifndef VMUNIX
346: lseek(ibf, ((long)woff) * sizeof(int), 0);
347: write(ibf, (char *)wbuf, wbfi * sizeof(int));
348: #endif
349: if((woff & (~(BLK-1))) == (roff & (~(BLK-1))))roff = -1;
350: woff = 0;
351: }
352: blisti(i)
353: filep i;
354: {
355: return((i-NEV*EVS)/(BLK));
356: }
357: rbf(){
358: register i;
359: extern filep incoff();
360:
361: if((i=rbf0(ip)) == 0){
362: if(!app)i = popi();
363: }else{
364: ip = incoff(ip);
365: }
366: return(i);
367: }
368: rbf0(p)
369: filep p;
370: {
371: register filep i;
372:
373: if((i = (p & (~(BLK-1)))) != roff){
374: roff = i;
375: #ifndef VMUNIX
376: lseek(ibf, ((long)roff) * sizeof(int), 0);
377: if(read(ibf, (char *)rbuf, BLK * sizeof(int)) == 0)return(0);
378: #else
379: rbuf = &Buf[roff];
380: #endif
381: }
382: return(rbuf[p & (BLK-1)]);
383: }
384: filep incoff(p)
385: filep p;
386: {
387: register i;
388: register filep j;
389: if(!((j = (++p)) & (BLK-1))){
390: if((i = blist[blisti(--p)]) == -1){
391: prstr("Bad storage allocation.\n");
392: done2(-5);
393: }
394: j = ((filep)i)<<BLKBITS;
395: }
396: return(j);
397: }
398: popi(){
399: register struct s *p;
400:
401: if(frame == stk)return(0);
402: if(strflg)strflg--;
403: p = nxf = frame;
404: p->nargs = 0;
405: frame = p->pframe;
406: ip = p->pip;
407: nchar = p->pnchar;
408: rchar = p->prchar;
409: pendt = p->ppendt;
410: ap = p->pap;
411: cp = p->pcp;
412: ch0 = p->pch0;
413: return(p->pch);
414: }
415:
416: /*
417: * test that the end of the allocation is above a certain location
418: * in memory
419: */
420: #define SPACETEST(base, size) while ((enda - (size)) <= (char *)(base)){setbrk(DELTA);}
421:
422: pushi(newip)
423: filep newip;
424: {
425: register struct s *p;
426: extern char *setbrk();
427:
428: SPACETEST(nxf, sizeof(struct s));
429: p = nxf;
430: p->pframe = frame;
431: p->pip = ip;
432: p->pnchar = nchar;
433: p->prchar = rchar;
434: p->ppendt = pendt;
435: p->pap = ap;
436: p->pcp = cp;
437: p->pch0 = ch0;
438: p->pch = ch;
439: cp = ap = 0;
440: nchar = rchar = pendt = ch0 = ch = 0;
441: frame = nxf;
442: if (nxf->nargs == 0)
443: nxf += 1;
444: else
445: nxf = (struct s *)argtop;
446: return(ip = newip);
447: }
448:
449:
450: char *setbrk(x)
451: int x;
452: {
453: register char *i;
454: char *sbrk();
455:
456: /* ought to be rounded up by sizeof(int) */
457: if (x % 2 == 1)
458: x++;
459: if ( (i = sbrk(x)) >= (char *)MAXPTR) {
460: prstrfl("Core limit reached.\n");
461: edone(0100);
462: } else {
463: enda = i + x;
464: }
465: return(i);
466: }
467:
468:
469: getsn()
470: {
471: register i;
472:
473: if ((i = getach()) == 0)
474: return(0);
475: if (i == '(')
476: return(getrq());
477: else
478: return(i);
479: }
480:
481:
482: setstr()
483: {
484: register i;
485:
486: lgf++;
487: if ( ((i = getsn()) == 0)
488: || ((i = findmn(i)) == -1)
489: || !(contab[i].rq & MMASK)) {
490: lgf--;
491: return(0);
492: } else {
493: SPACETEST(nxf, sizeof(struct s));
494: nxf->nargs = 0;
495: strflg++;
496: lgf--;
497: return(pushi(((filep)contab[i].x.mx)<<BLKBITS));
498: }
499: }
500:
501: typedef int tchar;
502: #define cbits(x) ((x) & CMASK)
503:
504: collect()
505: {
506: register j;
507: tchar i;
508: register tchar *strp;
509: tchar * lim;
510: tchar * *argpp, **argppend;
511: int quote;
512: struct s *savnxf;
513:
514: copyf++;
515: nxf->nargs = 0;
516: savnxf = nxf;
517: if (skip())
518: goto rtn;
519:
520: {
521: char *memp;
522: memp = (char *)savnxf;
523: /*
524: * 1 s structure for the macro descriptor
525: * APERMAC tchar *'s for pointers into the strings
526: * space for the tchar's themselves
527: */
528: memp += sizeof(struct s);
529: /*
530: * CPERMAC (the total # of characters for ALL arguments)
531: * to a macros, has been carefully chosen
532: * so that the distance between stack frames is < DELTA
533: */
534: #define CPERMAC 200
535: #define APERMAC 9
536: memp += APERMAC * sizeof(tchar *);
537: memp += CPERMAC * sizeof(tchar);
538: nxf = (struct s*)memp;
539: }
540: lim = (tchar *)nxf;
541: argpp = (tchar **)(savnxf + 1);
542: argppend = &argpp[APERMAC];
543: SPACETEST(argppend, sizeof(tchar *));
544: strp = (tchar *)argppend;
545: /*
546: * Zero out all the string pointers before filling them in.
547: */
548: for (j = 0; j < APERMAC; j++){
549: argpp[j] = (tchar *)0;
550: }
551: #if 0
552: fprintf(stderr, "savnxf=0x%x,nxf=0x%x,argpp=0x%x,strp=argppend=0x%x,lim=0x%x,enda=0x%x\n",
553: savnxf, nxf, argpp, strp, lim, enda);
554: #endif 0
555: strflg = 0;
556: while ((argpp != argppend) && (!skip())) {
557: *argpp++ = strp;
558: quote = 0;
559: if (cbits(i = getch()) == '"')
560: quote++;
561: else
562: ch = i;
563: while (1) {
564: i = getch();
565: if ( nlflg || (!quote && cbits(i) == ' '))
566: break;
567: if ( quote
568: && (cbits(i) == '"')
569: && (cbits(i = getch()) != '"')) {
570: ch = i;
571: break;
572: }
573: *strp++ = i;
574: if (strflg && (strp >= lim)) {
575: #if 0
576: fprintf(stderr, "strp=0x%x, lim = 0x%x\n",
577: strp, lim);
578: #endif 0
579: prstrfl("Macro argument too long.\n");
580: copyf--;
581: edone(004);
582: }
583: SPACETEST(strp, 3 * sizeof(tchar));
584: }
585: *strp++ = 0;
586: }
587: nxf = savnxf;
588: nxf->nargs = argpp - (tchar **)(savnxf + 1);
589: argtop = strp;
590: rtn:
591: copyf--;
592: }
593:
594:
595: seta()
596: {
597: register i;
598:
599: if(((i = (getch() & CMASK) - '0') > 0) &&
600: (i <= APERMAC) && (i <= frame->nargs))ap = *((int **)frame + i-1 + (sizeof(struct s)/sizeof(int **)));
601: }
602: caseda(){
603: app++;
604: casedi();
605: }
606: casedi(){
607: register i, j;
608: register *k;
609:
610: lgf++;
611: if(skip() || ((i=getrq()) == 0)){
612: if(dip != d)wbt(0);
613: if(dilev > 0){
614: v.dn = dip->dnl;
615: v.dl = dip->maxl;
616: dip = &d[--dilev];
617: offset = dip->op;
618: }
619: goto rtn;
620: }
621: if(++dilev == NDI){
622: --dilev;
623: prstr("Cannot divert.\n");
624: edone(02);
625: }
626: if(dip != d)wbt(0);
627: diflg++;
628: dip = &d[dilev];
629: dip->op = finds(i);
630: dip->curd = i;
631: clrmn(oldmn);
632: k = (int *)&dip->dnl;
633: for(j=0; j<10; j++)k[j] = 0; /*not op and curd*/
634: rtn:
635: app = 0;
636: diflg = 0;
637: }
638: casedt(){
639: lgf++;
640: dip->dimac = dip->ditrap = dip->ditf = 0;
641: skip();
642: dip->ditrap = vnumb((int *)0);
643: if(nonumb)return;
644: skip();
645: dip->dimac = getrq();
646: }
647: casetl(){
648: register i, j;
649: int w1, w2, w3, delim;
650: filep begin;
651: extern width(), pchar();
652:
653: dip->nls = 0;
654: skip();
655: if(dip != d)wbfl();
656: if((offset = begin = alloc()) == 0)return;
657: if((delim = getch()) & MOT){
658: ch = delim;
659: delim = '\'';
660: }else delim &= CMASK;
661: if(!nlflg)
662: while(((i = getch()) & CMASK) != '\n'){
663: if((i & CMASK) == delim)i = IMP;
664: wbf(i);
665: }
666: wbf(IMP);wbf(IMP);wbt(0);
667:
668: w1 = hseg(width,begin);
669: w2 = hseg(width,(filep)0);
670: w3 = hseg(width,(filep)0);
671: offset = dip->op;
672: #ifdef NROFF
673: if(!offset)horiz(po);
674: #endif
675: hseg(pchar,begin);
676: if(w2 || w3)horiz(j=quant((lt - w2)/2-w1,HOR));
677: hseg(pchar,(filep)0);
678: if(w3){
679: horiz(lt-w1-w2-w3-j);
680: hseg(pchar,(filep)0);
681: }
682: newline(0);
683: if(dip != d){if(dip->dnl > dip->hnl)dip->hnl = dip->dnl;}
684: else{if(v.nl > dip->hnl)dip->hnl = v.nl;}
685: ffree(begin);
686: }
687: casepc(){
688: pagech = chget(IMP);
689: }
690: hseg(f,p)
691: int (*f)();
692: filep p;
693: {
694: register acc, i;
695: static filep q;
696:
697: acc = 0;
698: if(p)q = p;
699: while(1){
700: i = rbf0(q);
701: q = incoff(q);
702: if(!i || (i == IMP))return(acc);
703: if((i & CMASK) == pagech){
704: nrbits = i & ~CMASK;
705: nform = fmt[findr('%')];
706: acc += fnumb(v.pn,f);
707: }else acc += (*f)(i);
708: }
709: }
710: casepm(){
711: register i, k;
712: register char *p;
713: int xx, cnt, kk, tot;
714: filep j;
715: char *kvt();
716: char pmline[10];
717:
718: kk = cnt = 0;
719: tot = !skip();
720: for(i = 0; i<NM; i++){
721: if(!((xx = contab[i].rq) & MMASK))continue;
722: p = pmline;
723: j = (((filep)contab[i].x.mx)<<BLKBITS);
724: k = 1;
725: while((j = blist[blisti(j)]) != -1){k++; j <<= BLKBITS;}
726: cnt++;
727: kk += k;
728: if(!tot){
729: *p++ = xx & 0177;
730: if(!(*p++ = (xx >> BYTE) & 0177))*(p-1) = ' ';
731: *p++ = ' ';
732: kvt(k,p);
733: prstr(pmline);
734: }
735: }
736: if(tot || (cnt > 1)){
737: kvt(kk,pmline);
738: prstr(pmline);
739: }
740: }
741: char *kvt(k,p)
742: int k;
743: char *p;
744: {
745: if(k>=100)*p++ = k/100 + '0';
746: if(k>=10)*p++ = (k%100)/10 + '0';
747: *p++ = k%10 + '0';
748: *p++ = '\n';
749: *p = 0;
750: return(p);
751: }
752: dummy(){}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.