1 /*
2  * t6.c
3  *
4  * width functions, sizes and fonts
5  */
6 
7 #include "tdef.h"
8 #include "fns.h"
9 #include "ext.h"
10 
11 int	fontlab[MAXFONTS+1];
12 int	cstab[MAXFONTS+1];
13 int	ccstab[MAXFONTS+1];
14 int	bdtab[MAXFONTS+1];
15 int	sbold = 0;
16 
17 int
18 t_width(Tchar j)
19 {
20 	int i, k;
21 
22 	if (iszbit(j))
23 		return 0;
24 	if (ismot(j)) {
25 		if (isvmot(j))
26 			return(0);
27 		k = absmot(j);
28 		if (isnmot(j))
29 			k = -k;
30 		return(k);
31 	}
32 	i = cbits(j);
33 	if (i < ' ') {
34 		if (i == '\b')
35 			return(-widthp);
36 		if (i == PRESC)
37 			i = eschar;
38 		else if (i == HX)
39 			return(0);
40 	}
41 	if (i == ohc)
42 		return(0);
43 	i = trtab[i];
44 	if (i < ' ')
45 		return(0);
46 	if (sfbits(j) == oldbits) {
47 		xfont = pfont;
48 		xpts = ppts;
49 	} else
50 		xbits(j, 0);
51 	if (i < nchnames + ALPHABET && widcache[i].fontpts == (xfont<<8) + xpts && !setwdf)
52 		k = widcache[i].width;
53 	else {
54 		k = getcw(i);
55 		if (bd)
56 			k += (bd - 1) * HOR;
57 		if (cs)
58 			k = cs;
59 	}
60 	widthp = k;
61 	return(k);
62 }
63 
64 /*
65  * clear width cache-- s means just space
66  */
67 void zapwcache(int s)
68 {
69 	int i;
70 
71 	if (s) {
72 		widcache[' '].fontpts = 0;
73 		return;
74 	}
75 	for (i=0; i<NWIDCACHE; i++)
76 		widcache[i].fontpts = 0;
77 }
78 
79 int
80 onfont(int n, int f)	/* is char n on font f? */
81 {
82 	int i;
83 	Font *fp = &fonts[f];
84 	Chwid *cp, *ep;
85 	char *np;
86 
87 	if (n < ALPHABET) {
88 		if (fp->wp[n].num == n)	/* ascii at front */
89 			return n;
90 		else
91 			return -1;
92 	}
93 	cp = &fp->wp[ALPHABET];
94 	ep = &fp->wp[fp->nchars];
95 	for ( ; cp < ep; cp++)	/* search others */
96 		if (cp->num == n)
97 			return cp - &fp->wp[0];
98 	/* maybe it was a \N... */
99 	np = chname(n);
100 	if (*np == Number) {
101 		i = atoi(np+1);		/* sscanf(np+1, "%d", &i); */
102 		cp = &fp->wp[0];
103 		ep = &fp->wp[fp->nchars];
104 		for ( ; cp < ep; cp++) {	/* search others */
105 			if (cp->code == i)
106 				return cp - &fp->wp[0];
107 		}
108 		return -2;	/* a \N that doesn't have an entry */
109 	}
110 	return -1;	/* vanilla not found */
111 }
112 
113 int
114 getcw(int i)
115 {
116 	int k, n, x;
117 	Font *fp;
118 	int nocache = 0;
119 	if (i < ' ')
120 		return 0;
121 	bd = 0;
122 	fp = &fonts[xfont];
123 	if (i == ' ') {	/* a blank */
124 		k = (fp->spacewidth * spacesz + 6) / 12;
125 		/* this nonsense because .ss cmd uses 1/36 em as its units */
126 		/* 	and default is 12 */
127 	} else if ((n = onfont(i, xfont)) >= 0) {	/* on this font at n */
128 		k = fp->wp[n].wid;
129 		if (setwdf)
130 			numtabp[CT].val |= fp->wp[n].kern;
131 	} else if (n == -2) {		/* \N with default width */
132 
133 		k = fp->defaultwidth;
134 	} else {			/* not on current font */
135 		nocache = 1;
136 		k = fp->defaultwidth;	/* default-size space */
137 		if (smnt) {
138 			int ii, jj;
139 			for (ii=smnt, jj=0; jj < nfonts; jj++, ii=ii % nfonts + 1) {
140 				if ((n = onfont(i, ii)) >= 0) {
141 					k = fonts[ii].wp[n].wid;
142 					if (xfont == sbold)
143 						bd = bdtab[ii];
144 					if (setwdf)
145 						numtabp[CT].val |= fonts[ii].wp[n].kern;
146 					break;
147 				}
148 			}
149 		}
150 	}
151 	if (!bd)
152 		bd = bdtab[xfont];
153 	if (cs = cstab[xfont]) {
154 		nocache = 1;
155 		if (ccs = ccstab[xfont])
156 			x = ccs;
157 		else
158 			x = xpts;
159 		cs = (cs * EMPTS(x)) / 36;
160 	}
161 	/* was (k & BYTEMASK);  since .wid is unsigned, should never happen */
162 	if (k < 0)
163 		ERROR "can't happen: negative width %d in getcw %d\n", k, i WARN;
164 	k = (k * xpts + (Unitwidth / 2)) / Unitwidth;
165 	if (nocache|bd)
166 		widcache[i].fontpts = 0;
167 	else {
168 		widcache[i].fontpts = (xfont<<8) + xpts;
169 		widcache[i].width = k;
170 	}
171 	return(k);
172 	/* Unitwidth is Units/Point, where
173 	/* Units is the fundamental digitization
174 	/* of the character set widths, and
175 	/* Point is the number of goobies in a point
176 	/* e.g., for cat, Units=36, Point=6, so Unitwidth=36/6=6
177 	/* In effect, it's the size at which the widths
178 	/* translate directly into units.
179 	*/
180 }
181 
182 void xbits(Tchar i, int bitf)
183 {
184 	int k;
185 
186 	if(TROFF) {
187 		xfont = fbits(i);
188 		k = sbits(i);
189 		if(k) {
190 			xpts = pstab[k-1];
191 			oldbits = sfbits(i);
192 			pfont = xfont;
193 			ppts = xpts;
194 			return;
195 		}
196 		switch(bitf) {
197 		case 0:
198 			xfont = font;
199 			xpts = pts;
200 			break;
201 		case 1:
202 			xfont = pfont;
203 			xpts = ppts;
204 			break;
205 		case 2:
206 			xfont = mfont;
207 			xpts = mpts;
208 		}
209 	}
210 }
211 
212 
213 /* these next two functions ought to be the same in troff and nroff, */
214 /* but the data structures they search are different. */
215 /* silly historical problem. */
216 
217 
218 Tchar t_setch(int c)
219 {
220 #ifndef UNICODE
221 	int j;
222 #endif
223 	char temp[50];
224 	char *s;
225 
226 #ifndef UNICODE
227 	j = 0;
228 #endif
229 	s = temp;
230 	if (c == '(') {	/* \(xx */
231 		if ((*s++ = getach()) == 0 || (*s++ = getach()) == 0)
232 			return(0);
233 	} else {	/* \C'...' */
234 		c = getach();
235 		while ((*s = getach()) != c && *s != 0 && s < temp + sizeof(temp) - 1)
236 			s++;
237 	}
238 	*s = '\0';
239 #ifdef UNICODE
240 	return chadd(temp, Troffchar, Install) | chbits; /* add name even if haven't seen it */
241 #else
242 	if (NROFF) {
243 		j = chadd(temp, Troffchar, Lookup);
244 		if ( j == -1)
245 			return 0;
246 		else
247 			return j | chbits;
248 	} else
249 		return chadd(temp, Troffchar, Install) | chbits; /* add name even if haven't seen it */
250 
251 #endif /*UNICODE*/
252 }
253 
254 Tchar t_setabs(void)		/* set absolute char from \N'...' */
255 {
256 	int n;
257 	char temp[10];
258 
259 	getch();	/* delim */
260 	n = 0;
261 	n = inumb(&n);
262 	getch();	/* delim */
263 	if (nonumb)
264 		return 0;
265 	sprintf(temp, "%d", n);	/* convert into "#n" */
266 	n = chadd(temp, Number, Install);
267 	return n | chbits;
268 }
269 
270 
271 /*
272  * fontlab[] is a cache that contains font information
273  * for each font.
274  * fontlab[] contains the 1- or 2-character name of the
275  * font current associated with that font.
276  * fonts 1..nfonts correspond to the mounted fonts;
277  * the last of these are the special fonts.
278  * If we don't use the (named) font in one of the
279  * standard positions, we install the name in the next
280  * free slot of fontlab[] and font[].
281  * Whenever we need info about the font, we
282  * read in the data into the next free slot with getfont.
283  * The ptfont() (t10.c) routine will tell
284  * the device filter to put the font always at position
285  * zero if xfont > nfonts, so no need to change these filters.
286  * Yes, this is a bit kludgy.
287  *
288  * This gives the new specs of findft:
289  * 	find the font name i, where i also can be a number.
290  * 	Installs the font(name) i when not present
291  * 	returns -1 on error
292  */
293 
294 int
295 t_findft(int i)
296 {
297 	int k;
298 	Uchar *p;
299 
300 	p = unpair(i);
301 
302 	if (isdigit(p[0])) {		/* first look for numbers */
303 		k = p[0] - '0';
304 		if (p[1] > 0 && isdigit(p[1]))
305 			k = 10 * k + p[1] - '0';
306 		if (k > 0 && k <= nfonts && k < smnt)
307 			return(k);	/* mounted font:  .ft 3 */
308 		if (fontlab[k] && k <= MAXFONTS) {	/* translate */
309 			return(k);			/*number to a name */
310 		} else {
311 			fprintf(stderr, "troff: no font at position %d\n", k);
312 			return(-1);	/* wild number */
313 		}
314 	}
315 
316 	/*
317 	 * Now we look for font names
318 	 */
319 	for (k = 1; fontlab[k] != i; k++) {
320 		if (k > MAXFONTS)
321 			return(-1);	/* running out of fontlab space */
322 		if (fontlab[k] == 0) {	/* passed all existing names */
323 			if (setfp(k, i, (char *) 0, 1) == -1)
324 				return(-1);
325 			else {
326 				fontlab[k] = i;	/* install the name */
327 				return(k);
328 			}
329 		}
330 	}
331 	return(k);			/* was one of the existing names */
332 }
333 
334 
335 void caseps(void)
336 {
337 	int i;
338 
339 	if (TROFF) {
340 		if(skip())
341 			i = apts1;
342 		else {
343 			noscale++;
344 			i = inumb(&apts);	/* this is a disaster for fractional point sizes */
345 			noscale = 0;
346 			if(nonumb)
347 				i = apts1;
348 		}
349 		casps1(i);
350 	}
351 }
352 
353 
354 void casps1(int i)
355 {
356 
357 /*
358  * in olden times, it used to ignore changes to 0 or negative.
359  * this is meant to allow the requested size to be anything,
360  * in particular so eqn can generate lots of \s-3's and still
361  * get back by matching \s+3's.
362 
363 	if (i <= 0)
364 		return;
365 */
366 	apts1 = apts;
367 	apts = i;
368 	pts1 = pts;
369 	pts = findps(i);
370 	mchbits();
371 }
372 
373 int
374 findps(int i)
375 {
376 	int j, k;
377 
378 	for (j=k=0 ; pstab[j] != 0 ; j++)
379 		if (abs(pstab[j]-i) < abs(pstab[k]-i))
380 			k = j;
381 
382 	return(pstab[k]);
383 }
384 
385 
386 void t_mchbits(void)
387 {
388 	int i, j, k;
389 
390 	i = pts;
391 	for (j = 0; i > (k = pstab[j]); j++)
392 		if (!k) {
393 			j--;
394 			break;
395 		}
396 	chbits = 0;
397 	setsbits(chbits, ++j);
398 	setfbits(chbits, font);
399 	sps = width(' ' | chbits);
400 	zapwcache(1);
401 }
402 
403 void t_setps(void)
404 {
405 	int i, j;
406 
407 	j = 0;
408 	i = cbits(getch());
409 	if (isdigit(i)) {		/* \sd or \sdd */
410 		i -= '0';
411 		if (i == 0)		/* \s0 */
412 			j = apts1;
413 		else if (i <= 3 && (ch=getch()) && isdigit(j = cbits(ch))) {	/* \sdd */
414 			j = 10 * i + j - '0';
415 			ch = 0;
416 		} else		/* \sd */
417 			j = i;
418 	} else if (i == '(') {		/* \s(dd */
419 		j = cbits(getch()) - '0';
420 		j = 10 * j + cbits(getch()) - '0';
421 		if (j == 0)		/* \s(00 */
422 			j = apts1;
423 	} else if (i == '+' || i == '-') {	/* \s+, \s- */
424 		j = cbits(getch());
425 		if (isdigit(j)) {		/* \s+d, \s-d */
426 			j -= '0';
427 		} else if (j == '(') {		/* \s+(dd, \s-(dd */
428 			j = cbits(getch()) - '0';
429 			j = 10 * j + cbits(getch()) - '0';
430 		}
431 		if (i == '-')
432 			j = -j;
433 		j += apts;
434 	}
435 	casps1(j);
436 }
437 
438 
439 Tchar t_setht(void)		/* set character height from \H'...' */
440 {
441 	int n;
442 	Tchar c;
443 
444 	getch();
445 	n = inumb(&apts);
446 	getch();
447 	if (n == 0 || nonumb)
448 		n = apts;	/* does this work? */
449 	c = CHARHT;
450 	c |= ZBIT;
451 	setsbits(c, n);
452 	setfbits(c, pts);	/* sneaky, CHARHT font bits are size bits */
453 	return(c);
454 }
455 
456 Tchar t_setslant(void)		/* set slant from \S'...' */
457 {
458 	int n;
459 	Tchar c;
460 
461 	getch();
462 	n = 0;
463 	n = inumb(&n);
464 	getch();
465 	if (nonumb)
466 		n = 0;
467 	c = SLANT;
468 	c |= ZBIT;
469 	setsfbits(c, n+180);
470 	return(c);
471 }
472 
473 
474 void caseft(void)
475 {
476 	if (!TROFF) {
477 		n_caseft();
478 		return;
479 	}
480 	skip();
481 	setfont(1);
482 }
483 
484 
485 void t_setfont(int a)
486 {
487 	int i, j;
488 
489 	if (a)
490 		i = getrq();
491 	else
492 		i = getsn();
493 	if (!i || i == 'P') {
494 		j = font1;
495 		goto s0;
496 	}
497 	if (/* i == 'S' || */ i == '0')	/* an experiment -- why can't we change to it? */
498 		return;
499 	if ((j = findft(i)) == -1)
500 		if ((j = setfp(0, i, (char*) 0, 1)) == -1)	/* try to put it in position 0 */
501 			return;
502 s0:
503 	font1 = font;
504 	font = j;
505 	mchbits();
506 }
507 
508 
509 void t_setwd(void)
510 {
511 	int base, wid;
512 	Tchar i;
513 	int delim, emsz, k;
514 	int savhp, savapts, savapts1, savfont, savfont1, savpts, savpts1;
515 
516 	base = numtabp[ST].val = numtabp[SB].val = wid = numtabp[CT].val = 0;
517 	if (ismot(i = getch()))
518 		return;
519 	delim = cbits(i);
520 	savhp = numtabp[HP].val;
521 	numtabp[HP].val = 0;
522 	savapts = apts;
523 	savapts1 = apts1;
524 	savfont = font;
525 	savfont1 = font1;
526 	savpts = pts;
527 	savpts1 = pts1;
528 	setwdf++;
529 	while (cbits(i = getch()) != delim && !nlflg) {
530 		k = width(i);
531 		wid += k;
532 		numtabp[HP].val += k;
533 		if (!ismot(i)) {
534 			emsz = (INCH/72) * xpts;
535 		} else if (isvmot(i)) {
536 			k = absmot(i);
537 			if (isnmot(i))
538 				k = -k;
539 			base -= k;
540 			emsz = 0;
541 		} else
542 			continue;
543 		if (base < numtabp[SB].val)
544 			numtabp[SB].val = base;
545 		if ((k = base + emsz) > numtabp[ST].val)
546 			numtabp[ST].val = k;
547 	}
548 	setn1(wid, 0, (Tchar) 0);
549 	numtabp[HP].val = savhp;
550 	apts = savapts;
551 	apts1 = savapts1;
552 	font = savfont;
553 	font1 = savfont1;
554 	pts = savpts;
555 	pts1 = savpts1;
556 	mchbits();
557 	setwdf = 0;
558 }
559 
560 
561 Tchar t_vmot(void)
562 {
563 	dfact = lss;
564 	vflag++;
565 	return t_mot();
566 }
567 
568 
569 Tchar t_hmot(void)
570 {
571 	dfact = EM;
572 	return t_mot();
573 }
574 
575 
576 Tchar t_mot(void)
577 {
578 	int j, n;
579 	Tchar i;
580 
581 	j = HOR;
582 	getch(); /*eat delim*/
583 	if (n = atoi0()) {
584 		if (vflag)
585 			j = VERT;
586 		i = makem(quant(n, j));
587 	} else
588 		i = 0;
589 	getch();
590 	vflag = 0;
591 	dfact = 1;
592 	return(i);
593 }
594 
595 
596 Tchar t_sethl(int k)
597 {
598 	int j;
599 	Tchar i;
600 
601 	j = EM / 2;
602 	if (k == 'u')
603 		j = -j;
604 	else if (k == 'r')
605 		j = -2 * j;
606 	vflag++;
607 	i = makem(j);
608 	vflag = 0;
609 	return(i);
610 }
611 
612 
613 Tchar t_makem(int i)
614 {
615 	Tchar j;
616 
617 	if (i >= 0)
618 		j = i;
619 	else
620 		j = -i;
621 	if (Hor > 1 && !vflag)
622 		j = (j + Hor/2)/Hor * Hor;
623 	j |= MOT;
624 	if (i < 0)
625 		j |= NMOT;
626 	if (vflag)
627 		j |= VMOT;
628 	return(j);
629 }
630 
631 
632 Tchar getlg(Tchar i)
633 {
634 	Tchar j, k;
635 	int lf;
636 
637 	if (!TROFF)
638 		return i;
639 	if ((lf = fonts[fbits(i)].ligfont) == 0) /* font lacks ligatures */
640 		return(i);
641 	j = getch0();
642 	if (cbits(j) == 'i' && (lf & LFI))
643 		j = LIG_FI;
644 	else if (cbits(j) == 'l' && (lf & LFL))
645 		j = LIG_FL;
646 	else if (cbits(j) == 'f' && (lf & LFF)) {
647 		if ((lf & (LFFI|LFFL)) && lg != 2) {
648 			k = getch0();
649 			if (cbits(k)=='i' && (lf&LFFI))
650 				j = LIG_FFI;
651 			else if (cbits(k)=='l' && (lf&LFFL))
652 				j = LIG_FFL;
653 			else {
654 				*pbp++ = k;
655 				j = LIG_FF;
656 			}
657 		} else
658 			j = LIG_FF;
659 	} else {
660 		*pbp++ = j;
661 		j = i;
662 	}
663 	return(i & SFMASK | j);
664 }
665 
666 
667 void caselg(void)
668 {
669 
670 	if(TROFF) {
671 		skip();
672 		lg = atoi0();
673 		if (nonumb)
674 			lg = 1;
675 	}
676 }
677 
678 void casefp(void)
679 {
680 	int i, j;
681 
682 	if (!TROFF) {
683 		n_casefp();
684 		return;
685 	}
686 	skip();
687 	i = cbits(getch());
688 	if (isdigit(i)) {
689 		i -= '0';
690 		j = cbits(getch());
691 		if (isdigit(j))
692 			i = 10 * i + j - '0';
693 	}
694 	if (i <= 0 || i > nfonts)
695 		ERROR "fp: bad font position %d", i WARN;
696 	else if (skip() || !(j = getrq()))
697 		ERROR "fp: no font name" WARN;
698 	else if (skip() || !getname())
699 		setfp(i, j, (char*) 0, 1);
700 	else		/* 3rd argument = filename */
701 		setfp(i, j, nextf, 1);
702 }
703 
704 char *strdupl(const char *s)	/* make a copy of s */
705 {
706 	char *t;
707 
708 	t = (char *) malloc(strlen(s) + 1);
709 	if (t == NULL)
710 		ERROR "out of space in strdupl(%s)", s FATAL;
711 	strcpy(t, s);
712 	return t;
713 }
714 
715 int
716 setfp(int pos, int f, char *truename, int print)	/* mount font f at position pos[0...nfonts] */
717 {
718 	char pathname[NS], shortname[NS];
719 
720 	zapwcache(0);
721 	if (truename)
722 		strcpy(shortname, truename);
723 	else
724 		strcpy(shortname, (char *) unpair(f));
725 	if (truename && strrchr(truename, '/')) {	/* .fp 1 R dir/file: use verbatim */
726 		snprintf(pathname, NS, "%s", truename);
727 		if (fonts[pos].truename)
728 			free(fonts[pos].truename);
729 		fonts[pos].truename = strdupl(truename);
730 	} else if (truename) {			/* synonym: .fp 1 R Avant */
731 		snprintf(pathname, NS, "%s/dev%s/%s", fontdir, devname, truename);
732 		truename = 0;	/* so doesn't get repeated by ptfpcmd */
733 	} else					/* vanilla: .fp 5 XX */
734 		snprintf(pathname, NS, "%s/dev%s/%s", fontdir, devname, shortname);
735 	if (truename == 0 && fonts[pos].truename != 0) {
736 		free(fonts[pos].truename);
737 		fonts[pos].truename = 0;
738 	}
739 	if (getfont(pathname, pos) < 0) {
740 		ERROR "Can't open font file %s", pathname WARN;
741 		return -1;
742 	}
743 	if (print && !ascii) {
744 		ptfpcmd(pos, fonts[pos].longname, truename);
745 		ptfont();
746 	}
747 	if (pos == smnt) {
748 		smnt = 0;
749 		sbold = 0;
750 	}
751 	fontlab[pos] = f;
752 	if (smnt == 0 && fonts[pos].specfont)
753 		smnt = pos;
754 	bdtab[pos] = cstab[pos] = ccstab[pos] = 0;
755 	return pos;
756 }
757 
758 /*
759  * .cs request; don't check legality of optional arguments
760  */
761 void casecs(void)
762 {
763 	int i, j;
764 
765 	if (TROFF) {
766 		int savtr = trace;
767 
768 		trace = 0;
769 		noscale++;
770 		skip();
771 		if (!(i = getrq()) || (i = findft(i)) < 0)
772 			goto rtn;
773 		skip();
774 		cstab[i] = atoi0();
775 		skip();
776 		j = atoi0();
777 		if(nonumb)
778 			ccstab[i] = 0;
779 		else
780 			ccstab[i] = findps(j);
781 	rtn:
782 		zapwcache(0);
783 		noscale = 0;
784 		trace = savtr;
785 	}
786 }
787 
788 
789 void casebd(void)
790 {
791 	int i, j, k;
792 
793 	j=0;
794 	if (!TROFF) {
795 		n_casebd();
796 		return;
797 	}
798 	zapwcache(0);
799 	k = 0;
800 bd0:
801 	if (skip() || !(i = getrq()) || (j = findft(i)) == -1) {
802 		if (k)
803 			goto bd1;
804 		else
805 			return;
806 	}
807 	if (j == smnt) {
808 		k = smnt;
809 		goto bd0;
810 	}
811 	if (k) {
812 		sbold = j;
813 		j = k;
814 	}
815 bd1:
816 	skip();
817 	noscale++;
818 	bdtab[j] = atoi0();
819 	noscale = 0;
820 }
821 
822 
823 void casevs(void)
824 {
825 	int i;
826 
827 	if (!TROFF) {
828 		n_casevs();
829 		return;
830 	}
831 	skip();
832 	vflag++;
833 	dfact = INCH; /* default scaling is points! */
834 	dfactd = 72;
835 	res = VERT;
836 	i = inumb(&lss);
837 	if (nonumb)
838 		i = lss1;
839 	if (i < VERT)
840 		i = VERT;
841 	lss1 = lss;
842 	lss = i;
843 }
844 
845 
846 void casess(void)
847 {
848 	int i;
849 
850 	if(TROFF) {
851 		noscale++;
852 		skip();
853 		if(i = atoi0()) {
854 			spacesz = i & 0177;
855 			zapwcache(0);
856 			sps = width(' ' | chbits);
857 		}
858 		noscale = 0;
859 	}
860 }
861 
862 
863 Tchar t_xlss(void)
864 {
865 	/* stores \x'...' into two successive Tchars.
866 	/* the first contains HX, the second the value,
867 	/* encoded as a vertical motion.
868 	/* decoding is done in n2.c by pchar().
869 	*/
870 	int i;
871 
872 	getch();
873 	dfact = lss;
874 	i = quant(atoi0(), VERT);
875 	dfact = 1;
876 	getch();
877 	if (i >= 0)
878 		*pbp++ = MOT | VMOT | i;
879 	else
880 		*pbp++ = MOT | VMOT | NMOT | -i;
881 	return(HX);
882 }
883 
884 Uchar *unpair(int i)
885 {
886 	static Uchar name[3];
887 
888 	name[0] = i & SHORTMASK;
889 	name[1] = (i >> SHORT) & SHORTMASK;
890 	name[2] = 0;
891 	return name;
892 }