Let's try this. It's BUGGERED.
This commit is contained in:
rsc
parent
76e6aca867
commit
5cedca1b69
118 changed files with 26947 additions and 1 deletions
881
src/cmd/troff/t6.c
Normal file
881
src/cmd/troff/t6.c
Normal file
|
|
@ -0,0 +1,881 @@
|
|||
/*
|
||||
* t6.c
|
||||
*
|
||||
* width functions, sizes and fonts
|
||||
*/
|
||||
|
||||
#include "tdef.h"
|
||||
#include "fns.h"
|
||||
#include "ext.h"
|
||||
|
||||
int fontlab[MAXFONTS+1];
|
||||
int cstab[MAXFONTS+1];
|
||||
int ccstab[MAXFONTS+1];
|
||||
int bdtab[MAXFONTS+1];
|
||||
int sbold = 0;
|
||||
|
||||
t_width(Tchar j)
|
||||
{
|
||||
int i, k;
|
||||
|
||||
if (iszbit(j))
|
||||
return 0;
|
||||
if (ismot(j)) {
|
||||
if (isvmot(j))
|
||||
return(0);
|
||||
k = absmot(j);
|
||||
if (isnmot(j))
|
||||
k = -k;
|
||||
return(k);
|
||||
}
|
||||
i = cbits(j);
|
||||
if (i < ' ') {
|
||||
if (i == '\b')
|
||||
return(-widthp);
|
||||
if (i == PRESC)
|
||||
i = eschar;
|
||||
else if (i == HX)
|
||||
return(0);
|
||||
}
|
||||
if (i == ohc)
|
||||
return(0);
|
||||
i = trtab[i];
|
||||
if (i < ' ')
|
||||
return(0);
|
||||
if (sfbits(j) == oldbits) {
|
||||
xfont = pfont;
|
||||
xpts = ppts;
|
||||
} else
|
||||
xbits(j, 0);
|
||||
if (i < nchnames + ALPHABET && 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
|
||||
*/
|
||||
void zapwcache(int s)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (s) {
|
||||
widcache[' '].fontpts = 0;
|
||||
return;
|
||||
}
|
||||
for (i=0; i<NWIDCACHE; i++)
|
||||
widcache[i].fontpts = 0;
|
||||
}
|
||||
|
||||
onfont(int n, int f) /* is char n on font f? */
|
||||
{
|
||||
int i;
|
||||
Font *fp = &fonts[f];
|
||||
Chwid *cp, *ep;
|
||||
char *np;
|
||||
|
||||
if (n < ALPHABET) {
|
||||
if (fp->wp[n].num == n) /* ascii at front */
|
||||
return n;
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
cp = &fp->wp[ALPHABET];
|
||||
ep = &fp->wp[fp->nchars];
|
||||
for ( ; cp < ep; cp++) /* search others */
|
||||
if (cp->num == n)
|
||||
return cp - &fp->wp[0];
|
||||
/* maybe it was a \N... */
|
||||
np = chname(n);
|
||||
if (*np == Number) {
|
||||
i = atoi(np+1); /* sscanf(np+1, "%d", &i); */
|
||||
cp = &fp->wp[0];
|
||||
ep = &fp->wp[fp->nchars];
|
||||
for ( ; cp < ep; cp++) { /* search others */
|
||||
if (cp->code == i)
|
||||
return cp - &fp->wp[0];
|
||||
}
|
||||
return -2; /* a \N that doesn't have an entry */
|
||||
}
|
||||
return -1; /* vanilla not found */
|
||||
}
|
||||
|
||||
getcw(int i)
|
||||
{
|
||||
int k, n, x;
|
||||
Font *fp;
|
||||
int nocache = 0;
|
||||
if (i < ' ')
|
||||
return 0;
|
||||
bd = 0;
|
||||
fp = &fonts[xfont];
|
||||
if (i == ' ') { /* a blank */
|
||||
k = (fp->spacewidth * spacesz + 6) / 12;
|
||||
/* this nonsense because .ss cmd uses 1/36 em as its units */
|
||||
/* and default is 12 */
|
||||
} else if ((n = onfont(i, xfont)) >= 0) { /* on this font at n */
|
||||
k = fp->wp[n].wid;
|
||||
if (setwdf)
|
||||
numtabp[CT].val |= fp->wp[n].kern;
|
||||
} else if (n == -2) { /* \N with default width */
|
||||
|
||||
k = fp->defaultwidth;
|
||||
} else { /* not on current font */
|
||||
nocache = 1;
|
||||
k = fp->defaultwidth; /* default-size space */
|
||||
if (smnt) {
|
||||
int ii, jj;
|
||||
for (ii=smnt, jj=0; jj < nfonts; jj++, ii=ii % nfonts + 1) {
|
||||
if ((n = onfont(i, ii)) >= 0) {
|
||||
k = fonts[ii].wp[n].wid;
|
||||
if (xfont == sbold)
|
||||
bd = bdtab[ii];
|
||||
if (setwdf)
|
||||
numtabp[CT].val |= fonts[ii].wp[n].kern;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
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;
|
||||
}
|
||||
/* was (k & BYTEMASK); since .wid is unsigned, should never happen */
|
||||
if (k < 0)
|
||||
ERROR "can't happen: negative width %d in getcw %d\n", k, i WARN;
|
||||
k = (k * 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.
|
||||
*/
|
||||
}
|
||||
|
||||
void xbits(Tchar i, int bitf)
|
||||
{
|
||||
int k;
|
||||
|
||||
if(TROFF) {
|
||||
xfont = fbits(i);
|
||||
k = sbits(i);
|
||||
if(k) {
|
||||
xpts = pstab[k-1];
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* these next two functions ought to be the same in troff and nroff, */
|
||||
/* but the data structures they search are different. */
|
||||
/* silly historical problem. */
|
||||
|
||||
|
||||
Tchar t_setch(int c)
|
||||
{
|
||||
int j;
|
||||
char temp[50];
|
||||
char *s;
|
||||
|
||||
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';
|
||||
#ifdef UNICODE
|
||||
return chadd(temp, Troffchar, Install) | chbits; /* add name even if haven't seen it */
|
||||
#else
|
||||
if (NROFF) {
|
||||
j = chadd(temp, Troffchar, Lookup);
|
||||
if ( j == -1)
|
||||
return 0;
|
||||
else
|
||||
return j | chbits;
|
||||
} else
|
||||
return chadd(temp, Troffchar, Install) | chbits; /* add name even if haven't seen it */
|
||||
|
||||
#endif /*UNICODE*/
|
||||
}
|
||||
|
||||
Tchar t_setabs(void) /* set absolute char from \N'...' */
|
||||
{
|
||||
int n;
|
||||
char temp[10];
|
||||
|
||||
getch(); /* delim */
|
||||
n = 0;
|
||||
n = inumb(&n);
|
||||
getch(); /* delim */
|
||||
if (nonumb)
|
||||
return 0;
|
||||
sprintf(temp, "%d", n); /* convert into "#n" */
|
||||
n = chadd(temp, Number, Install);
|
||||
return n | chbits;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* fontlab[] is a cache that contains font information
|
||||
* for each font.
|
||||
* fontlab[] contains the 1- or 2-character name of the
|
||||
* font current associated with that font.
|
||||
* fonts 1..nfonts correspond to the mounted fonts;
|
||||
* the last of these are the special fonts.
|
||||
* If we don't use the (named) font in one of the
|
||||
* standard positions, we install the name in the next
|
||||
* free slot of fontlab[] and font[].
|
||||
* Whenever we need info about the font, we
|
||||
* read in the data into the next free slot with getfont.
|
||||
* The ptfont() (t10.c) routine will tell
|
||||
* the device filter to put the font always at position
|
||||
* zero if xfont > nfonts, so no need to change these filters.
|
||||
* Yes, this is a bit kludgy.
|
||||
*
|
||||
* This gives the new specs of findft:
|
||||
* find the font name i, where i also can be a number.
|
||||
* Installs the font(name) i when not present
|
||||
* returns -1 on error
|
||||
*/
|
||||
|
||||
|
||||
t_findft(int i)
|
||||
{
|
||||
int k;
|
||||
Uchar *p;
|
||||
|
||||
p = unpair(i);
|
||||
|
||||
if (isdigit(p[0])) { /* first look for numbers */
|
||||
k = p[0] - '0';
|
||||
if (p[1] > 0 && isdigit(p[1]))
|
||||
k = 10 * k + p[1] - '0';
|
||||
if (k > 0 && k <= nfonts && k < smnt)
|
||||
return(k); /* mounted font: .ft 3 */
|
||||
if (fontlab[k] && k <= MAXFONTS) { /* translate */
|
||||
return(k); /*number to a name */
|
||||
} else {
|
||||
fprintf(stderr, "troff: no font at position %d\n", k);
|
||||
return(-1); /* wild number */
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Now we look for font names
|
||||
*/
|
||||
for (k = 1; fontlab[k] != i; k++) {
|
||||
if (k > MAXFONTS)
|
||||
return(-1); /* running out of fontlab space */
|
||||
if (fontlab[k] == 0) { /* passed all existing names */
|
||||
if (setfp(k, i, (char *) 0, 1) == -1)
|
||||
return(-1);
|
||||
else {
|
||||
fontlab[k] = i; /* install the name */
|
||||
return(k);
|
||||
}
|
||||
}
|
||||
}
|
||||
return(k); /* was one of the existing names */
|
||||
}
|
||||
|
||||
|
||||
void caseps(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (TROFF) {
|
||||
if(skip())
|
||||
i = apts1;
|
||||
else {
|
||||
noscale++;
|
||||
i = inumb(&apts); /* this is a disaster for fractional point sizes */
|
||||
noscale = 0;
|
||||
if(nonumb)
|
||||
i = apts1;
|
||||
}
|
||||
casps1(i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void casps1(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(int i)
|
||||
{
|
||||
int j, k;
|
||||
|
||||
for (j=k=0 ; pstab[j] != 0 ; j++)
|
||||
if (abs(pstab[j]-i) < abs(pstab[k]-i))
|
||||
k = j;
|
||||
|
||||
return(pstab[k]);
|
||||
}
|
||||
|
||||
|
||||
void t_mchbits(void)
|
||||
{
|
||||
int 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);
|
||||
}
|
||||
|
||||
void t_setps(void)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
i = cbits(getch());
|
||||
if (isdigit(i)) { /* \sd or \sdd */
|
||||
i -= '0';
|
||||
if (i == 0) /* \s0 */
|
||||
j = apts1;
|
||||
else if (i <= 3 && (ch=getch()) && isdigit(j = cbits(ch))) { /* \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 t_setht(void) /* 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);
|
||||
setfbits(c, pts); /* sneaky, CHARHT font bits are size bits */
|
||||
return(c);
|
||||
}
|
||||
|
||||
Tchar t_setslant(void) /* 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);
|
||||
}
|
||||
|
||||
|
||||
void caseft(void)
|
||||
{
|
||||
if (!TROFF) {
|
||||
n_caseft();
|
||||
return;
|
||||
}
|
||||
skip();
|
||||
setfont(1);
|
||||
}
|
||||
|
||||
|
||||
void t_setfont(int a)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
if (a)
|
||||
i = getrq();
|
||||
else
|
||||
i = getsn();
|
||||
if (!i || i == 'P') {
|
||||
j = font1;
|
||||
goto s0;
|
||||
}
|
||||
if (/* i == 'S' || */ i == '0') /* an experiment -- why can't we change to it? */
|
||||
return;
|
||||
if ((j = findft(i)) == -1)
|
||||
if ((j = setfp(0, i, (char*) 0, 1)) == -1) /* try to put it in position 0 */
|
||||
return;
|
||||
s0:
|
||||
font1 = font;
|
||||
font = j;
|
||||
mchbits();
|
||||
}
|
||||
|
||||
|
||||
void t_setwd(void)
|
||||
{
|
||||
int base, wid;
|
||||
Tchar i;
|
||||
int delim, emsz, k;
|
||||
int savhp, savapts, savapts1, savfont, savfont1, savpts, savpts1;
|
||||
|
||||
base = numtabp[ST].val = numtabp[SB].val = wid = numtabp[CT].val = 0;
|
||||
if (ismot(i = getch()))
|
||||
return;
|
||||
delim = cbits(i);
|
||||
savhp = numtabp[HP].val;
|
||||
numtabp[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;
|
||||
numtabp[HP].val += k;
|
||||
if (!ismot(i)) {
|
||||
emsz = (INCH/72) * xpts;
|
||||
} else if (isvmot(i)) {
|
||||
k = absmot(i);
|
||||
if (isnmot(i))
|
||||
k = -k;
|
||||
base -= k;
|
||||
emsz = 0;
|
||||
} else
|
||||
continue;
|
||||
if (base < numtabp[SB].val)
|
||||
numtabp[SB].val = base;
|
||||
if ((k = base + emsz) > numtabp[ST].val)
|
||||
numtabp[ST].val = k;
|
||||
}
|
||||
setn1(wid, 0, (Tchar) 0);
|
||||
numtabp[HP].val = savhp;
|
||||
apts = savapts;
|
||||
apts1 = savapts1;
|
||||
font = savfont;
|
||||
font1 = savfont1;
|
||||
pts = savpts;
|
||||
pts1 = savpts1;
|
||||
mchbits();
|
||||
setwdf = 0;
|
||||
}
|
||||
|
||||
|
||||
Tchar t_vmot(void)
|
||||
{
|
||||
dfact = lss;
|
||||
vflag++;
|
||||
return t_mot();
|
||||
}
|
||||
|
||||
|
||||
Tchar t_hmot(void)
|
||||
{
|
||||
dfact = EM;
|
||||
return t_mot();
|
||||
}
|
||||
|
||||
|
||||
Tchar t_mot(void)
|
||||
{
|
||||
int j, n;
|
||||
Tchar i;
|
||||
|
||||
j = HOR;
|
||||
getch(); /*eat delim*/
|
||||
if (n = atoi0()) {
|
||||
if (vflag)
|
||||
j = VERT;
|
||||
i = makem(quant(n, j));
|
||||
} else
|
||||
i = 0;
|
||||
getch();
|
||||
vflag = 0;
|
||||
dfact = 1;
|
||||
return(i);
|
||||
}
|
||||
|
||||
|
||||
Tchar t_sethl(int k)
|
||||
{
|
||||
int 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 t_makem(int i)
|
||||
{
|
||||
Tchar j;
|
||||
|
||||
if (i >= 0)
|
||||
j = i;
|
||||
else
|
||||
j = -i;
|
||||
if (Hor > 1 && !vflag)
|
||||
j = (j + Hor/2)/Hor * Hor;
|
||||
j |= MOT;
|
||||
if (i < 0)
|
||||
j |= NMOT;
|
||||
if (vflag)
|
||||
j |= VMOT;
|
||||
return(j);
|
||||
}
|
||||
|
||||
|
||||
Tchar getlg(Tchar i)
|
||||
{
|
||||
Tchar j, k;
|
||||
int lf;
|
||||
|
||||
if (!TROFF)
|
||||
return i;
|
||||
if ((lf = fonts[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);
|
||||
}
|
||||
|
||||
|
||||
void caselg(void)
|
||||
{
|
||||
|
||||
if(TROFF) {
|
||||
skip();
|
||||
lg = atoi0();
|
||||
if (nonumb)
|
||||
lg = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void casefp(void)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
if (!TROFF) {
|
||||
n_casefp();
|
||||
return;
|
||||
}
|
||||
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)
|
||||
ERROR "fp: bad font position %d", i WARN;
|
||||
else if (skip() || !(j = getrq()))
|
||||
ERROR "fp: no font name" WARN;
|
||||
else if (skip() || !getname())
|
||||
setfp(i, j, (char*) 0, 1);
|
||||
else /* 3rd argument = filename */
|
||||
setfp(i, j, nextf, 1);
|
||||
}
|
||||
|
||||
char *strdupl(const char *s) /* make a copy of s */
|
||||
{
|
||||
char *t;
|
||||
|
||||
t = (char *) malloc(strlen(s) + 1);
|
||||
if (t == NULL)
|
||||
ERROR "out of space in strdupl(%s)", s FATAL;
|
||||
strcpy(t, s);
|
||||
return t;
|
||||
}
|
||||
|
||||
setfp(int pos, int f, char *truename, int print) /* mount font f at position pos[0...nfonts] */
|
||||
{
|
||||
char pathname[NS], shortname[NS], *sl;
|
||||
|
||||
zapwcache(0);
|
||||
if (truename)
|
||||
strcpy(shortname, truename);
|
||||
else
|
||||
strcpy(shortname, (char *) unpair(f));
|
||||
if (truename && strrchr(truename, '/')) { /* .fp 1 R dir/file: use verbatim */
|
||||
sprintf(pathname, "%s", truename);
|
||||
if (fonts[pos].truename)
|
||||
free(fonts[pos].truename);
|
||||
fonts[pos].truename = strdupl(truename);
|
||||
} else if (truename) { /* synonym: .fp 1 R Avant */
|
||||
sprintf(pathname, "%s/dev%s/%s", fontdir, devname, truename);
|
||||
truename = 0; /* so doesn't get repeated by ptfpcmd */
|
||||
} else /* vanilla: .fp 5 XX */
|
||||
sprintf(pathname, "%s/dev%s/%s", fontdir, devname, shortname);
|
||||
if (truename == 0 && fonts[pos].truename != 0) {
|
||||
free(fonts[pos].truename);
|
||||
fonts[pos].truename = 0;
|
||||
}
|
||||
if (getfont(pathname, pos) < 0) {
|
||||
ERROR "Can't open font file %s", pathname WARN;
|
||||
return -1;
|
||||
}
|
||||
if (print && !ascii) {
|
||||
ptfpcmd(pos, fonts[pos].longname, truename);
|
||||
ptfont();
|
||||
}
|
||||
if (pos == smnt) {
|
||||
smnt = 0;
|
||||
sbold = 0;
|
||||
}
|
||||
fontlab[pos] = f;
|
||||
if (smnt == 0 && fonts[pos].specfont)
|
||||
smnt = pos;
|
||||
bdtab[pos] = cstab[pos] = ccstab[pos] = 0;
|
||||
return pos;
|
||||
}
|
||||
|
||||
/*
|
||||
* .cs request; don't check legality of optional arguments
|
||||
*/
|
||||
void casecs(void)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
if (TROFF) {
|
||||
int savtr = trace;
|
||||
|
||||
trace = 0;
|
||||
noscale++;
|
||||
skip();
|
||||
if (!(i = getrq()) || (i = findft(i)) < 0)
|
||||
goto rtn;
|
||||
skip();
|
||||
cstab[i] = atoi0();
|
||||
skip();
|
||||
j = atoi0();
|
||||
if(nonumb)
|
||||
ccstab[i] = 0;
|
||||
else
|
||||
ccstab[i] = findps(j);
|
||||
rtn:
|
||||
zapwcache(0);
|
||||
noscale = 0;
|
||||
trace = savtr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void casebd(void)
|
||||
{
|
||||
int i, j, k;
|
||||
|
||||
if (!TROFF) {
|
||||
n_casebd();
|
||||
return;
|
||||
}
|
||||
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] = atoi0();
|
||||
noscale = 0;
|
||||
}
|
||||
|
||||
|
||||
void casevs(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!TROFF) {
|
||||
n_casevs();
|
||||
return;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
void casess(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(TROFF) {
|
||||
noscale++;
|
||||
skip();
|
||||
if(i = atoi0()) {
|
||||
spacesz = i & 0177;
|
||||
zapwcache(0);
|
||||
sps = width(' ' | chbits);
|
||||
}
|
||||
noscale = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Tchar t_xlss(void)
|
||||
{
|
||||
/* 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(atoi0(), VERT);
|
||||
dfact = 1;
|
||||
getch();
|
||||
if (i >= 0)
|
||||
*pbp++ = MOT | VMOT | i;
|
||||
else
|
||||
*pbp++ = MOT | VMOT | NMOT | -i;
|
||||
return(HX);
|
||||
}
|
||||
|
||||
Uchar *unpair(int i)
|
||||
{
|
||||
static Uchar name[3];
|
||||
|
||||
name[0] = i & SHORTMASK;
|
||||
name[1] = (i >> SHORT) & SHORTMASK;
|
||||
name[2] = 0;
|
||||
return name;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue