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