![[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 [Research Unix] / researchv10no / cmd / troff|
Return to n3.c CVS log | Up to [Research Unix] / researchv10no / cmd / troff |
1.1 root 1: /*
2: * troff3.c
3: *
4: * macro and string routines, storage allocation
5: */
6:
7:
8: #include "tdef.h"
9: #include "fns.h"
10: #include "ext.h"
11:
12: Tchar *argtop;
13: int pagech = '%';
14: int strflg;
15:
16: #define MHASHSIZE 128 /* must be 2**n */
17: #define MHASH(x) ((x>>6)^x) & (MHASHSIZE-1)
18: Contab *mhash[MHASHSIZE];
19:
20:
21: Blockp *blist; /* allocated blocks for macros and strings */
22: int nblist; /* how many there are */
23:
24: void blockinit(void)
25: {
26: blist = (Blockp *) calloc(NBLIST, sizeof(Blockp));
27: if (blist == NULL) {
28: ERROR "not enough room for %d blocks", NBLIST WARN;
29: done2(1);
30: }
31: nblist = NBLIST;
32: blist[0].nextoff = blist[1].nextoff = -1;
33: blist[0].bp = (Tchar *) calloc(BLK, sizeof(Tchar));
34: blist[1].bp = (Tchar *) calloc(BLK, sizeof(Tchar));
35: /* -1 prevents blist[0] from being used; temporary fix */
36: /* for a design botch: offset==0 is overloaded. */
37: /* blist[1] reserved for .rd indicator -- also unused. */
38: /* but someone unwittingly looks at these, so allocate something */
39: }
40:
41:
42: void caseig(void)
43: {
44: int i;
45: Offset oldoff = offset;
46:
47: offset = 0;
48: i = copyb();
49: offset = oldoff;
50: if (i != '.')
51: control(i, 1);
52: }
53:
54:
55: void casern(void)
56: {
57: int i, j;
58:
59: lgf++;
60: skip();
61: if ((i = getrq()) == 0 || (oldmn = findmn(i)) < 0)
62: return;
63: skip();
64: clrmn(findmn(j = getrq()));
65: if (j) {
66: munhash(&contab[oldmn]);
67: contab[oldmn].rq = j;
68: maddhash(&contab[oldmn]);
69: }
70: }
71:
72: void maddhash(Contab *rp)
73: {
74: Contab **hp;
75:
76: if (rp->rq == 0)
77: return;
78: hp = &mhash[MHASH(rp->rq)];
79: rp->link = *hp;
80: *hp = rp;
81: }
82:
83: void munhash(Contab *mp)
84: {
85: Contab *p;
86: Contab **lp;
87:
88: if (mp->rq == 0)
89: return;
90: lp = &mhash[MHASH(mp->rq)];
91: p = *lp;
92: while (p) {
93: if (p == mp) {
94: *lp = p->link;
95: p->link = 0;
96: return;
97: }
98: lp = &p->link;
99: p = p->link;
100: }
101: }
102:
103: void mrehash(void)
104: {
105: Contab *p;
106: int i;
107:
108: for (i=0; i < MHASHSIZE; i++)
109: mhash[i] = 0;
110: for (p=contab; p < &contab[NM]; p++)
111: p->link = 0;
112: for (p=contab; p < &contab[NM]; p++) {
113: if (p->rq == 0)
114: continue;
115: i = MHASH(p->rq);
116: p->link = mhash[i];
117: mhash[i] = p;
118: }
119: }
120:
121: void caserm(void)
122: {
123: int j;
124:
125: lgf++;
126: while (!skip() && (j = getrq()) != 0)
127: clrmn(findmn(j));
128: lgf--;
129: }
130:
131:
132: void caseas(void)
133: {
134: app++;
135: caseds();
136: }
137:
138:
139: void caseds(void)
140: {
141: ds++;
142: casede();
143: }
144:
145:
146: void caseam(void)
147: {
148: app++;
149: casede();
150: }
151:
152:
153: void casede(void)
154: {
155: int i, req;
156: Offset savoff;
157:
158: req = '.';
159: lgf++;
160: skip();
161: if ((i = getrq()) == 0)
162: goto de1;
163: if ((offset = finds(i)) == 0)
164: goto de1;
165: if (ds)
166: copys();
167: else
168: req = copyb();
169: clrmn(oldmn);
170: if (newmn) {
171: if (contab[newmn].rq)
172: munhash(&contab[newmn]);
173: contab[newmn].rq = i;
174: maddhash(&contab[newmn]);
175: }
176: if (apptr) {
177: savoff = offset;
178: offset = apptr;
179: wbf((Tchar) IMP);
180: offset = savoff;
181: }
182: offset = dip->op;
183: if (req != '.')
184: control(req, 1);
185: de1:
186: ds = app = 0;
187: }
188:
189:
190: int findmn(int i)
191: {
192: Contab *p;
193:
194: for (p = mhash[MHASH(i)]; p; p = p->link)
195: if (i == p->rq)
196: return(p - contab);
197: return(-1);
198: }
199:
200:
201: void clrmn(int i)
202: {
203: if (i >= 0) {
204: if (contab[i].mx)
205: ffree(contab[i].mx);
206: munhash(&contab[i]);
207: contab[i].rq = 0;
208: contab[i].mx = 0;
209: contab[i].f = 0;
210: }
211: }
212:
213:
214: Offset finds(int mn)
215: {
216: int i;
217: Offset savip;
218:
219: oldmn = findmn(mn);
220: newmn = 0;
221: apptr = 0;
222: if (app && oldmn >= 0 && contab[oldmn].mx) {
223: savip = ip;
224: ip = contab[oldmn].mx;
225: oldmn = -1;
226: while (rbf() != 0)
227: ;
228: apptr = ip;
229: if (!diflg)
230: ip = incoff(ip);
231: nextb = ip;
232: ip = savip;
233: } else {
234: for (i = 0; i < NM; i++) {
235: if (contab[i].rq == 0)
236: break;
237: }
238: if (i == NM || (nextb = alloc()) == -1) {
239: app = 0;
240: if (macerr++ > 1)
241: done2(02);
242: if (i == NM)
243: ERROR "Too many (%d) string/macro names", NM WARN;
244: if (nextb == 0)
245: ERROR "Too much space for string/macro names" WARN, abort();
246: edone(04);
247: return(offset = 0);
248: }
249: contab[i].mx = nextb;
250: if (!diflg) {
251: newmn = i;
252: if (oldmn == -1)
253: contab[i].rq = -1;
254: } else {
255: contab[i].rq = mn;
256: maddhash(&contab[i]);
257: }
258: }
259: app = 0;
260: return(offset = nextb);
261: }
262:
263:
264: int skip(void)
265: {
266: Tchar i;
267:
268: while (cbits(i = getch()) == ' ')
269: ;
270: ch = i;
271: return(nlflg);
272: }
273:
274:
275: int copyb(void)
276: {
277: int i, j, state;
278: Tchar ii;
279: int req, k;
280: Offset savoff;
281: char *p;
282:
283: if (skip() || !(j = getrq()))
284: j = '.';
285: req = j;
286: p = unpair(j);
287: /* was: k = j >> BYTE; j &= BYTEMASK; */
288: j = p[0];
289: k = p[1];
290: copyf++;
291: flushi();
292: nlflg = 0;
293: state = 1;
294:
295: /* state 0 eat up
296: * state 1 look for .
297: * state 2 look for first char of end macro
298: * state 3 look for second char of end macro
299: */
300:
301: while (1) {
302: i = cbits(ii = getch());
303: if (state == 3) {
304: if (i == k)
305: break;
306: if (!k) {
307: ch = ii;
308: i = getach();
309: ch = ii;
310: if (!i)
311: break;
312: }
313: state = 0;
314: goto c0;
315: }
316: if (i == '\n') {
317: state = 1;
318: nlflg = 0;
319: goto c0;
320: }
321: if (state == 1 && i == '.') {
322: state++;
323: savoff = offset;
324: goto c0;
325: }
326: if (state == 2 && i == j) {
327: state++;
328: goto c0;
329: }
330: state = 0;
331: c0:
332: if (offset)
333: wbf(ii);
334: }
335: if (offset) {
336: offset = savoff;
337: wbf((Tchar)0);
338: }
339: copyf--;
340: return(req);
341: }
342:
343:
344: void copys(void)
345: {
346: Tchar i;
347:
348: copyf++;
349: if (skip())
350: goto c0;
351: if (cbits(i = getch()) != '"')
352: wbf(i);
353: while (cbits(i = getch()) != '\n')
354: wbf(i);
355: c0:
356: wbf((Tchar)0);
357: copyf--;
358: }
359:
360:
361: Offset alloc(void) /* return free Offset in nextb */
362: {
363: int i, j;
364:
365: for (i = 0; i < nblist; i++)
366: if (blist[i].nextoff == 0)
367: break;
368: if (i == nblist) {
369: blist = (Blockp *) realloc((char *) blist, 2 * nblist * sizeof(Blockp));
370: if (blist == NULL) {
371: ERROR "can't grow blist for string/macro defns" WARN;
372: done2(2);
373: }
374: nblist *= 2;
375: for (j = i; j < nblist; j++) {
376: blist[j].nextoff = 0;
377: blist[j].bp = 0;
378: }
379: }
380: blist[i].nextoff = -1; /* this block is the end */
381: if (blist[i].bp == 0)
382: blist[i].bp = (Tchar *) calloc(BLK, sizeof(Tchar));
383: nextb = (Offset) i * BLK;
384: return nextb;
385: }
386:
387:
388: void ffree(Offset i) /* free list of blocks starting at blist(o) */
389: { /* (doesn't actually free the blocks, just the pointers) */
390: int j;
391:
392: for ( ; blist[j = bindex(i)].nextoff != -1; ) {
393: i = blist[j].nextoff;
394: blist[j].nextoff = 0;
395: }
396: blist[j].nextoff = 0;
397: }
398:
399:
400: void wbf(Tchar i) /* store i into offset, get ready for next one */
401: {
402: int j, off;
403:
404: if (!offset)
405: return;
406: j = bindex(offset);
407: off = boffset(offset);
408: blist[j].bp[off++] = i;
409: offset++;
410: if (pastend(offset)) { /* off the end of this block */
411: if (blist[j].nextoff == -1) {
412: if ((nextb = alloc()) == -1) {
413: ERROR "Out of temp file space" WARN;
414: done2(01);
415: }
416: blist[j].nextoff = nextb;
417: }
418: offset = blist[j].nextoff;
419: }
420: }
421:
422:
423: Tchar rbf(void) /* return next char from blist[] block */
424: {
425: Tchar i, j;
426:
427: if (ip == RD_OFFSET) { /* for rdtty */
428: if (j = rdtty())
429: return(j);
430: else
431: return(popi());
432: }
433:
434: i = rbf0(ip);
435: if (i == 0) {
436: if (!app)
437: i = popi();
438: return(i);
439: }
440: ip = incoff(ip);
441: return(i);
442: }
443:
444:
445: Offset xxxincoff(Offset p) /* get next blist[] block */
446: {
447: p++;
448: if (pastend(p)) { /* off the end of this block */
449: if ((p = blist[bindex(p-1)].nextoff) == -1) { /* and nothing was allocated after it */
450: ERROR "Bad storage allocation" WARN;
451: done2(-5);
452: }
453: }
454: return(p);
455: }
456:
457:
458: Tchar popi(void)
459: {
460: Stack *p;
461:
462: if (frame == stk)
463: return(0);
464: if (strflg)
465: strflg--;
466: p = nxf = frame;
467: p->nargs = 0;
468: frame = p->pframe;
469: ip = p->pip;
470: pendt = p->ppendt;
471: lastpbp = p->lastpbp;
472: return(p->pch);
473: }
474:
475: /*
476: * test that the end of the allocation is above a certain location
477: * in memory
478: */
479: #define SPACETEST(base, size) \
480: if ((char*)base + size >= (char*)stk+STACKSIZE) \
481: ERROR "Stacksize overflow in n3" WARN
482:
483: Offset pushi(Offset newip, int mname)
484: {
485: Stack *p;
486:
487: SPACETEST(nxf, sizeof(Stack));
488: p = nxf;
489: p->pframe = frame;
490: p->pip = ip;
491: p->ppendt = pendt;
492: p->pch = ch;
493: p->lastpbp = lastpbp;
494: p->mname = mname;
495: lastpbp = pbp;
496: pendt = ch = 0;
497: frame = nxf;
498: if (nxf->nargs == 0)
499: nxf += 1;
500: else
501: nxf = (Stack *)argtop;
502: return(ip = newip);
503: }
504:
505:
506: void *setbrk(int x)
507: {
508: char *i;
509:
510: if ((i = (char *) calloc(x, 1)) == 0) {
511: ERROR "Core limit reached" WARN;
512: edone(0100);
513: }
514: return(i);
515: }
516:
517:
518: int getsn(void)
519: {
520: int i;
521:
522: if ((i = getach()) == 0)
523: return(0);
524: if (i == '(')
525: return(getrq());
526: else
527: return(i);
528: }
529:
530:
531: Offset setstr(void)
532: {
533: int i, j;
534:
535: lgf++;
536: if ((i = getsn()) == 0 || (j = findmn(i)) == -1 || !contab[j].mx) {
537: lgf--;
538: return(0);
539: } else {
540: SPACETEST(nxf, sizeof(Stack));
541: nxf->nargs = 0;
542: strflg++;
543: lgf--;
544: return pushi(contab[j].mx, i);
545: }
546: }
547:
548:
549:
550: void collect(void)
551: {
552: int j;
553: Tchar i, *strp, *lim, **argpp, **argppend;
554: int quote;
555: Stack *savnxf;
556:
557: copyf++;
558: nxf->nargs = 0;
559: savnxf = nxf;
560: if (skip())
561: goto rtn;
562:
563: {
564: char *memp;
565: memp = (char *)savnxf;
566: /*
567: * 1 s structure for the macro descriptor
568: * APERMAC Tchar *'s for pointers into the strings
569: * space for the Tchar's themselves
570: */
571: memp += sizeof(Stack);
572: /*
573: * CPERMAC = the total # of characters for ALL arguments
574: */
575: #define CPERMAC 200
576: #define APERMAC 9
577: memp += APERMAC * sizeof(Tchar *);
578: memp += CPERMAC * sizeof(Tchar);
579: nxf = (Stack *)memp;
580: }
581: lim = (Tchar *)nxf;
582: argpp = (Tchar **)(savnxf + 1);
583: argppend = &argpp[APERMAC];
584: SPACETEST(argppend, sizeof(Tchar *));
585: strp = (Tchar *)argppend;
586: /*
587: * Zero out all the string pointers before filling them in.
588: */
589: for (j = 0; j < APERMAC; j++)
590: argpp[j] = 0;
591: /* ERROR "savnxf=0x%x,nxf=0x%x,argpp=0x%x,strp=argppend=0x%x, lim=0x%x",
592: * savnxf, nxf, argpp, strp, lim WARN;
593: */
594: strflg = 0;
595: while (argpp != argppend && !skip()) {
596: *argpp++ = strp;
597: quote = 0;
598: if (cbits(i = getch()) == '"')
599: quote++;
600: else
601: ch = i;
602: while (1) {
603: i = getch();
604: /* fprintf(stderr, "collect %c %d\n", cbits(i), cbits(i)); */
605: if (nlflg || (!quote && argpp != argppend && cbits(i) == ' '))
606: break; /* collects rest into $9 */
607: if ( quote
608: && cbits(i) == '"'
609: && cbits(i = getch()) != '"') {
610: ch = i;
611: break;
612: }
613: *strp++ = i;
614: if (strflg && strp >= lim) {
615: /* ERROR "strp=0x%x, lim = 0x%x", strp, lim WARN; */
616: ERROR "Macro argument too long" WARN;
617: copyf--;
618: edone(004);
619: }
620: SPACETEST(strp, 3 * sizeof(Tchar));
621: }
622: *strp++ = 0;
623: }
624: nxf = savnxf;
625: nxf->nargs = argpp - (Tchar **)(savnxf + 1);
626: argtop = strp;
627: rtn:
628: copyf--;
629: }
630:
631:
632: void seta(void)
633: {
634: int i;
635:
636: i = cbits(getch()) - '0';
637: if (i > 0 && i <= APERMAC && i <= frame->nargs)
638: pushback(*(((Tchar **)(frame + 1)) + i - 1));
639: }
640:
641:
642: void caseda(void)
643: {
644: app++;
645: casedi();
646: }
647:
648:
649: void casedi(void)
650: {
651: int i, j, *k;
652:
653: lgf++;
654: if (skip() || (i = getrq()) == 0) {
655: if (dip != d)
656: wbf((Tchar)0);
657: if (dilev > 0) {
658: numtab[DN].val = dip->dnl;
659: numtab[DL].val = dip->maxl;
660: dip = &d[--dilev];
661: offset = dip->op;
662: }
663: goto rtn;
664: }
665: if (++dilev == NDI) {
666: --dilev;
667: ERROR "Diversions nested too deep" WARN;
668: edone(02);
669: }
670: if (dip != d)
671: wbf((Tchar)0);
672: diflg++;
673: dip = &d[dilev];
674: dip->op = finds(i);
675: dip->curd = i;
676: clrmn(oldmn);
677: k = (int *) & dip->dnl;
678: for (j = 0; j < 10; j++)
679: k[j] = 0; /*not op and curd*/
680: rtn:
681: app = 0;
682: diflg = 0;
683: }
684:
685:
686: void casedt(void)
687: {
688: lgf++;
689: dip->dimac = dip->ditrap = dip->ditf = 0;
690: skip();
691: dip->ditrap = vnumb((int *)0);
692: if (nonumb)
693: return;
694: skip();
695: dip->dimac = getrq();
696: }
697:
698:
699: void casetl(void)
700: {
701: int j;
702: int w[3];
703: Tchar buf[LNSIZE];
704: Tchar *tp;
705: Tchar i, delim;
706:
707: /*
708: * bug fix
709: *
710: * if .tl is the first thing in the file, the p1
711: * doesn't come out, also the pagenumber will be 0
712: *
713: * tends too confuse the device filter (and the user as well)
714: */
715: if (dip == d && numtab[NL].val == -1)
716: newline(1);
717: dip->nls = 0;
718: skip();
719: if (ismot(delim = getch())) {
720: ch = delim;
721: delim = '\'';
722: } else
723: delim = cbits(delim);
724: tp = buf;
725: numtab[HP].val = 0;
726: w[0] = w[1] = w[2] = 0;
727: j = 0;
728: while (cbits(i = getch()) != '\n') {
729: if (cbits(i) == cbits(delim)) {
730: if (j < 3)
731: w[j] = numtab[HP].val;
732: numtab[HP].val = 0;
733: j++;
734: *tp++ = 0;
735: } else {
736: if (cbits(i) == pagech) {
737: setn1(numtab[PN].val, numtab[findr('%')].fmt,
738: i&SFMASK);
739: continue;
740: }
741: numtab[HP].val += width(i);
742: if (tp < &buf[LNSIZE-10])
743: *tp++ = i;
744: }
745: }
746: if (j<3)
747: w[j] = numtab[HP].val;
748: *tp++ = 0;
749: *tp++ = 0;
750: *tp = 0;
751: tp = buf;
752: if (NROFF)
753: horiz(po);
754: while (i = *tp++)
755: pchar(i);
756: if (w[1] || w[2])
757: horiz(j = quant((lt - w[1]) / 2 - w[0], HOR));
758: while (i = *tp++)
759: pchar(i);
760: if (w[2]) {
761: horiz(lt - w[0] - w[1] - w[2] - j);
762: while (i = *tp++)
763: pchar(i);
764: }
765: newline(0);
766: if (dip != d) {
767: if (dip->dnl > dip->hnl)
768: dip->hnl = dip->dnl;
769: } else {
770: if (numtab[NL].val > dip->hnl)
771: dip->hnl = numtab[NL].val;
772: }
773: }
774:
775:
776: void casepc(void)
777: {
778: pagech = chget(IMP);
779: }
780:
781:
782: void casepm(void)
783: {
784: int i, k;
785: int xx, cnt, tcnt, kk, tot;
786: Offset j;
787:
788: kk = cnt = tcnt = 0;
789: tot = !skip();
790: stackdump();
791: for (i = 0; i < NM; i++) {
792: if ((xx = contab[i].rq) == 0 || contab[i].mx == 0)
793: continue;
794: tcnt++;
795: j = contab[i].mx;
796: for (k = 1; (j = blist[bindex(j)].nextoff) != -1; )
797: k++;
798: cnt++;
799: kk += k;
800: if (!tot)
801: fprintf(stderr, "%-2.2s %d\n", unpair(xx), k);
802: }
803: fprintf(stderr, "pm: total %d, macros %d, space %d\n", tcnt, cnt, kk);
804: }
805:
806: void stackdump(void) /* dumps stack of macros in process */
807: {
808: Stack *p;
809:
810: if (frame != stk) {
811: fprintf(stderr, "stack: ");
812: for (p = frame; p != stk; p = p->pframe)
813: fprintf(stderr, "%s ", unpair(p->mname));
814: fprintf(stderr, "\n");
815: }
816: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.