mirror of
https://github.com/9fans/plan9port.git
synced 2025-01-15 11:20:03 +00:00
889 lines
15 KiB
C
889 lines
15 KiB
C
/*
|
|
* 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;
|
|
|
|
int
|
|
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;
|
|
}
|
|
|
|
int
|
|
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 */
|
|
}
|
|
|
|
int
|
|
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;
|
|
|
|
j = 0;
|
|
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
|
|
*/
|
|
|
|
int
|
|
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();
|
|
}
|
|
|
|
int
|
|
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;
|
|
|
|
j = 0;
|
|
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;
|
|
}
|
|
|
|
int
|
|
setfp(int pos, int f, char *truename, int print) /* mount font f at position pos[0...nfonts] */
|
|
{
|
|
char pathname[NS], shortname[NS], *sl;
|
|
|
|
sl = (char*)0;
|
|
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;
|
|
|
|
j=0;
|
|
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;
|
|
}
|