V9/cmd/troff/t6.c
/*
* t6.c
*
* width functions, sizes and fonts
*/
#include "tdef.h"
#include "dev.h"
#include <ctype.h>
#include "ext.h"
/*
fitab[f][c] is 0 if c is not on font f
if it's non-zero, c is in fontab[f] at position fitab[f][c].
*/
extern struct Font *fontbase[NFONT+1];
extern char *codetab[NFONT+1];
extern int nchtab;
int fontlab[NFONT+1];
short *pstab;
int cstab[NFONT+1];
int ccstab[NFONT+1];
int bdtab[NFONT+1];
int sbold = 0;
width(j)
register tchar j;
{
register i, k;
if (j & (ZBIT|MOT)) {
if (iszbit(j))
return(0);
if (isvmot(j))
return(0);
k = absmot(j);
if (isnmot(j))
k = -k;
return(k);
}
i = cbits(j);
if (i < 32) {
if (i == '\b')
return(-widthp);
if (i == PRESC)
i = eschar;
else if (iscontrol(i))
return(0);
}
if (i == ohc)
return(0);
i = trtab[i] - 32; /* fails for \N */
if (i < 0)
return(0);
if (sfbits(j) == oldbits) {
xfont = pfont;
xpts = ppts;
} else
xbits(j, 0);
if (i < nchtab + 128-32 && widcache[i].fontpts == (xfont<<8) + xpts && !setwdf)
k = widcache[i].width;
else {
k = getcw(i);
if (bd)
k += (bd - 1) * HOR;
if (cs)
k = cs;
}
widthp = k;
return(k);
}
/*
* clear width cache-- s means just space
*/
zapwcache(s)
{
register i;
if (s) {
widcache[0].fontpts = 0;
return;
}
for (i=0; i<NWIDCACHE; i++)
widcache[i].fontpts = 0;
}
getcw(i)
register int i;
{
register int k;
register char *p;
register int x, j;
int nocache = 0;
bd = 0;
if (i >= nchtab + 128-32) {
j = abscw(i + 32 - (nchtab+128));
goto g0;
}
if (i == 0) { /* a blank */
k = (fontab[xfont][0] * spacesz + 6) / 12;
/* this nonsense because .ss cmd uses 1/36 em as its units */
/* and default is 12 */
goto g1;
}
if ((j = fitab[xfont][i] & BYTEMASK) == 0) { /* it's not on current font */
/* search through search list of xfont
/* to see what font it ought to be on.
/* searches S, then remaining fonts in wraparound order.
*/
nocache = 1;
if (smnt) {
int ii, jj;
for (ii=smnt, jj=0; jj < nfonts; jj++, ii=ii % nfonts + 1) {
j = fitab[ii][i] & BYTEMASK;
if (j != 0) {
p = fontab[ii];
k = *(p + j);
if (xfont == sbold)
bd = bdtab[ii];
if (setwdf)
numtab[CT].val |= kerntab[ii][j];
goto g1;
}
}
}
k = fontab[xfont][0]; /* leave a space-size space */
goto g1;
}
g0:
p = fontab[xfont];
if (setwdf)
numtab[CT].val |= kerntab[xfont][j];
k = *(p + j);
g1:
if (!bd)
bd = bdtab[xfont];
if (cs = cstab[xfont]) {
nocache = 1;
if (ccs = ccstab[xfont])
x = ccs;
else
x = xpts;
cs = (cs * EMPTS(x)) / 36;
}
k = ((k&BYTEMASK) * xpts + (Unitwidth / 2)) / Unitwidth;
if (nocache|bd)
widcache[i].fontpts = 0;
else {
widcache[i].fontpts = (xfont<<8) + xpts;
widcache[i].width = k;
}
return(k);
/* Unitwidth is Units/Point, where
/* Units is the fundamental digitization
/* of the character set widths, and
/* Point is the number of goobies in a point
/* e.g., for cat, Units=36, Point=6, so Unitwidth=36/6=6
/* In effect, it's the size at which the widths
/* translate directly into units.
*/
}
abscw(n) /* return index of abs char n in fontab[], etc. */
{ register int i, ncf;
ncf = fontbase[xfont]->nwfont & BYTEMASK;
for (i = 0; i < ncf; i++)
if (codetab[xfont][i] == n)
return i;
return 0;
}
xbits(i, bitf)
register tchar i;
{
register k;
xfont = fbits(i);
k = sbits(i);
if (k) {
xpts = pstab[--k];
oldbits = sfbits(i);
pfont = xfont;
ppts = xpts;
return;
}
switch (bitf) {
case 0:
xfont = font;
xpts = pts;
break;
case 1:
xfont = pfont;
xpts = ppts;
break;
case 2:
xfont = mfont;
xpts = mpts;
}
}
tchar setch(c)
{
register j;
char temp[50];
register char *s;
extern char *chname;
extern short *chtab;
s = temp;
if (c == '(') { /* \(xx */
if ((*s++ = getach()) == 0 || (*s++ = getach()) == 0)
return(0);
} else { /* \C'...' */
c = getach();
while ((*s = getach()) != c && *s != 0 && s < temp + sizeof(temp) - 1)
s++;
}
*s = '\0';
for (j = 0; j < nchtab; j++)
if (strcmp(&chname[chtab[j]], temp) == 0)
return(j + 128 | chbits);
return(0);
}
tchar setabs() /* set absolute char from \N'...' */
{
int n;
getch();
n = 0;
n = inumb(&n);
getch();
if (nonumb)
return 0;
if (n > (fontbase[xfont]->nwfont & BYTEMASK)) {
errprint("\\N'%d' toooo large", n);
return 0;
}
return n + nchtab + 128 | chbits;
}
findft(i)
register int i;
{
register int k, c0, c1;
c0 = i & BYTEMASK; /* unPAIR: allows for 2-digit font numbers */
c1 = (i >> BYTE) & BYTEMASK;
if (isdigit(c0)) {
if (c1 == 0)
k = c0 - '0';
else if (isdigit(c1))
k = 10 * (c0 - '0') + c1 - '0';
else
k = -1;
if (k >= 0 && k <= nfonts && k < smnt)
return(k);
}
for (k = 0; fontlab[k] != i; k++)
if (k > nfonts)
return(-1);
return(k);
}
caseps()
{
register i;
if (skip())
i = apts1;
else {
noscale++;
i = inumb(&apts); /* this is a disaster for fractional point sizes */
noscale = 0;
if (nonumb)
return;
}
casps1(i);
}
casps1(i)
register int i;
{
/*
* in olden times, it used to ignore changes to 0 or negative.
* this is meant to allow the requested size to be anything,
* in particular so eqn can generate lots of \s-3's and still
* get back by matching \s+3's.
if (i <= 0)
return;
*/
apts1 = apts;
apts = i;
pts1 = pts;
pts = findps(i);
mchbits();
}
findps(i)
register int i;
{
register j, k;
for (j=k=0 ; pstab[j] != 0 ; j++)
if (abs(pstab[j]-i) < abs(pstab[k]-i))
k = j;
return(pstab[k]);
}
mchbits()
{
register i, j, k;
i = pts;
for (j = 0; i > (k = pstab[j]); j++)
if (!k) {
j--;
break;
}
chbits = 0;
setsbits(chbits, ++j);
setfbits(chbits, font);
sps = width(' ' | chbits);
zapwcache(1);
}
setps()
{
register int i, j;
i = cbits(getch());
if (isdigit(i)) { /* \sd or \sdd */
i -= '0';
if (i == 0) /* \s0 */
j = apts1;
else if (i <= 3 && isdigit(j = cbits(ch=getch()))) { /* \sdd */
j = 10 * i + j - '0';
ch = 0;
} else /* \sd */
j = i;
} else if (i == '(') { /* \s(dd */
j = cbits(getch()) - '0';
j = 10 * j + cbits(getch()) - '0';
if (j == 0) /* \s(00 */
j = apts1;
} else if (i == '+' || i == '-') { /* \s+, \s- */
j = cbits(getch());
if (isdigit(j)) { /* \s+d, \s-d */
j -= '0';
} else if (j == '(') { /* \s+(dd, \s-(dd */
j = cbits(getch()) - '0';
j = 10 * j + cbits(getch()) - '0';
}
if (i == '-')
j = -j;
j += apts;
}
casps1(j);
}
tchar setht() /* set character height from \H'...' */
{
int n;
tchar c;
getch();
n = inumb(&apts);
getch();
if (n == 0 || nonumb)
n = apts; /* does this work? */
c = CHARHT;
c |= ZBIT;
setsbits(c, n);
return(c);
}
tchar setslant() /* set slant from \S'...' */
{
int n;
tchar c;
getch();
n = 0;
n = inumb(&n);
getch();
if (nonumb)
n = 0;
c = SLANT;
c |= ZBIT;
setsfbits(c, n+180);
return(c);
}
caseft()
{
skip();
setfont(1);
}
setfont(a)
int a;
{
register i, j;
if (a)
i = getrq();
else
i = getsn();
if (!i || i == 'P') {
j = font1;
goto s0;
}
if (i == 'S' || i == '0')
return;
if ((j = findft(i)) == -1)
if ((j = setfp(0, i, (char*)0)) == -1) /* try to put it in position 0 */
return;
s0:
font1 = font;
font = j;
mchbits();
}
setwd()
{
register base, wid;
register tchar i;
int delim, emsz, k;
int savhp, savapts, savapts1, savfont, savfont1, savpts, savpts1;
base = numtab[ST].val = numtab[ST].val = wid = numtab[CT].val = 0;
if (ismot(i = getch()))
return;
delim = cbits(i);
savhp = numtab[HP].val;
numtab[HP].val = 0;
savapts = apts;
savapts1 = apts1;
savfont = font;
savfont1 = font1;
savpts = pts;
savpts1 = pts1;
setwdf++;
while (cbits(i = getch()) != delim && !nlflg) {
k = width(i);
wid += k;
numtab[HP].val += k;
if (!ismot(i)) {
emsz = POINT * xpts;
} else if (isvmot(i)) {
k = absmot(i);
if (isnmot(i))
k = -k;
base -= k;
emsz = 0;
} else
continue;
if (base < numtab[SB].val)
numtab[SB].val = base;
if ((k = base + emsz) > numtab[ST].val)
numtab[ST].val = k;
}
setn1(wid, 0, (tchar) 0);
numtab[HP].val = savhp;
apts = savapts;
apts1 = savapts1;
font = savfont;
font1 = savfont1;
pts = savpts;
pts1 = savpts1;
mchbits();
setwdf = 0;
}
tchar vmot()
{
dfact = lss;
vflag++;
return(mot());
}
tchar hmot()
{
dfact = EM;
return(mot());
}
tchar mot()
{
register int j, n;
register tchar i;
j = HOR;
getch(); /*eat delim*/
if (n = atoi()) {
if (vflag)
j = VERT;
i = makem(quant(n, j));
} else
i = 0;
getch();
vflag = 0;
dfact = 1;
return(i);
}
tchar sethl(k)
int k;
{
register j;
tchar i;
j = EM / 2;
if (k == 'u')
j = -j;
else if (k == 'r')
j = -2 * j;
vflag++;
i = makem(j);
vflag = 0;
return(i);
}
tchar makem(i)
register int i;
{
register tchar j;
if ((j = i) < 0)
j = -j;
j |= MOT;
if (i < 0)
j |= NMOT;
if (vflag)
j |= VMOT;
return(j);
}
tchar getlg(i)
tchar i;
{
tchar j, k;
register int lf;
if ((lf = fontbase[fbits(i)]->ligfont) == 0) /* font lacks ligatures */
return(i);
j = getch0();
if (cbits(j) == 'i' && (lf & LFI))
j = LIG_FI;
else if (cbits(j) == 'l' && (lf & LFL))
j = LIG_FL;
else if (cbits(j) == 'f' && (lf & LFF)) {
if ((lf & (LFFI|LFFL)) && lg != 2) {
k = getch0();
if (cbits(k)=='i' && (lf&LFFI))
j = LIG_FFI;
else if (cbits(k)=='l' && (lf&LFFL))
j = LIG_FFL;
else {
*pbp++ = k;
j = LIG_FF;
}
} else
j = LIG_FF;
} else {
*pbp++ = j;
j = i;
}
return(i & SFMASK | j);
}
caselg()
{
lg = 1;
if (skip())
return;
lg = atoi();
}
casefp()
{
register int i, j;
skip();
i = cbits(getch());
if (isdigit(i)) {
i -= '0';
j = cbits(getch());
if (isdigit(j))
i = 10 * i + j - '0';
}
if (i <= 0 || i > nfonts)
errprint("fp: bad font position %d", i);
else if (skip() || !(j = getrq()))
errprint("fp: no font name");
else if (skip() || !getname())
setfp(i, j, (char*)0);
else /* 3rd argument = filename */
setfp(i, j, nextf);
}
setfp(pos, f, truename) /* mount font f at position pos[0...nfonts] */
int pos, f;
char *truename;
{
register k;
int onw, nw;
char longname[NS], shortname[NS];
zapwcache(0);
if (truename) {
strcpy(shortname, truename);
} else {
shortname[0] = f & BYTEMASK;
shortname[1] = f >> BYTE;
shortname[2] = '\0';
}
if (truename && truename[0] == '/') /* full pathname -- use verbatim.out */
sprintf(longname, "%s.out", truename);
else
sprintf(longname, "%s/dev%s/%s.out", fontdir, devname, shortname);
if ((k = open(longname, 0)) < 0) {
errprint("Can't open %s", longname);
return(-1);
}
onw = fontbase[pos]->nwfont & BYTEMASK;
read(k, (char *) fontbase[pos], 3*onw + nchtab + 128-32 + sizeof(struct Font));
nw = fontbase[pos]->nwfont & BYTEMASK;
kerntab[pos] = (char *) fontab[pos] + nw;
codetab[pos] = (char *) fontab[pos] + 2 * nw;
/* have to reset the fitab pointer because the width may be different */
fitab[pos] = (char *) fontab[pos] + 3 * nw;
if (nw > onw) {
errprint("Font %s too big for position %d", shortname, pos);
fontbase[pos]->nwfont = onw;
return(-1);
}
fontbase[pos]->nwfont = onw; /* so can load a larger one again later */
close(k);
if (pos == smnt) {
smnt = 0;
sbold = 0;
}
if ((fontlab[pos] = f) == 'S')
smnt = pos;
bdtab[pos] = cstab[pos] = ccstab[pos] = 0;
/* if there is a directory, no place to store its name. */
/* if position isn't zero, no place to store its value. */
/* only time a FONTPOS is pushed back is if it's a */
/* standard font on position 0 (i.e., mounted implicitly. */
/* there's a bug here: if there are several input lines */
/* that look like .ft XX in short successtion, the output */
/* will all be in the last one because the "x font ..." */
/* comes out too soon. pushing back FONTPOS doesn't work */
/* with .ft commands because input is flushed after .xx cmds */
ptfpcmd(pos, shortname);
if (pos == 0)
ch = (tchar) FONTPOS | (tchar) f << 16;
return(pos);
}
casecs()
{
register i, j;
noscale++;
skip();
if (!(i = getrq()) || (i = findft(i)) < 0)
goto rtn;
skip();
cstab[i] = atoi();
skip();
j = atoi();
if (nonumb)
ccstab[i] = 0;
else
ccstab[i] = findps(j);
rtn:
zapwcache(0);
noscale = 0;
}
casebd()
{
register i, j, k;
zapwcache(0);
k = 0;
bd0:
if (skip() || !(i = getrq()) || (j = findft(i)) == -1) {
if (k)
goto bd1;
else
return;
}
if (j == smnt) {
k = smnt;
goto bd0;
}
if (k) {
sbold = j;
j = k;
}
bd1:
skip();
noscale++;
bdtab[j] = atoi();
noscale = 0;
}
casevs()
{
register i;
skip();
vflag++;
dfact = INCH; /* default scaling is points! */
dfactd = 72;
res = VERT;
i = inumb(&lss);
if (nonumb)
i = lss1;
if (i < VERT)
i = VERT;
lss1 = lss;
lss = i;
}
casess()
{
register i;
noscale++;
skip();
if (i = atoi()) {
spacesz = i & 0177;
zapwcache(0);
sps = width(' ' | chbits);
}
noscale = 0;
}
tchar xlss()
{
/* stores \x'...' into
/* two successive tchars.
/* the first contains HX, the second the value,
/* encoded as a vertical motion.
/* decoding is done in n2.c by pchar().
*/
int i;
getch();
dfact = lss;
i = quant(atoi(), VERT);
dfact = 1;
getch();
if (i >= 0)
*pbp++ = MOT | VMOT | i;
else
*pbp++ = MOT | VMOT | NMOT | -i;
return(HX);
}