![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tbl.cpio CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / tbl|
Return to tbl.cpio CVS log | Up to [Research Unix] / researchv10no / cmd / tbl |
researchv10 Norman
0707070035051115131006640000030000040000011503200474064415100000500000003372t..c /* t..c : external declarations */
# include "stdio.h"
# include "ctype.h"
# define MAXLIN 250
# define MAXHEAD 44
# define MAXCOL 30
/* Do NOT make MAXCOL bigger with adjusting nregs[] in tr.c */
# define MAXCHS 2000
#define MAXLINLEN 300
# define MAXRPT 100
# define CLLEN 10
# define SHORTLINE 4
extern int nlin, ncol, iline, nclin, nslin;
extern int (*style)[MAXHEAD];
extern char (*font)[MAXHEAD][2];
extern char (*csize)[MAXHEAD][4];
extern char (*vsize)[MAXHEAD][4];
extern char (*cll)[CLLEN];
extern int (*flags)[MAXHEAD];
# define ZEROW 001
# define HALFUP 002
# define CTOP 004
# define CDOWN 010
extern int stynum[];
extern int qcol;
extern int *doubled, *acase, *topat;
extern int F1, F2;
extern int (*lefline)[MAXHEAD];
extern int fullbot[];
extern char *instead[];
extern int expflg;
extern int ctrflg;
extern int evenflg;
extern int *evenup;
extern int boxflg;
extern int dboxflg;
extern int linsize;
extern int tab;
extern int pr1403;
extern int linsize, delim1, delim2;
extern int allflg;
extern int textflg;
extern int left1flg;
extern int rightl;
struct colstr {char *col, *rcol;};
extern struct colstr *table[];
extern char *cspace, *cstore;
extern char *exstore, *exlim, *exspace;
extern int *sep;
extern int *used, *lused, *rused;
extern int linestop[];
extern int leftover;
extern char *last, *ifile;
extern int texname;
extern int texct, texmax;
extern char texstr[];
extern int linstart;
extern FILE *tabin, *tabout;
# define CRIGHT 2
# define CLEFT 0
# define CMID 1
# define S1 31
# define S2 32
# define S3 33
# define TMP 38
#define S9 39
# define SF 35
# define SL 34
# define LSIZE 33
# define SIND 37
# define SVS 36
/* this refers to the relative position of lines */
# define LEFT 1
# define RIGHT 2
# define THRU 3
# define TOP 1
# define BOT 2
0707070035051115121006640000030000040000010245650265271262100000500000001755t0.c /* t0.c: storage allocation */
#
# include "t..c"
int expflg = 0;
int ctrflg = 0;
int boxflg = 0;
int dboxflg = 0;
int tab = '\t';
int linsize;
int pr1403;
int delim1, delim2;
int evenflg;
int *evenup;
int F1 = 0;
int F2 = 0;
int allflg = 0;
int leftover = 0;
int textflg = 0;
int left1flg = 0;
int rightl = 0;
char *cstore, *cspace;
char *last;
struct colstr *table[MAXLIN];
int stynum[MAXLIN+1];
int fullbot[MAXLIN];
char *instead[MAXLIN];
int linestop[MAXLIN];
int (*style)[MAXHEAD];
char (*font)[MAXHEAD][2];
char (*csize)[MAXHEAD][4];
char (*vsize)[MAXHEAD][4];
int (*lefline)[MAXHEAD];
char (*cll)[CLLEN];
int (*flags)[MAXHEAD];
int qcol;
int *doubled, *acase, *topat;
int nslin, nclin;
int *sep;
int *used, *lused, *rused;
int nlin, ncol;
int iline = 1;
char *ifile = "Input";
int texname = 'a';
int texct = 0;
char texstr[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYXZ0123456789";
int linstart;
char *exstore, *exlim, *exspace;
FILE *tabin /*= stdin */;
FILE *tabout /* = stdout */;
0707070035051115001006640000510000040000011516610474064427500000500000003744t1.c /* t1.c: main control and input switching */
#
# include "t..c"
#include <signal.h>
# ifdef gcos
/* required by GCOS because file is passed to "tbl" by troff preprocessor */
# define _f1 _f
extern FILE *_f[];
# endif
# ifdef unix
# define MACROS "/usr/lib/tmac.s"
# define PYMACS "/usr/lib/tmac.m"
# endif
# ifdef gcos
# define MACROS "cc/troff/smac"
# define PYMACS "cc/troff/mmac"
# endif
# define ever (;;)
main(argc,argv)
char *argv[];
{
# ifdef unix
int badsig();
signal(SIGPIPE, badsig);
# endif
# ifdef gcos
if(!intss()) tabout = fopen("qq", "w"); /* default media code is type 5 */
# endif
exit(tbl(argc,argv));
}
tbl(argc,argv)
char *argv[];
{
char line[5120];
/*int x;*/
/*x=malloc((char *)0); uncomment when allocation breaks*/
/* required by GCOS because "stdout" is set by troff preprocessor */
tabin=stdin; tabout=stdout;
setinp(argc,argv);
while (gets1(line, sizeof(line)))
{
fprintf(tabout, "%s\n",line);
if (prefix(".TS", line))
tableput();
}
fclose(tabin);
return(0);
}
int sargc;
char **sargv;
setinp(argc,argv)
char **argv;
{
sargc = argc;
sargv = argv;
sargc--; sargv++;
if (sargc>0)
swapin();
}
swapin()
{
char *name;
while (sargc>0 && **sargv=='-')
{
if (match("-ms", *sargv))
{
*sargv = MACROS;
break;
}
if (match("-mm", *sargv))
{
*sargv = PYMACS;
break;
}
if (match("-TX", *sargv))
pr1403=1;
if (match("-", *sargv))
break;
sargc--; sargv++;
}
if (sargc<=0) return(0);
# ifdef unix
/* file closing is done by GCOS troff preprocessor */
if (tabin!=stdin) fclose(tabin);
# endif
if (match(*sargv, "-")){
tabin=stdin;
name = "-";
}
else{
tabin = fopen(ifile= *sargv, "r");
name = ifile;
}
iline=1;
# ifdef unix
/* file names are all put into f. by the GCOS troff preprocessor */
fprintf(tabout, ".ds f. %s\n",ifile);
fprintf(tabout, ".lf %d %s\n",iline, name);
# endif
if (tabin==NULL)
error("Can't open file");
sargc--;
sargv++;
return(1);
}
# ifdef unix
badsig()
{
signal(SIGPIPE, 1);
exit(0);
}
# endif
0707070035051115101006640000030000040000010245670373132574500000500000000420t2.c /* t2.c: subroutine sequencing for one table */
# include "t..c"
tableput()
{
saveline();
savefill();
ifdivert();
cleanfc();
getcomm();
getspec();
gettbl();
getstop();
checkuse();
choochar();
maktab();
runout();
release();
rstofill();
endoff();
freearr();
restline();
}
0707070035051112121006640000030000040000011516630474064445400000500000003265t3.c /* t3.c: interpret commands affecting whole table */
# include "t..c"
struct optstr {char *optnam; int *optadd;} options [] = {
"expand", &expflg,
"EXPAND", &expflg,
"center", &ctrflg,
"CENTER", &ctrflg,
"box", &boxflg,
"BOX", &boxflg,
"allbox", &allflg,
"ALLBOX", &allflg,
"doublebox", &dboxflg,
"DOUBLEBOX", &dboxflg,
"frame", &boxflg,
"FRAME", &boxflg,
"doubleframe", &dboxflg,
"DOUBLEFRAME", &dboxflg,
"tab", &tab,
"TAB", &tab,
"linesize", &linsize,
"LINESIZE", &linsize,
"delim", &delim1,
"DELIM", &delim1,
0,0};
getcomm()
{
char line[200], *cp, nb[25], *t;
struct optstr *lp;
int c, ci, found;
for(lp= options; lp->optnam; lp++)
*(lp->optadd) = 0;
texname = texstr[texct=0];
tab = '\t';
printf(".nr %d \\n(.s\n", LSIZE);
gets1(line, sizeof(line));
/* see if this is a command line */
if (strchr(line,';') == NULL)
{
backrest(line);
return;
}
for(cp=line; (c = *cp) != ';'; cp++)
{
if (!letter(c)) continue;
found=0;
for(lp= options; lp->optadd; lp++)
{
if (prefix(lp->optnam, cp))
{
*(lp->optadd) = 1;
cp += strlen(lp->optnam);
if (letter(*cp))
error("Misspelled global option");
while (*cp==' ')cp++;
t=nb;
if ( *cp == '(')
while ((ci= *++cp) != ')')
*t++ = ci;
else cp--;
*t++ = 0; *t=0;
if (lp->optadd == &tab)
{
if (nb[0])
*(lp->optadd) = nb[0];
}
if (lp->optadd == &linsize)
printf(".nr %d %s\n", LSIZE, nb);
if (lp->optadd == &delim1)
{
delim1 = nb[0];
delim2 = nb[1];
}
found=1;
break;
}
}
if (!found)
error("Illegal option");
}
cp++;
backrest(cp);
return;
}
backrest(cp)
char *cp;
{
char *s;
for(s=cp; *s; s++);
un1getc('\n');
while (s>cp)
un1getc(*--s);
return;
}
0707070035050264701006640000510000010000011371440455733744100000500000017000t4.c /* t4.c: read table specification */
# include "t..c"
int oncol;
getspec()
{
int icol, i;
qcol = findcol()+1;/* must allow one extra for line at right */
garray(qcol);
sep[-1]= -1;
for(icol=0; icol<qcol; icol++)
{
sep[icol]= -1;
evenup[icol]=0;
cll[icol][0]=0;
for(i=0; i<MAXHEAD; i++)
{
csize[icol][i][0]=0;
vsize[icol][i][0]=0;
font[icol][i][0] = lefline[icol][i] = 0;
flags[icol][i]=0;
style[icol][i]= 'l';
}
}
for(i=0;i<MAXHEAD;i++)
lefline[qcol][i]=0; /* fixes sample55 looping */
nclin=ncol=0;
oncol =0;
left1flg=rightl=0;
readspec();
fprintf(tabout, ".rm");
for(i=0; i<ncol; i++)
fprintf(tabout, " %2s", reg(i, CRIGHT));
fprintf(tabout, "\n");
}
readspec()
{
int icol, c, sawchar, stopc, i;
char sn[10], *snp, *temp;
sawchar=icol=0;
while (c=get1char())
{
switch(c)
{
default:
if (c != tab)
error("bad table specification character");
case ' ': /* note this is also case tab */
continue;
case '\n':
if(sawchar==0) continue;
case ',':
case '.': /* end of table specification */
ncol = max(ncol, icol);
if (lefline[ncol][nclin]>0) {ncol++; rightl++;};
if(sawchar)
nclin++;
if (nclin>=MAXHEAD)
error("too many lines in specification");
icol=0;
if (ncol==0 || nclin==0)
error("no specification");
if (c== '.')
{
while ((c=get1char()) && c != '\n')
if (c != ' ' && c != '\t')
error("dot not last character on format line");
/* fix up sep - default is 3 except at edge */
for(icol=0; icol<ncol; icol++)
if (sep[icol]<0)
sep[icol] = icol+1<ncol ? 3 : 2;
if (oncol == 0)
oncol = ncol;
else if (oncol +2 <ncol)
error("tried to widen table in T&, not allowed");
return;
}
sawchar=0;
continue;
case 'C': case 'S': case 'R': case 'N': case 'L': case 'A':
c += ('a'-'A');
case '_': if (c=='_') c= '-';
case '=': case '-':
case '^':
case 'c': case 's': case 'n': case 'r': case 'l': case 'a':
style[icol][nclin]=c;
if (c== 's' && icol<=0)
error("first column can not be S-type");
if (c=='s' && style[icol-1][nclin] == 'a')
{
fprintf(tabout, ".tm warning: can't span a-type cols, changed to l\n");
style[icol-1][nclin] = 'l';
}
if (c=='s' && style[icol-1][nclin] == 'n')
{
fprintf(tabout, ".tm warning: can't span n-type cols, changed to c\n");
style[icol-1][nclin] = 'c';
}
icol++;
if (c=='^' && nclin<=0)
error("first row can not contain vertical span");
if (icol>qcol)
error("too many columns in table");
sawchar=1;
continue;
case 'b': case 'i':
c += 'A'-'a';
case 'B': case 'I':
if (icol==0) continue;
snp=font[icol-1][nclin];
snp[0]= (c=='I' ? '2' : '3');
snp[1]=0;
continue;
case 't': case 'T':
if (icol>0)
flags[icol-1][nclin] |= CTOP;
continue;
case 'd': case 'D':
if (icol>0)
flags[icol-1][nclin] |= CDOWN;
continue;
case 'f': case 'F':
if (icol==0) continue;
snp=font[icol-1][nclin];
snp[0]=snp[1]=stopc=0;
for(i=0; i<2; i++)
{
c = get1char();
if (i==0 && c=='(')
{
stopc=')';
c = get1char();
}
if (c==0) break;
if (c==stopc) {stopc=0; break;}
if (stopc==0) if (c==' ' || c== tab ) break;
if (c=='\n' || c == '|'){un1getc(c); break;}
snp[i] = c;
if (c>= '0' && c<= '9') break;
}
if (stopc) if (get1char()!=stopc)
error("Nonterminated font name");
continue;
case 'P': case 'p':
if (icol<=0) continue;
temp = snp = csize[icol-1][nclin];
while (c = get1char())
{
if (c== ' ' || c== tab || c=='\n') break;
if (c=='-' || c == '+')
if (snp>temp)
break;
else
*snp++=c;
else
if (digit(c))
*snp++ = c;
else break;
if (snp-temp>4)
error("point size too large");
}
*snp = 0;
if (atoi(temp)>36)
error("point size unreasonable");
un1getc (c);
continue;
case 'V': case 'v':
if (icol<=0) continue;
temp = snp = vsize[icol-1][nclin];
while (c = get1char())
{
if (c== ' ' || c== tab || c=='\n') break;
if (c=='-' || c == '+')
if (snp>temp)
break;
else
*snp++=c;
else
if (digit(c))
*snp++ = c;
else break;
if (snp-temp>4)
error("vertical spacing value too large");
}
*snp=0;
un1getc(c);
continue;
case 'w': case 'W':
snp = cll [icol-1];
/* Dale Smith didn't like this check - possible to have two text blocks
of different widths now ....
if (*snp)
{
fprintf(tabout, "Ignored second width specification");
continue;
}
/* end commented out code ... */
stopc=0;
while (c = get1char())
{
if (snp==cll[icol-1] && c=='(')
{
stopc = ')';
continue;
}
if ( !stopc && (c>'9' || c< '0'))
break;
if (stopc && c== stopc)
break;
*snp++ =c;
}
*snp=0;
if (snp-cll[icol-1]>CLLEN)
error ("column width too long");
if (!stopc)
un1getc(c);
continue;
case 'e': case 'E':
if (icol<1) continue;
evenup[icol-1]=1;
evenflg=1;
continue;
case 'z': case 'Z': /* zero width-ignre width this item */
if (icol<1) continue;
flags[icol-1][nclin] |= ZEROW;
continue;
case 'u': case 'U': /* half line up */
if (icol<1) continue;
flags[icol-1][nclin] |= HALFUP;
continue;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
sn[0] = c;
snp=sn+1;
while (digit(*snp++ = c = get1char()))
;
un1getc(c);
sep[icol-1] = max(sep[icol-1], numb(sn));
continue;
case '|':
lefline[icol][nclin]++;
if (icol==0) left1flg=1;
continue;
}
}
error("EOF reading table specification");
}
findcol()
{
# define FLNLIM 200
/* this counts the number of columns and then puts the line back*/
char *s, line[FLNLIM+2], *p;
int c, n=0, inpar=0;
while ((c=get1char())!=EOF && c == ' ')
;
if (c!='\n')
un1getc(c);
for(s=line; *s = c = get1char(); s++)
{
if (c==')') inpar=0;
if (inpar) continue;
if (c=='\n' || c == EOF || c == '.' || c==',')
break;
else if (c=='(')
inpar=1;
else
if (s>=line+FLNLIM)
error("too long spec line");
}
for(p=line; p<s; p++)
switch (c= *p)
{
case 'l': case 'r': case 'c': case 'n': case 'a': case 's':
case 'L': case 'R': case 'C': case 'N': case 'A': case 'S':
case '-': case '=': case '_':
n++;
}
while (p>=line)
un1getc(*p--);
return(n);
}
garray(qcol)
{
char * getcore();
style = (int (*)[]) getcore(MAXHEAD*qcol, sizeof(int));
evenup = (int *) getcore(qcol, sizeof(int));
lefline = (int (*)[]) getcore(MAXHEAD*(qcol+1), sizeof (int)); /*+1 for sample55 loop - others may need it too*/
font = (char (*)[][2]) getcore(MAXHEAD*qcol, 2);
csize = (char (*)[MAXHEAD][4]) getcore(MAXHEAD*qcol, 4);
vsize = (char (*)[MAXHEAD][4]) getcore(MAXHEAD*qcol, 4);
flags = (int (*)[]) getcore(MAXHEAD*qcol, sizeof(int));
cll = (char (*)[])getcore(qcol, CLLEN);
sep = (int *) getcore(qcol+1, sizeof(int));
sep++; /* sep[-1] must be legal */
used = (int *) getcore(qcol+1, sizeof(int));
lused = (int *) getcore(qcol+1, sizeof(int));
rused = (int *) getcore(qcol+1, sizeof(int));
doubled = (int *) getcore(qcol+1, sizeof(int));
acase = (int *) getcore(qcol+1, sizeof(int));
topat = (int *) getcore(qcol+1, sizeof(int));
}
char *
getcore(a,b)
{
char *x, *calloc();
x = calloc(a,b);
if (x==0)
error("Couldn't get memory");
return(x);
}
freearr()
{
cfree(style);
cfree(evenup);
cfree(lefline);
cfree(flags);
cfree(font);
cfree(csize);
cfree(vsize);
cfree(cll);
cfree(--sep); /* netnews says this should be --sep because incremented earlier! */
cfree(used);
cfree(lused);
cfree(rused);
cfree(doubled);
cfree(acase);
cfree(topat);
}
0707070035051112061006640000510000040000010207410474064464000000500000006556t5.c /* t5.c: read data for table */
# include "t..c"
gettbl()
{
extern char *chspace();
extern char *maknew();
int icol, ch;
cstore=cspace= chspace();
textflg=0;
for (nlin=nslin=0; gets1(cstore, MAXCHS - (cstore-cspace)); nlin++)
{
stynum[nlin]=nslin;
if (prefix(".TE", cstore))
{
leftover=0;
break;
}
if (prefix(".TC", cstore) || prefix(".T&", cstore))
{
readspec();
nslin++;
}
if (nlin>=MAXLIN)
{
leftover=(int)cstore;
break;
}
fullbot[nlin]=0;
if (cstore[0] == '.' && !isdigit(cstore[1]))
{
instead[nlin] = cstore;
while (*cstore++);
continue;
}
else instead[nlin] = 0;
if (nodata(nlin))
{
if (ch = oneh(nlin))
fullbot[nlin]= ch;
table[nlin] = (struct colstr *) alocv((ncol+2)*sizeof(table[0][0]));
for(icol=0;icol<ncol;icol++){
table[nlin][icol].rcol = "";
table[nlin][icol].col = "";
}
nlin++;
nslin++;
fullbot[nlin] = 0;
instead[nlin] = (char *) 0;
}
table[nlin] = (struct colstr *) alocv((ncol+2)*sizeof(table[0][0]));
if (cstore[1]==0)
switch(cstore[0])
{
case '_': fullbot[nlin]= '-'; continue;
case '=': fullbot[nlin]= '='; continue;
}
stynum[nlin] = nslin;
nslin = min(nslin+1, nclin-1);
for (icol = 0; icol <ncol; icol++)
{
table[nlin][icol].col = cstore;
table[nlin][icol].rcol=0;
ch=1;
if (match(cstore, "T{")){ /* text follows */
table[nlin][icol].col =
(char *)gettext(cstore, nlin, icol,
font[icol][stynum[nlin]],
csize[icol][stynum[nlin]]);
}
else
{
for(; (ch= *cstore) != '\0' && ch != tab; cstore++)
;
*cstore++ = '\0';
switch(ctype(nlin,icol)) /* numerical or alpha, subcol */
{
case 'n':
table[nlin][icol].rcol = maknew(table[nlin][icol].col);
break;
case 'a':
table[nlin][icol].rcol = table[nlin][icol].col;
table[nlin][icol].col = "";
break;
}
}
while (ctype(nlin,icol+1)== 's') /* spanning */
table[nlin][++icol].col = "";
if (ch == '\0') break;
}
while (++icol <ncol+2)
{
table[nlin][icol].col = "";
table [nlin][icol].rcol=0;
}
while (*cstore != '\0')
cstore++;
if (cstore-cspace + MAXLINLEN > MAXCHS)
cstore = cspace = chspace();
}
last = cstore;
permute();
if (textflg) untext();
return;
}
nodata(il)
{
int c;
for (c=0; c<ncol;c++)
{
switch(ctype(il,c))
{
case 'c': case 'n': case 'r': case 'l': case 's': case 'a':
return(0);
}
}
return(1);
}
oneh(lin)
{
int k, icol;
k = ctype(lin,0);
for(icol=1; icol<ncol; icol++)
{
if (k != ctype(lin,icol))
return(0);
}
return(k);
}
# define SPAN "\\^"
permute()
{
int irow, jcol, is;
char *start, *strig;
for(jcol=0; jcol<ncol; jcol++)
{
for(irow=1; irow<nlin; irow++)
{
if (vspand(irow,jcol,0))
{
is = prev(irow);
if (is<0)
error("Vertical spanning in first row not allowed");
start = table[is][jcol].col;
strig = table[is][jcol].rcol;
while (irow<nlin &&vspand(irow,jcol,0))
irow++;
table[--irow][jcol].col = start;
table[irow][jcol].rcol = strig;
while (is<irow)
{
table[is][jcol].rcol =0;
table[is][jcol].col= SPAN;
is = next(is);
}
}
}
}
}
vspand(ir,ij,ifform)
{
if (ir<0) return(0);
if (ir>=nlin)return(0);
if (instead[ir]) return(0);
if (ifform==0 && ctype(ir,ij)=='^') return(1);
if (table[ir][ij].rcol!=0) return(0);
if (fullbot[ir]) return(0);
return(vspen(table[ir][ij].col));
}
vspen(s)
char *s;
{
if (s==0) return(0);
if (!point(s)) return(0);
return(match(s, SPAN));
}
0707070035051112041006640000030000040000010245600265271264300000500000014652t6.c /* t6.c: compute tab stops */
# define tx(a) (a>0 && a<128)
# include "t..c"
maktab()
{
# define FN(i,c) font[c][stynum[i]]
# define SZ(i,c) csize[c][stynum[i]]
/* define the tab stops of the table */
int icol, ilin, tsep, k, ik, vforml, il, text;
char *s;
for(icol=0; icol <ncol; icol++)
{
doubled[icol] = acase[icol] = 0;
fprintf(tabout, ".nr %2s 0\n", reg(icol,CRIGHT));
for(text=0; text<2; text++)
{
if (text)
fprintf(tabout, ".%2s\n.rm %2s\n", reg(icol, CRIGHT), reg(icol, CRIGHT));
for(ilin=0; ilin<nlin; ilin++)
{
if (instead[ilin]|| fullbot[ilin]) continue;
vforml=ilin;
for(il=prev(ilin); il>=0 && vspen(table[il][icol].col); il=prev(il))
vforml=il;
if (fspan(vforml,icol)) continue;
if (filler(table[ilin][icol].col)) continue;
if ((flags[icol][stynum[ilin]] & ZEROW) != 0) continue;
switch(ctype(vforml,icol))
{
case 'a':
acase[icol]=1;
s = table[ilin][icol].col;
if ((int)s>0 && (int)s<128 && text)
{
if (doubled[icol]==0)
fprintf(tabout, ".nr %d 0\n.nr %d 0\n",S1,S2);
doubled[icol]=1;
fprintf(tabout, ".if \\n(%c->\\n(%d .nr %d \\n(%c-\n",s,S2,S2,s);
}
case 'n':
if (table[ilin][icol].rcol!=0)
{
if (doubled[icol]==0 && text==0)
fprintf(tabout, ".nr %d 0\n.nr %d 0\n", S1, S2);
doubled[icol]=1;
if (real(s=table[ilin][icol].col) && !vspen(s))
{
if (tx((int)s) != text) continue;
fprintf(tabout, ".nr %d ", TMP);
wide(s, FN(vforml,icol), SZ(vforml,icol)); fprintf(tabout, "\n");
fprintf(tabout, ".if \\n(%d<\\n(%d .nr %d \\n(%d\n", S1, TMP, S1, TMP);
}
if (text==0 && real(s=table[ilin][icol].rcol) && !vspen(s) && !barent(s))
{
fprintf(tabout, ".nr %d \\w%c%s%c\n",TMP, F1, s, F1);
fprintf(tabout, ".if \\n(%d<\\n(%d .nr %d \\n(%d\n",S2,TMP,S2,TMP);
}
continue;
}
case 'r':
case 'c':
case 'l':
if (real(s=table[ilin][icol].col) && !vspen(s))
{
if (tx((int)s) != text) continue;
fprintf(tabout, ".nr %d ", TMP);
wide(s, FN(vforml,icol), SZ(vforml,icol)); fprintf(tabout, "\n");
fprintf(tabout, ".if \\n(%2s<\\n(%d .nr %2s \\n(%d\n", reg(icol,CRIGHT), TMP, reg(icol,CRIGHT), TMP);
}
}
}
}
if (acase[icol])
{
fprintf(tabout, ".if \\n(%d>=\\n(%2s .nr %2s \\n(%du+2n\n",S2,reg(icol,CRIGHT),reg(icol,CRIGHT),S2);
}
if (doubled[icol])
{
fprintf(tabout, ".nr %2s \\n(%d\n", reg(icol,CMID), S1);
fprintf(tabout, ".nr %d \\n(%2s+\\n(%d\n",TMP,reg(icol,CMID),S2);
fprintf(tabout, ".if \\n(%d>\\n(%2s .nr %2s \\n(%d\n",TMP,reg(icol,CRIGHT),reg(icol,CRIGHT),TMP);
fprintf(tabout, ".if \\n(%d<\\n(%2s .nr %2s +(\\n(%2s-\\n(%d)/2\n",TMP,reg(icol,CRIGHT),reg(icol,CMID),reg(icol,CRIGHT),TMP);
}
if (cll[icol][0])
{
fprintf(tabout, ".nr %d %sn\n", TMP, cll[icol]);
fprintf(tabout, ".if \\n(%2s<\\n(%d .nr %2s \\n(%d\n",reg(icol,CRIGHT), TMP, reg(icol,CRIGHT), TMP);
}
for(ilin=0; ilin<nlin; ilin++)
if (k=lspan(ilin, icol))
{
s=table[ilin][icol-k].col;
if (!real(s) || barent(s) || vspen(s) ) continue;
fprintf(tabout, ".nr %d ", TMP);
wide(table[ilin][icol-k].col, FN(ilin,icol-k), SZ(ilin,icol-k));
for(ik=k; ik>=0; ik--)
{
fprintf(tabout, "-\\n(%2s",reg(icol-ik,CRIGHT));
if (!expflg && ik>0) fprintf(tabout, "-%dn", sep[icol-ik]);
}
fprintf(tabout, "\n");
fprintf(tabout, ".if \\n(%d>0 .nr %d \\n(%d/%d\n", TMP, TMP, TMP, k);
fprintf(tabout, ".if \\n(%d<0 .nr %d 0\n", TMP, TMP);
for(ik=1; ik<=k; ik++)
{
if (doubled[icol-k+ik])
fprintf(tabout, ".nr %2s +\\n(%d/2\n", reg(icol-k+ik,CMID), TMP);
fprintf(tabout, ".nr %2s +\\n(%d\n", reg(icol-k+ik,CRIGHT), TMP);
}
}
}
if (textflg) untext();
/* if even requested, make all columns widest width */
# define TMP1 S1
# define TMP2 S2
if (evenflg)
{
fprintf(tabout, ".nr %d 0\n", TMP);
for(icol=0; icol<ncol; icol++)
{
if (evenup[icol]==0) continue;
fprintf(tabout, ".if \\n(%2s>\\n(%d .nr %d \\n(%2s\n",
reg(icol,CRIGHT), TMP, TMP, reg(icol,CRIGHT));
}
for(icol=0; icol<ncol; icol++)
{
if (evenup[icol]==0)
/* if column not evened just retain old interval */
continue;
if (doubled[icol])
fprintf(tabout, ".nr %2s (100*\\n(%2s/\\n(%2s)*\\n(%d/100\n",
reg(icol,CMID), reg(icol,CMID), reg(icol,CRIGHT), TMP);
/* that nonsense with the 100's and parens tries
to avoid overflow while proportionally shifting
the middle of the number */
fprintf(tabout, ".nr %2s \\n(%d\n", reg(icol,CRIGHT), TMP);
}
}
/* now adjust for total table width */
for(tsep=icol=0; icol<ncol; icol++)
tsep+= sep[icol];
if (expflg)
{
fprintf(tabout, ".nr %d 0", TMP);
for(icol=0; icol<ncol; icol++)
fprintf(tabout, "+\\n(%2s", reg(icol,CRIGHT));
fprintf(tabout, "\n");
fprintf(tabout, ".nr %d \\n(.l-\\n(%d\n", TMP, TMP);
if (boxflg || dboxflg || allflg)
/* tsep += 1; */ ;
else
tsep -= sep[ncol-1];
fprintf(tabout, ".nr %d \\n(%d/%d\n", TMP, TMP, tsep);
fprintf(tabout, ".if \\n(%d<0 .nr %d 0\n", TMP, TMP);
}
else
fprintf(tabout, ".nr %d 1n\n", TMP);
fprintf(tabout, ".nr %2s 0\n",reg(-1, CRIGHT));
tsep= (boxflg || allflg || dboxflg || left1flg) ? 2 : 0;
if (sep[-1] >= 0) tsep = sep[-1];
for(icol=0; icol<ncol; icol++)
{
fprintf(tabout, ".nr %2s \\n(%2s+((%d*\\n(%d)/2)\n",reg(icol,CLEFT), reg(icol-1,CRIGHT), tsep, TMP);
fprintf(tabout, ".nr %2s +\\n(%2s\n",reg(icol,CRIGHT), reg(icol,CLEFT));
if (doubled[icol])
{
/* the next line is last-ditch effort to avoid zero field width */
/*fprintf(tabout, ".if \\n(%2s=0 .nr %2s 1\n",reg(icol,CMID), reg(icol,CMID));*/
fprintf(tabout, ".nr %2s +\\n(%2s\n", reg(icol,CMID), reg(icol,CLEFT));
/* fprintf(tabout, ".if n .if \\n(%s%%24>0 .nr %s +12u\n",reg(icol,CMID), reg(icol,CMID)); */
}
tsep=sep[icol]*2;
}
if (rightl)
fprintf(tabout, ".nr %s (\\n(%s+\\n(%s)/2\n",reg(ncol-1, CRIGHT), reg(ncol-1,CLEFT), reg(ncol-2,CRIGHT));
fprintf(tabout, ".nr TW \\n(%2s\n", reg(ncol-1, CRIGHT));
tsep = sep[ncol-1];
if (boxflg || allflg || dboxflg)
fprintf(tabout, ".nr TW +((%d*\\n(%d)/2)\n", tsep, TMP);
fprintf(tabout,
".if t .if (\\n(TW+\\n(.o)>7.65i .tm Table at line %d file %s is too wide - \\n(TW units\n", iline-1, ifile);
return;
}
wide(s, fn, size)
char *s, *size, *fn;
{
if (point(s))
{
fprintf(tabout, "\\w%c", F1);
if (*fn>0) putfont(fn);
if (*size) putsize(size);
fprintf(tabout, "%s", s);
if (*fn>0) putfont("P");
if (*size) putsize("0");
fprintf(tabout, "%c",F1);
}
else
fprintf(tabout, "\\n(%c-", s);
}
filler(s)
char *s;
{
return (point(s) && s[0]=='\\' && s[1] == 'R');
}
0707070035051115071006640000030000040000010245700265271264300000500000006174t7.c /* t7.c: control to write table entries */
# include "t..c"
# define realsplit ((ct=='a'||ct=='n') && table[ldata][c].rcol)
runout()
{
int i;
if (boxflg || allflg || dboxflg) need();
if (ctrflg)
{
fprintf(tabout, ".nr #I \\n(.i\n");
fprintf(tabout, ".in +(\\n(.lu-\\n(TWu-\\n(.iu)/2u\n");
}
fprintf(tabout, ".fc %c %c\n", F1, F2);
fprintf(tabout, ".nr #T 0-1\n");
deftail();
for(i=0; i<nlin; i++)
putline(i,i);
if (leftover)
yetmore();
fprintf(tabout, ".fc\n");
fprintf(tabout, ".nr T. 1\n");
fprintf(tabout, ".T# 1\n");
if (ctrflg)
fprintf(tabout, ".in \\n(#Iu\n");
}
runtabs(lform, ldata)
{
int c, ct, vforml, lf;
fprintf(tabout, ".ta ");
for(c=0; c<ncol; c++)
{
vforml=lform;
for(lf=prev(lform); lf>=0 && vspen(table[lf][c].col); lf=prev(lf))
vforml=lf;
if (fspan(vforml,c))
continue;
switch(ct=ctype(vforml,c))
{
case 'n':
case 'a':
if (table[ldata][c].rcol)
if (lused[c]) /*Zero field width*/
fprintf(tabout, "\\n(%2su ",reg(c,CMID));
case 'c':
case 'l':
case 'r':
if (realsplit? rused[c]: (used[c]+lused[c]))
fprintf(tabout, "\\n(%2su ",reg(c,CRIGHT));
continue;
case 's':
if (lspan(lform, c))
fprintf(tabout, "\\n(%2su ", reg(c,CRIGHT));
continue;
}
}
fprintf(tabout, "\n");
}
ifline(s)
char *s;
{
if (!point(s)) return(0);
if (s[0] == '\\') s++;
if (s[1] ) return(0);
if (s[0] == '_') return('-');
if (s[0] == '=') return('=');
return(0);
}
need()
{
int texlin, horlin, i;
for(texlin=horlin=i=0; i<nlin; i++)
{
if (fullbot[i]!=0)
horlin++;
else
if (instead[i]!=0)
continue;
else
texlin++;
}
fprintf(tabout, ".ne %dv+%dp\n",texlin,2*horlin);
}
deftail()
{
int i, c, lf, lwid;
for(i=0; i<MAXHEAD; i++)
if (linestop[i])
fprintf(tabout, ".nr #%c 0-1\n", linestop[i]+'a'-1);
fprintf(tabout, ".nr #a 0-1\n");
fprintf(tabout, ".eo\n");
fprintf(tabout, ".de T#\n");
fprintf(tabout, ".nr 35 1m\n");
fprintf(tabout, ".ds #d .d\n");
fprintf(tabout, ".if \\(ts\\n(.z\\(ts\\(ts .ds #d nl\n");
fprintf(tabout, ".mk ##\n");
fprintf(tabout, ".nr ## -1v\n");
fprintf(tabout, ".ls 1\n");
for(i=0; i<MAXHEAD; i++)
if (linestop[i])
fprintf(tabout, ".if \\n(#T>=0 .nr #%c \\n(#T\n",linestop[i]+'a'-1);
if (boxflg || allflg || dboxflg) /* bottom of table line */
if (fullbot[nlin-1]==0)
{
if (!pr1403)
fprintf(tabout, ".if \\n(T. .vs \\n(.vu-\\n(.sp\n");
fprintf(tabout, ".if \\n(T. ");
drawline(nlin,0,ncol, dboxflg ? '=' : '-',1,0);
fprintf(tabout, "\n.if \\n(T. .vs\n");
/* T. is really an argument to a macro but because of
eqn we don't dare pass it as an argument and reference by $1 */
}
for(c=0; c<ncol; c++)
{
if ((lf=left(nlin-1,c, &lwid))>=0)
{
fprintf(tabout, ".if \\n(#%c>=0 .sp -1\n",linestop[lf]+'a'-1);
fprintf(tabout, ".if \\n(#%c>=0 ", linestop[lf]+'a'-1);
tohcol(c);
drawvert(lf, nlin-1, c, lwid);
fprintf(tabout, "\\h'|\\n(TWu'\n");
}
}
if (boxflg || allflg || dboxflg) /* right hand line */
{
fprintf(tabout, ".if \\n(#a>=0 .sp -1\n");
fprintf(tabout, ".if \\n(#a>=0 \\h'|\\n(TWu'");
drawvert (0, nlin-1, ncol, dboxflg? 2 : 1);
fprintf(tabout, "\n");
}
fprintf(tabout, ".ls\n");
fprintf(tabout, "..\n");
fprintf(tabout, ".ec\n");
}
0707070035051115061006660000030000040000010245710406576507100000500000017553t8.c /* t8.c: write out one line of output table */
# include "t..c"
# define realsplit ((ct=='a'||ct=='n') && table[nl][c].rcol)
int watchout;
int once;
putline(i, nl)
/* i is line number for deciding format */
/* nl is line number for finding data usually identical */
{
int c, lf, ct, form, lwid, vspf, ip, cmidx, exvspen, vforml;
int vct, chfont, uphalf;
char *s, *size, *fn;
cmidx=watchout=vspf=exvspen=0;
if (i==0) once=0;
if (i==0 && ( allflg || boxflg || dboxflg))
fullwide(0, dboxflg? '=' : '-');
if (instead[nl]==0 && fullbot[nl] ==0)
for(c=0; c<ncol; c++)
{
s = table[nl][c].col;
if (s==0) continue;
if (vspen(s))
{
for(ip=nl; ip<nlin; ip=next(ip))
if (!vspen(s=table[ip][c].col)) break;
if ((int)s>0 && (int)s<128)
fprintf(tabout, ".ne \\n(%c|u+\\n(.Vu\n",s);
continue;
}
if (point(s)) continue;
fprintf(tabout, ".ne \\n(%c|u+\\n(.Vu\n",s);
watchout=1;
}
if (linestop[nl])
fprintf(tabout, ".mk #%c\n", linestop[nl]+'a'-1);
lf = prev(nl);
if (instead[nl])
{
puts(instead[nl]);
return;
}
if (fullbot[nl])
{
switch (ct=fullbot[nl])
{
case '=':
case '-':
fullwide(nl,ct);
}
return;
}
for(c=0; c<ncol; c++)
{
if (instead[nl]==0 && fullbot[nl]==0)
if (vspen(table[nl][c].col)) vspf=1;
if (lf>=0)
if (vspen(table[lf][c].col)) vspf=1;
}
if (vspf)
{
fprintf(tabout, ".nr #^ \\n(\\*(#du\n");
fprintf(tabout, ".nr #- \\n(#^\n"); /* current line position relative to bottom */
}
vspf=0;
chfont=0;
for(c=0; c<ncol; c++)
{
s = table[nl][c].col;
if (s==0) continue;
chfont |= (int)(font[c][stynum[nl]]);
if (point(s) ) continue;
lf=prev(nl);
if (lf>=0 && vspen(table[lf][c].col))
fprintf(tabout, ".if (\\n(%c|+\\n(^%c-1v)>\\n(#- .nr #- +(\\n(%c|+\\n(^%c-\\n(#--1v)\n",s,'a'+c,s,'a'+c);
else
fprintf(tabout, ".if (\\n(%c|+\\n(#^-1v)>\\n(#- .nr #- +(\\n(%c|+\\n(#^-\\n(#--1v)\n",s,s);
}
if (allflg && once>0 )
fullwide(i,'-');
once=1;
runtabs(i, nl);
if (allh(i) && !pr1403)
{
fprintf(tabout, ".nr %d \\n(.v\n", SVS);
fprintf(tabout, ".vs \\n(.vu-\\n(.sp\n");
fprintf(tabout, ".nr 35 \\n(.vu\n");
}
else
fprintf(tabout, ".nr 35 1m\n");
if (chfont)
fprintf(tabout, ".nr %2d \\n(.f\n", S1);
fprintf(tabout, "\\&");
vct = 0;
for(c=0; c<ncol; c++)
{
uphalf=0;
if (watchout==0 && i+1<nlin && (lf=left(i,c, &lwid))>=0)
{
tohcol(c);
drawvert(lf, i, c, lwid);
vct += 2;
}
if (rightl && c+1==ncol) continue;
vforml=i;
for(lf=prev(nl); lf>=0 && vspen(table[lf][c].col); lf=prev(lf))
vforml= lf;
form= ctype(vforml,c);
if (form != 's')
{
ct = reg(c,CLEFT);
if (form=='a') ct = reg(c,CMID);
if (form=='n' && table[nl][c].rcol && lused[c]==0) ct= reg(c,CMID);
fprintf(tabout, "\\h'|\\n(%2su'", ct);
}
s= table[nl][c].col;
fn = font[c][stynum[vforml]];
size = csize[c][stynum[vforml]];
if (*size==0)size=0;
if ((flags[c][stynum[nl]] & HALFUP)!=0 && pr1403 == 0)
uphalf=1;
switch(ct=ctype(vforml, c))
{
case 'n':
case 'a':
if (table[nl][c].rcol)
{
if (lused[c]) /*Zero field width*/
{
ip = prev(nl);
if (ip>=0)
if (vspen(table[ip][c].col))
{
if (exvspen==0)
{
fprintf(tabout, "\\v'-(\\n(\\*(#du-\\n(^%cu", c+'a');
if (cmidx)
fprintf(tabout, "-((\\n(#-u-\\n(^%cu)/2u)", c+'a');
vct++;
if (pr1403) /* must round to whole lines */
fprintf(tabout, "/1v*1v");
fprintf(tabout, "'");
exvspen=1;
}
}
fprintf(tabout, "%c%c",F1,F2);
if (uphalf) fprintf(tabout, "\\u");
puttext(s,fn,size);
if (uphalf) fprintf(tabout, "\\d");
fprintf(tabout, "%c",F1);
}
s= table[nl][c].rcol;
form=1;
break;
}
case 'c':
form=3; break;
case 'r':
form=2; break;
case 'l':
form=1; break;
case '-':
case '=':
if (real(table[nl][c].col))
fprintf(stderr,"%s: line %d: Data ignored on table line %d\n", ifile, iline-1, i+1);
makeline(i,c,ct);
continue;
default:
continue;
}
if (realsplit ? rused[c]: used[c]) /*Zero field width*/
{
/* form: 1 left, 2 right, 3 center adjust */
if (ifline(s))
{
makeline(i,c,ifline(s));
continue;
}
if (filler(s))
{
fprintf(tabout, "\\l'|\\n(%2su\\&%s'", reg(c,CRIGHT), s+2);
continue;
}
ip = prev(nl);
cmidx = (flags[c][stynum[nl]] & (CTOP|CDOWN))==0;
if (ip>=0)
if (vspen(table[ip][c].col))
{
if (exvspen==0)
{
fprintf(tabout, "\\v'-(\\n(\\*(#du-\\n(^%cu", c+'a');
if (cmidx)
fprintf(tabout, "-((\\n(#-u-\\n(^%cu)/2u)", c+'a');
vct++;
if (pr1403) /* round to whole lines */
fprintf(tabout, "/1v*1v");
fprintf(tabout, "'");
}
}
fprintf(tabout, "%c", F1);
if (form!= 1)
fprintf(tabout, "%c", F2);
if (vspen(s))
vspf=1;
else
{
if (uphalf) fprintf(tabout, "\\u");
puttext(s, fn, size);
if (uphalf) fprintf(tabout, "\\d");
}
if (form !=2)
fprintf(tabout, "%c", F2);
fprintf(tabout, "%c", F1);
}
ip = prev(nl);
if (ip>=0)
if (vspen(table[ip][c].col))
{
exvspen = (c+1 < ncol) && vspen(table[ip][c+1].col) &&
(topat[c] == topat[c+1]) &&
(cmidx == (flags[c+1] [stynum[nl]]&(CTOP|CDOWN)==0)) && (left(i,c+1,&lwid)<0);
if (exvspen==0)
{
fprintf(tabout, "\\v'(\\n(\\*(#du-\\n(^%cu", c+'a');
if (cmidx)
fprintf(tabout, "-((\\n(#-u-\\n(^%cu)/2u)", c+'a');
vct++;
if (pr1403) /* round to whole lines */
fprintf(tabout, "/1v*1v");
fprintf(tabout, "'");
}
}
else
exvspen=0;
/* if lines need to be split for gcos here is the place for a backslash */
if (vct > 7 && c < ncol)
{
fprintf(tabout, "\n.sp-1\n\\&");
vct=0;
}
}
fprintf(tabout, "\n");
if (allh(i) && !pr1403) fprintf(tabout, ".vs \\n(%du\n", SVS);
if (watchout)
funnies(i,nl);
if (vspf)
{
for(c=0; c<ncol; c++)
if (vspen(table[nl][c].col) && (nl==0 || (lf=prev(nl))<0 || !vspen(table[lf][c].col)))
{
fprintf(tabout, ".nr ^%c \\n(#^u\n", 'a'+c);
topat[c]=nl;
}
}
}
puttext(s,fn, size)
char *s, *size, *fn;
{
if (point(s))
{
putfont(fn);
putsize(size);
fprintf(tabout, "%s",s);
if (*fn>0) fprintf(tabout, "\\f\\n(%2d", S1);
if (size!=0) putsize("0");
}
}
funnies( stl, lin)
{
/* write out funny diverted things */
int c, s, pl, lwid, dv, lf, ct;
char *fn;
fprintf(tabout, ".mk ##\n"); /* rmember current vertical position */
fprintf(tabout, ".nr %d \\n(##\n", S1); /* bottom position */
for(c=0; c<ncol; c++)
{
s = (int)table[lin][c].col;
if (point(s)) continue;
if (s==0) continue;
fprintf(tabout, ".sp |\\n(##u-1v\n");
fprintf(tabout, ".nr %d ", SIND);
for(pl=stl; pl>=0 && !isalpha(ct=ctype(pl,c)); pl=prev(pl))
;
switch (ct)
{
case 'n':
case 'c':
fprintf(tabout, "(\\n(%2su+\\n(%2su-\\n(%c-u)/2u\n",reg(c,CLEFT),reg(c-1+ctspan(lin,c),CRIGHT), s);
break;
case 'l':
fprintf(tabout, "\\n(%2su\n",reg(c,CLEFT));
break;
case 'a':
fprintf(tabout, "\\n(%2su\n",reg(c,CMID));
break;
case 'r':
fprintf(tabout, "\\n(%2su-\\n(%c-u\n", reg(c,CRIGHT), s);
break;
}
fprintf(tabout, ".in +\\n(%du\n", SIND);
fn=font[c][stynum[stl]];
putfont(fn);
pl = prev(stl);
if (stl>0 && pl>=0 && vspen(table[pl][c].col))
{
fprintf(tabout, ".sp |\\n(^%cu\n", 'a'+c);
if ((flags[c][stynum[stl]]&(CTOP|CDOWN))==0)
{
fprintf(tabout, ".nr %d \\n(#-u-\\n(^%c-\\n(%c|+1v\n",TMP, 'a'+c, s);
fprintf(tabout, ".if \\n(%d>0 .sp \\n(%du/2u", TMP, TMP);
if (pr1403) /* round */
fprintf(tabout, "/1v*1v");
fprintf(tabout, "\n");
}
}
fprintf(tabout, ".%c+\n",s);
fprintf(tabout, ".in -\\n(%du\n", SIND);
if (*fn>0) putfont("P");
fprintf(tabout, ".mk %d\n", S2);
fprintf(tabout, ".if \\n(%d>\\n(%d .nr %d \\n(%d\n", S2, S1, S1, S2);
}
fprintf(tabout, ".sp |\\n(%du\n", S1);
for(c=dv=0; c<ncol; c++)
{
if (stl+1< nlin && (lf=left(stl,c,&lwid))>=0)
{
if (dv++ == 0)
fprintf(tabout, ".sp -1\n");
tohcol(c);
dv++;
drawvert(lf, stl, c, lwid);
}
}
if (dv)
fprintf(tabout,"\n");
}
putfont(fn)
char *fn;
{
if (fn && *fn)
fprintf(tabout, fn[1] ? "\\f(%.2s" : "\\f%.2s", fn);
}
putsize(s)
char *s;
{
if (s && *s)
fprintf(tabout, "\\s%s",s);
}
0707070035051115051006640000030000040000010207610474064475300000500000002656t9.c /* t9.c: write lines for tables over 200 lines */
# include "t..c"
static useln;
extern char *maknew();
yetmore()
{
for(useln=0; useln<MAXLIN && table[useln]==0; useln++);
if (useln>=MAXLIN)
error("Wierd. No data in table.");
table[0]=table[useln];
for(useln=nlin-1; useln>=0 && (fullbot[useln] || instead[useln]); useln--);
if (useln<0)
error("Wierd. No real lines in table.");
domore(leftover);
while (gets1(cstore=cspace, MAXCHS) && domore(cstore))
;
last =cstore;
return;
}
domore(dataln)
char *dataln;
{
int icol, ch;
if (prefix(".TE", dataln))
return(0);
if (dataln[0] == '.' && !isdigit(dataln[1]))
{
puts(dataln);
return(1);
}
fullbot[0]=0;
instead[0]=(char *)0;
if (dataln[1]==0)
switch(dataln[0])
{
case '_': fullbot[0]= '-'; putline(useln,0); return(1);
case '=': fullbot[0]= '='; putline(useln, 0); return(1);
}
for (icol = 0; icol <ncol; icol++)
{
table[0][icol].col = dataln;
table[0][icol].rcol=0;
for(; (ch= *dataln) != '\0' && ch != tab; dataln++)
;
*dataln++ = '\0';
switch(ctype(useln,icol))
{
case 'n':
table[0][icol].rcol = maknew(table[0][icol].col);
break;
case 'a':
table[0][icol].rcol = table[0][icol].col;
table[0][icol].col= "";
break;
}
while (ctype(useln,icol+1)== 's') /* spanning */
table[0][++icol].col = "";
if (ch == '\0') break;
}
while (++icol <ncol)
table[0][icol].col = "";
putline(useln,0);
exstore=exspace; /* reuse space for numerical items */
return(1);
}
0707070035051115041006640000030000040000010207630474064504300000500000003071tb.c /* tb.c: check which entries exist, also storage allocation */
# include "t..c"
checkuse()
{
int i,c, k;
for(c=0; c<ncol; c++)
{
used[c]=lused[c]=rused[c]=0;
for(i=0; i<nlin; i++)
{
if (instead[i] || fullbot[i]) continue;
k = ctype(i,c);
if (k== '-' || k == '=') continue;
if ((k=='n'||k=='a'))
{
rused[c]|= real(table[i][c].rcol);
if( !real(table[i][c].rcol))
used[c] |= real(table[i][c].col);
if (table[i][c].rcol)
lused[c] |= real(table[i][c].col);
}
else
used[c] |= real(table[i][c].col);
}
}
}
real(s)
char *s;
{
if (s==0) return(0);
if (!point(s)) return(1);
if (*s==0) return(0);
return(1);
}
int spcount = 0;
extern char * calloc();
# define MAXVEC 20
char *spvecs[MAXVEC];
char *chspace()
{
char *pp;
if (spvecs[spcount])
return(spvecs[spcount++]);
if (spcount>=MAXVEC)
error("Too many characters in table");
spvecs[spcount++]= pp = calloc(MAXCHS+MAXLINLEN,1);
if (pp== (char *)-1 || pp == (char *)0)
error("no space for characters");
return(pp);
}
# define MAXPC 50
char *thisvec;
int tpcount = -1;
char *tpvecs[MAXPC];
int *alocv(n)
int n;
{
int *tp, *q;
if (tpcount<0 || thisvec+n > tpvecs[tpcount]+MAXCHS)
{
tpcount++;
if (tpvecs[tpcount]==0)
{
tpvecs[tpcount] = calloc(MAXCHS,1);
}
thisvec = tpvecs[tpcount];
if (thisvec == (char *)0)
error("no space for vectors");
}
tp=(int *)thisvec;
thisvec+=n;
for(q=tp; q<(int *)thisvec; q++)
*q=0;
return(tp);
}
release()
{
/* give back unwanted space in some vectors */
/* this should call free; it does not because
alloc() is so buggy */
spcount=0;
tpcount= -1;
exstore=0;
}
0707070035051115031006640000030000040000010245750265271264600000500000002130tc.c /* tc.c: find character not in table to delimit fields */
# include "t..c"
choochar()
{
/* choose funny characters to delimit fields */
int had[128], ilin,icol, k;
char *s;
for(icol=0; icol<128; icol++)
had[icol]=0;
F1 = F2 = 0;
for(ilin=0;ilin<nlin;ilin++)
{
if (instead[ilin]) continue;
if (fullbot[ilin]) continue;
for(icol=0; icol<ncol; icol++)
{
k = ctype(ilin, icol);
if (k==0 || k == '-' || k == '=')
continue;
s = table[ilin][icol].col;
if (point(s))
while (*s)
had[*s++]=1;
s=table[ilin][icol].rcol;
if (point(s))
while (*s)
had[*s++]=1;
}
}
/* choose first funny character */
for(
s="\002\003\005\006\007!%&#/?,:;<=>@`^~_{}+-*ABCDEFGHIJKMNOPQRSTUVWXYZabcdefgjkoqrstwxyz";
*s; s++)
{
if (had[*s]==0)
{
F1= *s;
had[F1]=1;
break;
}
}
/* choose second funny character */
for(
s="\002\003\005\006\007:_~^`@;,<=>#%&!/?{}+-*ABCDEFGHIJKMNOPQRSTUVWXZabcdefgjkoqrstuwxyz";
*s; s++)
{
if (had[*s]==0)
{
F2= *s;
break;
}
}
if (F1==0 || F2==0)
error("couldn't find characters to use for delimiters");
return;
}
point(s)
{
return(s>= 128 || s<0);
}
0707070035051115021006640000030000040000011516550474434145100000500000002144te.c /* te.c: error message control, input line count */
# include "t..c"
error(s)
char *s;
{
fprintf(stderr, "\n%s: line %d: %s\n", ifile, iline, s);
# ifdef unix
fprintf(stderr, "tbl quits\n");
exit(1);
# endif
# ifdef gcos
fprintf(stderr, "run terminated due to error condition detected by tbl preprocessor\n");
exit(0);
# endif
}
char *gets1(s, size)
char *s;
int size;
{
char *p, *ns;
int nbl = 0;
iline++;
ns = s;
p=fgets(s,size,tabin);
while (p==0)
{
if (swapin()==0)
return(0);
p = fgets(s,size,tabin);
}
while (*s) s++;
s--;
if (*s == '\n') *s-- =0;
else error("input buffer too small");
for(nbl=0; *s == '\\' && s>p; s--)
nbl++;
if (linstart && nbl % 2) /* fold escaped nl if in table */
gets1(s+1, size - (s-ns));
return(p);
}
# define BACKMAX 500
char backup[BACKMAX];
char *backp = backup;
un1getc(c)
{
if (c=='\n')
iline--;
*backp++ = c;
if (backp >= backup+BACKMAX)
error("too much backup");
}
get1char()
{
int c;
if (backp>backup)
c = *--backp;
else
c=getc(tabin);
if (c== EOF) /* EOF */
{
if (swapin() ==0)
error("unexpected EOF");
c = getc(tabin);
}
if (c== '\n')
iline++;
return(c);
}
0707070035051115011006640000030000040000010245770446267321300000500000002207tf.c /* tf.c: save and restore fill mode around table */
# include "t..c"
savefill()
{
/* remembers various things: fill mode, vs, ps in mac 35 (SF) */
fprintf(tabout, ".de %d\n",SF);
fprintf(tabout, ".ps \\n(.s\n");
fprintf(tabout, ".vs \\n(.vu\n");
fprintf(tabout, ".in \\n(.iu\n");
fprintf(tabout, ".if \\n(.u .fi\n");
fprintf(tabout, ".if \\n(.j .ad\n");
fprintf(tabout, ".if \\n(.j=0 .na\n");
fprintf(tabout, "..\n");
fprintf(tabout, ".nf\n");
/* set obx offset if useful */
fprintf(tabout, ".nr #~ 0\n");
fprintf(tabout, ".if \\n(.T .if n .nr #~ 0.6n\n");
}
rstofill()
{
fprintf(tabout, ".%d\n",SF);
}
endoff()
{
int i;
for(i=0; i<MAXHEAD; i++)
if (linestop[i])
fprintf(tabout, ".nr #%c 0\n", linestop[i]+'a'-1);
for(i=0; i<texct; i++)
fprintf(tabout, ".rm %c+\n",texstr[i]);
fprintf(tabout, "%s\n", last);
}
ifdivert()
{
fprintf(tabout, ".ds #d .d\n");
fprintf(tabout, ".if \\(ts\\n(.z\\(ts\\(ts .ds #d nl\n");
}
saveline()
{
fprintf(tabout, ".if \\n+(b.=1 .nr d. \\n(.c-\\n(c.-1\n");
linstart=iline;
}
restline()
{
fprintf(tabout,".if \\n-(b.=0 .nr c. \\n(.c-\\n(d.-%d\n", iline-linstart);
linstart = 0;
}
cleanfc()
{
fprintf(tabout, ".fc\n");
}
0707070035051113651006640000510000040000010247370474434102600000500000003570tg.c /* tg.c: process included text blocks */
# include "t..c"
gettext(sp, ilin,icol, fn, sz)
char *sp, *fn, *sz;
{
/* get a section of text */
char line[4096];
int oname;
char *vs;
if (texname==0) error("Too many text block diversions");
if (textflg==0)
{
fprintf(tabout, ".nr %d \\n(.lu\n", SL); /* remember old line length */
textflg=1;
}
fprintf(tabout, ".eo\n");
fprintf(tabout, ".am %s\n", reg(icol,CRIGHT));
fprintf(tabout, ".br\n");
fprintf(tabout, ".di %c+\n", texname);
rstofill();
if (fn && *fn) fprintf(tabout, ".nr %d \\n(.f\n.ft %s\n", S1, fn);
fprintf(tabout, ".ft \\n(.f\n"); /* protect font */
vs = vsize[icol][stynum[ilin]];
if ((sz && *sz) || (vs && *vs))
{
fprintf(tabout, ".nr %d \\n(.v\n", S9);
if (vs==0 || *vs==0) vs= "\\n(.s+2";
if (sz && *sz)
fprintf(tabout, ".ps %s\n",sz);
fprintf(tabout, ".vs %s\n",vs);
fprintf(tabout, ".if \\n(%du>\\n(.vu .sp \\n(%du-\\n(.vu\n", S9,S9);
}
if (cll[icol][0])
fprintf(tabout, ".ll %sn\n", cll[icol]);
else
fprintf(tabout, ".ll \\n(%du*%du/%du\n",SL,ctspan(ilin,icol),ncol+1);
fprintf(tabout,".if \\n(.l<\\n(%2s .ll \\n(%2su\n", reg(icol,CRIGHT), reg(icol,CRIGHT));
if (ctype(ilin,icol)=='a')
fprintf(tabout, ".ll -2n\n");
fprintf(tabout, ".in 0\n");
while (gets1(line, sizeof(line)))
{
if (line[0]=='T' && line[1]=='}' && line[2]== tab) break;
if (match("T}", line)) break;
fprintf(tabout, "%s\n", line);
}
if (fn && *fn) fprintf(tabout, ".ft \\n(%d\n", S1);
if (sz && *sz) fprintf(tabout, ".br\n.ps\n.vs\n");
fprintf(tabout, ".br\n");
fprintf(tabout, ".di\n");
fprintf(tabout, ".nr %c| \\n(dn\n", texname);
fprintf(tabout, ".nr %c- \\n(dl\n", texname);
fprintf(tabout, "..\n");
fprintf(tabout, ".ec \\\n");
/* copy remainder of line */
if (line[2])
tcopy (sp, line+3);
else
*sp=0;
oname=texname;
texname = texstr[++texct];
return(oname);
}
untext()
{
rstofill();
fprintf(tabout, ".nf\n");
fprintf(tabout, ".ll \\n(%du\n", SL);
}
0707070035051114771006640000030000040000010246010265271266600000500000002004ti.c /* ti.c: classify line intersections */
# include "t..c"
/* determine local environment for intersections */
interv(i,c)
{
int ku, kl;
if (c>=ncol || c == 0)
{
if (dboxflg)
{
if (i==0) return(BOT);
if (i>=nlin) return(TOP);
return(THRU);
}
if (c>=ncol)
return(0);
}
ku = i>0 ? lefdata(i-1,c) : 0;
if (i+1 >= nlin && allh(i))
kl=0;
else
kl = lefdata(allh(i) ? i+1 : i, c);
if (ku==2 && kl==2) return(THRU);
if (ku ==2) return(TOP);
if (kl==BOT) return(2);
return(0);
}
interh(i,c)
{
int kl, kr;
if (fullbot[i]== '=' || (dboxflg && (i==0 || i>= nlin-1)))
{
if (c==ncol)
return(LEFT);
if (c==0)
return(RIGHT);
return(THRU);
}
if (i>=nlin) return(0);
kl = c>0 ? thish (i,c-1) : 0;
if (kl<=1 && i>0 && allh(up1(i)))
kl = c>0 ? thish(up1(i),c-1) : 0;
kr = thish(i,c);
if (kr<=1 && i>0 && allh(up1(i)))
kr = c>0 ? thish(up1(i), c) : 0;
if (kl== '=' && kr == '=') return(THRU);
if (kl== '=') return(LEFT);
if (kr== '=') return(RIGHT);
return(0);
}
up1(i)
{
i--;
while (instead[i] && i>0) i--;
return(i);
}
0707070035051114761006640000030000040000010246020265271266600000500000002123tm.c /* tm.c: split numerical fields */
# include "t..c"
char *maknew(str)
char *str;
{
/* make two numerical fields */
extern char *chspace();
int dpoint, c;
char *p, *q, *ba;
p = str;
for (ba= 0; c = *str; str++)
if (c == '\\' && *(str+1)== '&')
ba=str;
str=p;
if (ba==0)
{
for (dpoint=0; *str; str++)
{
if (*str=='.' && !ineqn(str,p) &&
(str>p && digit(*(str-1)) ||
digit(*(str+1))))
dpoint=(int)str;
}
if (dpoint==0)
for(; str>p; str--)
{
if (digit( * (str-1) ) && !ineqn(str, p))
break;
}
if (!dpoint && p==str) /* not numerical, don't split */
return(0);
if (dpoint) str=(char *)dpoint;
}
else
str = ba;
p =str;
if (exstore ==0 || exstore >exlim)
{
exstore = exspace = chspace();
exlim= exstore+MAXCHS;
}
q = exstore;
while (*exstore++ = *str++);
*p = 0;
return(q);
}
ineqn (s, p)
char *s, *p;
{
/* true if s is in a eqn within p */
int ineq = 0, c;
while (c = *p)
{
if (s == p)
return(ineq);
p++;
if ((ineq == 0) && (c == delim1))
ineq = 1;
else
if ((ineq == 1) && (c == delim2))
ineq = 0;
}
return(0);
}
0707070035051114751006640000030000040000010246030265271266700000500000001554tr.c # include "t..c"
/* tr.c: number register allocation */
char * nregs[] ={
/* this array must have at least 3*qcol entries
or illegal register names will result */
"40","41","42","43","44","45","46","47","48","49",
"50","51","52","53","54","55","56","57","58","59",
"60","61","62","63","64","65","66","67","68","69",
"70","71","72","73","74","75","76","77","78","79",
"80","81","82","83","84","85","86","87","88","89",
"90","91","92","93","94","95","96","97","4q","4r",
"4s","4t","4u","4v","4w","4x","4y","4z","4;","4.",
"4a","4b","4c","4d","4e","4f","4g","4h","4i","4j",
"4k","4l","4m","4n","4o","4p","5a","5b","5c","5d",
"5e","5f","5g","5h","5i","5j","5k","5l","5m","5n",
"5o","5p","5q","5r","5s","5t","5u","5v","5w","5x",
0};
char *
reg(col, place)
{
if(sizeof(nregs) < 2*3*qcol)
error("Too many columns for registers");
return (nregs[qcol*place+col]);
}
0707070035051114741006640000030000040000010246040265271266700000500000001243ts.c /* ts.c: minor string processing subroutines */
match (s1, s2)
char *s1, *s2;
{
while (*s1 == *s2)
if (*s1++ == '\0')
return(1);
else
s2++;
return(0);
}
prefix(small, big)
char *small, *big;
{
int c;
while ((c= *small++) == *big++)
if (c==0) return(1);
return(c==0);
}
letter (ch)
{
if (ch >= 'a' && ch <= 'z')
return(1);
if (ch >= 'A' && ch <= 'Z')
return(1);
return(0);
}
numb(str)
char *str;
{
/* convert to integer */
int k;
for (k=0; *str >= '0' && *str <= '9'; str++)
k = k*10 + *str - '0';
return(k);
}
digit(x)
{
return(x>= '0' && x<= '9');
}
max(a,b)
{
return( a>b ? a : b);
}
tcopy (s,t)
char *s, *t;
{
while (*s++ = *t++);
}
0707070035051114731006640000030000040000010246050265271267000000500000002651tt.c /* tt.c: subroutines for drawing horizontal lines */
# include "t..c"
ctype(il, ic)
{
if (instead[il])
return(0);
if (fullbot[il])
return(0);
il = stynum[il];
return(style[ic][il]);
}
min(a,b)
{
return(a<b ? a : b);
}
fspan(i,c)
{
c++;
return(c<ncol && ctype(i,c)=='s');
}
lspan(i,c)
{
int k;
if (ctype(i,c) != 's') return(0);
c++;
if (c < ncol && ctype(i,c)== 's')
return(0);
for(k=0; ctype(i,--c) == 's'; k++);
return(k);
}
ctspan(i,c)
{
int k;
c++;
for(k=1; c<ncol && ctype(i,c)=='s'; k++)
c++;
return(k);
}
tohcol(ic)
{
if (ic==0)
fprintf(tabout, "\\h'|0'");
else
fprintf(tabout, "\\h'(|\\n(%2su+|\\n(%2su)/2u'", reg(ic,CLEFT), reg(ic-1,CRIGHT));
}
allh(i)
{
/* return true if every element in line i is horizontal */
/* also at least one must be horizontl */
int c, one, k;
if (fullbot[i]) return(1);
if (i>=nlin) return(dboxflg||boxflg);
for(one=c=0; c<ncol; c++)
{
k = thish(i,c);
if (k==0) return(0);
if (k==1) continue;
one=1;
}
return(one);
}
thish(i,c)
{
int t;
char *s;
struct colstr *pc;
if (c<0)return(0);
if (i<0) return(0);
t = ctype(i,c);
if (t=='_' || t == '-')
return('-');
if (t=='=')return('=');
if (t=='^') return(1);
if (fullbot[i] )
return(fullbot[i]);
if (t=='s') return(thish(i,c-1));
if (t==0) return(1);
pc = &table[i][c];
s = (t=='a' ? pc->rcol : pc->col);
if (s==0 || (point(s) && *s==0))
return(1);
if (vspen(s)) return(1);
if (t=barent( s))
return(t);
return(0);
}
0707070035051114721006640000030000040000010246060265271267000000500000010000tu.c /* tu.c: draws horizontal lines */
# include "t..c"
makeline(i,c,lintype)
{
int cr, type, shortl;
type = thish(i,c);
if (type==0) return;
cr=c;
shortl = (table[i][c].col[0]=='\\');
if (c>0 && !shortl && thish(i,c-1) == type)return;
if (shortl==0)
for(cr=c; cr < ncol && (ctype(i,cr)=='s'||type==thish(i,cr)); cr++);
else
for(cr=c+1; cr<ncol && ctype(i,cr)=='s'; cr++);
drawline(i, c, cr-1, lintype, 0, shortl);
}
fullwide(i, lintype)
{
int cr, cl;
if (!pr1403)
fprintf(tabout, ".nr %d \\n(.v\n.vs \\n(.vu-\\n(.sp\n", SVS);
cr= 0;
while (cr<ncol)
{
cl=cr;
while (i>0 && vspand(prev(i),cl,1))
cl++;
for(cr=cl; cr<ncol; cr++)
if (i>0 && vspand(prev(i),cr,1))
break;
if (cl<ncol)
drawline(i,cl,(cr<ncol?cr-1:cr),lintype,1,0);
}
fprintf(tabout, "\n");
if (!pr1403)
fprintf(tabout, ".vs \\n(%du\n", SVS);
}
drawline(i, cl, cr, lintype, noheight, shortl)
{
char *exhr, *exhl, *lnch;
int lcount, ln, linpos, oldpos, nodata;
lcount=0;
exhr=exhl= "";
switch(lintype)
{
case '-': lcount=1;break;
case '=': lcount = pr1403? 1 : 2; break;
case SHORTLINE: lcount=1; break;
}
if (lcount<=0) return;
nodata = cr-cl>=ncol || noheight || allh(i);
if (!nodata)
fprintf(tabout, "\\v'-.5m'");
for(ln=oldpos=0; ln<lcount; ln++)
{
linpos = 2*ln - lcount +1;
if (linpos != oldpos)
fprintf(tabout, "\\v'%dp'", linpos-oldpos);
oldpos=linpos;
if (shortl==0)
{
tohcol(cl);
if (lcount>1)
{
switch(interv(i,cl))
{
case TOP: exhl = ln==0 ? "1p" : "-1p"; break;
case BOT: exhl = ln==1 ? "1p" : "-1p"; break;
case THRU: exhl = "1p"; break;
}
if (exhl[0])
fprintf(tabout, "\\h'%s'", exhl);
}
else if (lcount==1)
{
switch(interv(i,cl))
{
case TOP: case BOT: exhl = "-1p"; break;
case THRU: exhl = "1p"; break;
}
if (exhl[0])
fprintf(tabout, "\\h'%s'", exhl);
}
if (lcount>1)
{
switch(interv(i,cr+1))
{
case TOP: exhr = ln==0 ? "-1p" : "+1p"; break;
case BOT: exhr = ln==1 ? "-1p" : "+1p"; break;
case THRU: exhr = "-1p"; break;
}
}
else if (lcount==1)
{
switch(interv(i,cr+1))
{
case TOP: case BOT: exhr = "+1p"; break;
case THRU: exhr = "-1p"; break;
}
}
}
else
fprintf(tabout, "\\h'|\\n(%2su'", reg(cl,CLEFT));
fprintf(tabout, "\\s\\n(%d",LSIZE);
if (linsize)
fprintf(tabout, "\\v'-\\n(%dp/6u'", LSIZE);
if (shortl)
fprintf(tabout, "\\l'|\\n(%2su'", reg(cr,CRIGHT));
else
{
lnch = "\\(ul";
if (pr1403)
lnch = lintype==2 ? "=" : "\\(ru";
if (cr+1>=ncol)
fprintf(tabout, "\\l'|\\n(TWu%s%s'", exhr,lnch);
else
fprintf(tabout, "\\l'(|\\n(%2su+|\\n(%2su)/2u%s%s'", reg(cr,CRIGHT),
reg(cr+1,CLEFT), exhr, lnch);
}
if (linsize)
fprintf(tabout, "\\v'\\n(%dp/6u'", LSIZE);
fprintf(tabout, "\\s0");
}
if (oldpos!=0)
fprintf(tabout, "\\v'%dp'", -oldpos);
if (!nodata)
fprintf(tabout, "\\v'+.5m'");
}
getstop()
{
int i,c,k,junk, stopp;
stopp=1;
for(i=0; i<MAXLIN; i++)
linestop[i]=0;
for(i=0; i<nlin; i++)
for(c=0; c<ncol; c++)
{
k = left(i,c,&junk);
if (k>=0 && linestop[k]==0)
linestop[k]= ++stopp;
}
if (boxflg || allflg || dboxflg)
linestop[0]=1;
}
left(i,c, lwidp)
int *lwidp;
{
int kind, li, lj;
/* returns -1 if no line to left */
/* returns number of line where it starts */
/* stores into lwid the kind of line */
*lwidp=0;
if (i<0) return(-1);
kind = lefdata(i,c);
if (kind==0) return(-1);
if (i+1<nlin)
if (lefdata(next(i),c)== kind) return(-1);
while (i>=0 && lefdata(i,c)==kind)
i=prev(li=i);
if (prev(li)== -1) li=0;
*lwidp=kind;
for(lj= i+1; lj<li; lj++)
if (instead[lj] && strcmp(instead[lj], ".TH")==0)
return(li);
for(i= i+1; i<li; i++)
if (fullbot[i])
li=i;
return(li);
}
lefdata(i,c)
{
int ck;
if (i>=nlin) i=nlin-1;
if (ctype(i,c) == 's')
{
for(ck=c; ctype(i,ck)=='s'; ck--);
if (thish(i,ck)==0)
return(0);
}
i =stynum[i];
i = lefline[c][i];
if (i>0) return(i);
if (dboxflg && c==0) return(2);
if (allflg)return(1);
if (boxflg && c==0) return(1);
return(0);
}
next(i)
{
while (i+1 <nlin)
{
i++;
if (!fullbot[i] && !instead[i]) break;
}
return(i);
}
prev(i)
{
while (--i >=0 && (fullbot[i] || instead[i]))
;
return(i);
}
0707070035051114711006640000030000040000010246070265271267100000500000005512tv.c /* tv.c: draw vertical lines */
# include "t..c"
drawvert(start,end, c, lwid)
{
char *exb=0, *ext=0;
int tp=0, sl, ln, pos, epb, ept, vm;
end++;
vm='v';
/* note: nr 35 has value of 1m outside of linesize */
while (instead[end]) end++;
for(ln=0; ln<lwid; ln++)
{
epb=ept=0;
pos = 2*ln-lwid+1;
if (pos!=tp) fprintf(tabout, "\\h'%dp'", pos-tp);
tp = pos;
if (end<nlin)
{
if (fullbot[end]|| (!instead[end] && allh(end)))
epb=2;
else
switch (midbar(end,c))
{
case '-':
exb = "1v-.5m"; break;
case '=':
exb = "1v-.5m";
epb = 1; break;
}
}
if (lwid>1)
switch(interh(end, c))
{
case THRU: epb -= 1; break;
case RIGHT: epb += (ln==0 ? 1 : -1); break;
case LEFT: epb += (ln==1 ? 1 : -1); break;
}
if (lwid==1)
switch(interh(end,c))
{
case THRU: epb -= 1; break;
case RIGHT: case LEFT: epb += 1; break;
}
if (start>0)
{
sl = start-1;
while (sl>=0 && instead[sl]) sl--;
if (sl>=0 && (fullbot[sl] || allh(sl)))
ept=0;
else
if (sl>=0)
switch(midbar(sl,c))
{
case '-':
ext = ".5m"; break;
case '=':
ext= ".5m"; ept = -1; break;
default:
vm = 'm'; break;
}
else
ept = -4;
}
else if (start==0 && allh(0))
{
ept=0;
vm = 'm';
}
if (lwid>1)
switch(interh(start,c))
{
case THRU: ept += 1; break;
case LEFT: ept += (ln==0 ? 1 : -1); break;
case RIGHT: ept += (ln==1 ? 1 : -1); break;
}
else if (lwid==1)
switch(interh(start,c))
{
case THRU: ept += 1; break;
case LEFT: case RIGHT: ept -= 1; break;
}
if (exb)
fprintf(tabout, "\\v'%s'", exb);
if (epb)
fprintf(tabout, "\\v'%dp'", epb);
fprintf(tabout, "\\s\\n(%d",LSIZE);
if (linsize)
fprintf(tabout, "\\v'-\\n(%dp/6u'", LSIZE);
fprintf(tabout, "\\h'-\\n(#~u'"); /* adjustment for T450 nroff boxes */
fprintf(tabout, "\\L'|\\n(#%cu-%s", linestop[start]+'a'-1, vm=='v'? "1v" : "\\n(35u");
if (ext)
fprintf(tabout, "-(%s)",ext);
if (exb)
fprintf(tabout, "-(%s)", exb);
pos = ept-epb;
if (pos)
fprintf(tabout, "%s%dp", pos>=0? "+" : "", pos);
/* the string #d is either "nl" or ".d" depending
on diversions; on GCOS not the same */
fprintf(tabout, "'\\s0\\v'\\n(\\*(#du-\\n(#%cu+%s", linestop[start]+'a'-1,vm=='v' ? "1v" : "\\n(35u");
if (ext)
fprintf(tabout, "+%s",ext);
if (ept)
fprintf(tabout, "%s%dp", (-ept)>0 ? "+" : "", (-ept));
fprintf(tabout, "'");
if (linsize)
fprintf(tabout, "\\v'\\n(%dp/6u'", LSIZE);
}
}
midbar(i,c)
{
int k;
k = midbcol(i,c);
if (k==0 && c>0)
k = midbcol(i, c-1);
return(k);
}
midbcol(i,c)
{
int ct;
while ( (ct=ctype(i,c)) == 's')
c--;
if (ct=='-' || ct == '=')
return(ct);
if (ct=barent(table[i][c].col))
return(ct);
return(0);
}
barent(s)
char *s;
{
if (s==0) return (1);
if (!point(s)) return(0);
if (s[0]== '\\') s++;
if (s[1]!= 0)
return(0);
switch(s[0])
{
case '_':
return('-');
case '=':
return('=');
}
return(0);
}
0707070035051114711006640000030000040000010246070265271267100001300000000000TRAILER!!! 0);
}
barent(s)
char *s;
{
if (s==0) return (1);
if (!point(s)) return(0);
if (s[0]== '\\') s++;
if (s[1]!= 0)
return(0);
switch(s[0])
{
case '_':
return('-');
case '=':
return('=');
}
return(0);
}
0707070
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.