BSD 4_1c_2 development

Work on file usr/src/usr.bin/tbl/t..c
Work on file usr/src/usr.bin/tbl/Makefile
Work on file usr/src/usr.bin/tbl/t0.c
Work on file usr/src/usr.bin/tbl/t3.c
Work on file usr/src/usr.bin/tbl/t2.c
Work on file usr/src/usr.bin/tbl/t1.c
Work on file usr/src/usr.bin/tbl/t5.c
Work on file usr/src/usr.bin/tbl/t6.c
Work on file usr/src/usr.bin/tbl/t7.c
Work on file usr/src/usr.bin/tbl/t4.c
Work on file usr/src/usr.bin/tbl/tb.c
Work on file usr/src/usr.bin/tbl/t9.c
Work on file usr/src/usr.bin/tbl/t8.c
Work on file usr/src/usr.bin/tbl/tg.c
Work on file usr/src/usr.bin/tbl/te.c
Work on file usr/src/usr.bin/tbl/tc.c
Work on file usr/src/usr.bin/tbl/tf.c
Work on file usr/src/usr.bin/tbl/tm.c
Work on file usr/src/usr.bin/tbl/ti.c
Work on file usr/src/usr.bin/tbl/tt.c
Work on file usr/src/usr.bin/tbl/ts.c
Work on file usr/src/usr.bin/tbl/tu.c
Work on file usr/src/usr.bin/tbl/tv.c
Work on file usr/src/usr.bin/prof/Makefile

Synthesized-from: CSRG/cd1/4.1c.2

diff --git a/usr/src/usr.bin/prof/Makefile b/usr/src/usr.bin/prof/Makefile
new file mode 100644 (file)
index 0000000..112b25d
--- /dev/null
+++ b/usr/src/usr.bin/prof/Makefile
@@ -0,0 +1,14 @@
+# If you don't want to plot, take out the -Dplot and the ref. to plot.a
+PLOT = -lplot -Dplot
+CFLAGS=-O 
+prof:  prof.o
+       $(CC) -o prof prof.o $(PLOT)
+
+prof.o: prof.c
+       cc -c $(CFLAGS) $(PLOT) prof.c
+
+install:
+       install -s prof $(DESTDIR)/usr/bin
+
+clean :
+       rm -f *.o prof

diff --git a/usr/src/usr.bin/tbl/Makefile b/usr/src/usr.bin/tbl/Makefile
new file mode 100644 (file)
index 0000000..221cbf2
--- /dev/null
+++ b/usr/src/usr.bin/tbl/Makefile
@@ -0,0 +1,69 @@
+CFLAGS=-O
+o = t0.o t1.o t2.o t3.o t4.o t5.o t6.o t7.o t8.o t9.o\
+    tb.o tc.o te.o tf.o tg.o ti.o tm.o ts.o tt.o tu.o tv.o
+
+tbl :  $o
+       $(CC) $o -o tbl
+$o :   t..c
+
+install: 
+       install -s tbl $(DESTDIR)/usr/bin
+
+clean :
+       rm -f *.o
+
+test:
+       sh compr sample01
+       sh compr sample02
+       sh compr sample03
+       sh compr sample04
+       sh compr sample05
+       sh compr sample06
+       sh compr sample07
+       sh compr sample08
+       sh compeq sample09
+       sh compeq sample10
+       sh compeq sample11
+       sh compr sample12
+       sh compr sample13
+       sh compr sample14
+       sh compr sample15
+       sh compr sample16
+       sh compr sample17
+       sh compr sample18
+       sh compr sample19
+       sh compr sample20
+       sh compr sample21
+       sh compr sample22
+       sh compr sample23
+       sh compms sample24
+       sh compr sample25
+       sh compr sample26
+       sh compr sample27
+       sh compr sample28
+       sh compr sample29
+       sh compr sample30
+       sh compr sample31
+       sh compr sample32
+       sh compr sample33
+       sh compms sample34
+       sh compeq sample35
+       sh compeq sample36
+       sh compnr sample37
+       sh compr sample38
+       sh compr sample39
+       sh compr sample40
+       sh compr sample41
+       sh compr sample42
+       sh compr sample43
+       sh compr sample44
+       sh compms sample45
+       sh compms sample46
+       sh compr sample47
+       sh compnr sample48
+       sh compeq /usr/doc/mel/tables
+ichk: /usr/bin/tbl
+       /usr/bin/tbl sample1 >junk1
+       cmp -s junk1 out1
+comp: tbl
+       cmp -s tbl /usr/bin/tbl

diff --git a/usr/src/usr.bin/tbl/t..c b/usr/src/usr.bin/tbl/t..c
new file mode 100644 (file)
index 0000000..4334622
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t..c
@@ -0,0 +1,71 @@
+/* t..c : external declarations */
+
+# include "stdio.h"
+# include "ctype.h"
+
+# define MAXLIN 200
+# define MAXHEAD 30
+# define MAXCOL 20
+# define MAXCHS 2000
+# define MAXRPT 100
+# define CLLEN 10
+# define SHORTLINE 4
+extern int nlin, ncol, iline, nclin, nslin;
+extern int style[MAXHEAD][MAXCOL];
+extern int ctop[MAXHEAD][MAXCOL];
+extern char font[MAXHEAD][MAXCOL][2];
+extern char csize[MAXHEAD][MAXCOL][4];
+extern char vsize[MAXHEAD][MAXCOL][4];
+extern char cll[MAXCOL][CLLEN];
+extern int stynum[];
+extern int F1, F2;
+extern int lefline[MAXHEAD][MAXCOL];
+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;
+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 80
+# define CLEFT 40
+# define CMID 60
+# define S1 31
+# define S2 32
+# define TMP 38
+# 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

diff --git a/usr/src/usr.bin/tbl/t0.c b/usr/src/usr.bin/tbl/t0.c
new file mode 100644 (file)
index 0000000..5ad82c6
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t0.c
@@ -0,0 +1,48 @@
+ /* 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 evenup[MAXCOL], evenflg;
+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 style[MAXHEAD][MAXCOL];
+int ctop[MAXHEAD][MAXCOL];
+char font[MAXHEAD][MAXCOL][2];
+char csize[MAXHEAD][MAXCOL][4];
+char vsize[MAXHEAD][MAXCOL][4];
+int lefline[MAXHEAD][MAXCOL];
+char cll[MAXCOL][CLLEN];
+/*char *rpt[MAXHEAD][MAXCOL];*/
+/*char rpttx[MAXRPT];*/
+int stynum[MAXLIN+1];
+int nslin, nclin;
+int sep[MAXCOL];
+int fullbot[MAXLIN];
+char *instead[MAXLIN];
+int used[MAXCOL], lused[MAXCOL], rused[MAXCOL];
+int linestop[MAXLIN];
+int nlin, ncol;
+int iline = 1;
+char *ifile = "Input";
+int texname = 'a';
+int texct = 0;
+char texstr[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYXZ0123456789";
+int linstart;
+char *exstore, *exlim;
+FILE *tabin  /*= stdin */;
+FILE *tabout  /* = stdout */;

diff --git a/usr/src/usr.bin/tbl/t1.c b/usr/src/usr.bin/tbl/t1.c
new file mode 100644 (file)
index 0000000..cf6ee75
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t1.c
@@ -0,0 +1,106 @@
+ /* 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[BUFSIZ];
+/* required by GCOS because "stdout" is set by troff preprocessor */
+tabin=stdin; tabout=stdout;
+setinp(argc,argv);
+while (gets1(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()
+{
+       while (sargc>0 && **sargv=='-') /* Mem fault if no test on sargc */
+               {
+               if (sargc<=0) return(0);
+               if (match("-ms", *sargv))
+                       {
+                       *sargv = MACROS;
+                       break;
+                       }
+               if (match("-mm", *sargv))
+                       {
+                       *sargv = PYMACS;
+                       break;
+                       }
+               if (match("-TX", *sargv))
+                       pr1403=1;
+               sargc--; sargv++;
+               }
+       if (sargc<=0) return(0);
+# ifdef unix
+/* file closing is done by GCOS troff preprocessor */
+       if (tabin!=stdin) fclose(tabin);
+# endif
+       tabin = fopen(ifile= *sargv, "r");
+       iline=1;
+# ifdef unix
+/* file names are all put into f. by the GCOS troff preprocessor */
+       fprintf(tabout, ".ds f. %s\n",ifile);
+# endif
+       if (tabin==NULL)
+               error("Can't open file");
+       sargc--;
+       sargv++;
+       return(1);
+}
+# ifdef unix
+badsig()
+{
+signal(SIGPIPE, SIG_IGN);
+ exit(0);
+}
+# endif

diff --git a/usr/src/usr.bin/tbl/t2.c b/usr/src/usr.bin/tbl/t2.c
new file mode 100644 (file)
index 0000000..780dc79
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t2.c
@@ -0,0 +1,21 @@
+ /* 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();
+restline();
+}

diff --git a/usr/src/usr.bin/tbl/t3.c b/usr/src/usr.bin/tbl/t3.c
new file mode 100644 (file)
index 0000000..22f71ec
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t3.c
@@ -0,0 +1,93 @@
+ /* 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);
+/* see if this is a command line */
+if (index(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;
+}

diff --git a/usr/src/usr.bin/tbl/t4.c b/usr/src/usr.bin/tbl/t4.c
new file mode 100644 (file)
index 0000000..61ad357
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t4.c
@@ -0,0 +1,233 @@
+ /* t4.c: read table specification */
+# include "t..c"
+int oncol;
+getspec()
+{
+int icol, i;
+for(icol=0; icol<MAXCOL; icol++)
+       {
+       sep[icol]= -1;
+       evenup[icol]=0;
+       cll[icol][0]=0;
+       for(i=0; i<MAXHEAD; i++)
+               {
+               csize[i][icol][0]=0;
+               vsize[i][icol][0]=0;
+               font[i][icol][0] = lefline[i][icol] = 0;
+               ctop[i][icol]=0;
+               style[i][icol]= 'l';
+               }
+       }
+nclin=ncol=0;
+oncol =0;
+left1flg=rightl=0;
+readspec();
+fprintf(tabout, ".rm");
+for(i=0; i<ncol; i++)
+       fprintf(tabout, " %02d", 80+i);
+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[nclin][ncol]>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 : 1;
+                               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[nclin][icol]=c;
+                       if (c== 's' && icol<=0)
+                               error("first column can not be S-type");
+                       if (c=='s' && style[nclin][icol-1] == 'a')
+                               {
+                               fprintf(tabout, ".tm warning: can't span a-type cols, changed to l\n");
+                               style[nclin][icol-1] = 'l';
+                               }
+                       if (c=='s' && style[nclin][icol-1] == 'n')
+                               {
+                               fprintf(tabout, ".tm warning: can't span n-type cols, changed to c\n");
+                               style[nclin][icol-1] = 'c';
+                               }
+                       icol++;
+                       if (c=='^' && nclin<=0)
+                               error("first row can not contain vertical span");
+                       if (icol>=MAXCOL)
+                               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[nclin][icol-1];
+                       snp[0]= (c=='I' ? '2' : '3');
+                       snp[1]=0;
+                       continue;
+               case 't': case 'T':
+                       if (icol>0)
+                       ctop[nclin][icol-1] = 1;
+                       continue;
+               case 'd': case 'D':
+                       if (icol>0)
+                       ctop[nclin][icol-1] = -1;
+                       continue;
+               case 'f': case 'F':
+                       if (icol==0) continue;
+                       snp=font[nclin][icol-1];
+                       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'){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[nclin][icol-1];
+                       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[nclin][icol-1];
+                       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 '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[nclin][icol]++;
+                       if (icol==0) left1flg=1;
+                       continue;
+               }
+       }
+error("EOF reading table specification");
+}

diff --git a/usr/src/usr.bin/tbl/t5.c b/usr/src/usr.bin/tbl/t5.c
new file mode 100644 (file)
index 0000000..1cc245f
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t5.c
@@ -0,0 +1,166 @@
+ /* t5.c: read data for table */
+# include "t..c"
+gettbl()
+{
+int icol, ch;
+cstore=cspace= chspace();
+textflg=0;
+for (nlin=nslin=0; gets1(cstore); nlin++)
+       {
+       stynum[nlin]=nslin;
+       if (prefix(".TE", cstore))
+               {
+               leftover=0;
+               break;
+               }
+       if (prefix(".TC", cstore) || prefix(".T&", cstore))
+               {
+               readspec();
+               nslin++;
+               }
+       if (nlin>=MAXLIN)
+               {
+               leftover=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;
+               nlin++;
+               nslin++;
+               instead[nlin]=fullbot[nlin]=0;
+               }
+       table[nlin] = 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 =
+                               gettext(cstore, nlin, icol,
+                                       font[stynum[nlin]][icol],
+                                       csize[stynum[nlin]][icol]);
+               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 > 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));
+}

diff --git a/usr/src/usr.bin/tbl/t6.c b/usr/src/usr.bin/tbl/t6.c
new file mode 100644 (file)
index 0000000..3909b98
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t6.c
@@ -0,0 +1,202 @@
+ /* t6.c: compute tab stops */
+# define tx(a) (a>0 && a<128)
+# include "t..c"
+maktab()
+{
+# define FN(i,c) font[stynum[i]][c]
+# define SZ(i,c) csize[stynum[i]][c]
+/* define the tab stops of the table */
+int icol, ilin, tsep, k, ik, vforml, il, text;
+int doubled[MAXCOL], acase[MAXCOL];
+char *s;
+for(icol=0; icol <ncol; icol++)
+       {
+       doubled[icol] = acase[icol] = 0;
+       fprintf(tabout, ".nr %d 0\n", icol+CRIGHT);
+   for(text=0; text<2; text++)
+       {
+       if (text)
+               fprintf(tabout, ".%02d\n.rm %02d\n", icol+80, icol+80);
+       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;
+               switch(ctype(vforml,icol))
+                       {
+                       case 'a':
+                               acase[icol]=1;
+                               s = table[ilin][icol].col;
+                               if (s>0 && 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(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(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", icol+CRIGHT, TMP, icol+CRIGHT, TMP);
+                                       }
+                       }
+               }
+               }
+       if (acase[icol])
+               {
+               fprintf(tabout, ".if \\n(%d>=\\n(%d .nr %d \\n(%du+2n\n",S2,icol+CRIGHT,icol+CRIGHT,S2);
+               }
+       if (doubled[icol])
+               {
+               fprintf(tabout, ".nr %d \\n(%d\n", icol+CMID, S1);
+               fprintf(tabout, ".nr %d \\n(%d+\\n(%d\n",TMP,icol+CMID,S2);
+               fprintf(tabout, ".if \\n(%d>\\n(%d .nr %d \\n(%d\n",TMP,icol+CRIGHT,icol+CRIGHT,TMP);
+               fprintf(tabout, ".if \\n(%d<\\n(%d .nr %d +(\\n(%d-\\n(%d)/2\n",TMP,icol+CRIGHT,icol+CMID,icol+CRIGHT,TMP);
+               }
+       if (cll[icol][0])
+               {
+               fprintf(tabout, ".nr %d %sn\n", TMP, cll[icol]);
+               fprintf(tabout, ".if \\n(%d<\\n(%d .nr %d \\n(%d\n",icol+CRIGHT, TMP, 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(%d",CRIGHT+icol-ik);
+                       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 %d +\\n(%d/2\n", icol-k+ik+CMID, TMP);
+                       fprintf(tabout, ".nr %d +\\n(%d\n", 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(%d>\\n(%d .nr %d \\n(%d\n",
+               icol+CRIGHT, TMP, TMP, 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 %d (100*\\n(%d/\\n(%d)*\\n(%d/100\n",
+                               icol+CMID, icol+CMID, 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 %d \\n(%d\n", 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(%d", 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 %d 0\n",CRIGHT-1);
+tsep= (boxflg || allflg || dboxflg || left1flg) ? 1 : 0;
+for(icol=0; icol<ncol; icol++)
+       {
+       fprintf(tabout, ".nr %d \\n(%d+(%d*\\n(%d)\n",icol+CLEFT, icol+CRIGHT-1, tsep, TMP);
+       fprintf(tabout, ".nr %d +\\n(%d\n",icol+CRIGHT, icol+CLEFT);
+       if (doubled[icol])
+               {
+               /* the next line is last-ditch effort to avoid zero field width */
+               /*fprintf(tabout, ".if \\n(%d=0 .nr %d 1\n",icol+CMID, icol+CMID);*/
+               fprintf(tabout, ".nr %d +\\n(%d\n", icol+CMID, icol+CLEFT);
+       /*  fprintf(tabout, ".if n .if \\n(%d%%24>0 .nr %d +12u\n",icol+CMID, icol+CMID); */
+               }
+       tsep=sep[icol];
+       }
+if (rightl)
+       fprintf(tabout, ".nr %d (\\n(%d+\\n(%d)/2\n",ncol+CRIGHT-1, ncol+CLEFT-1, ncol+CRIGHT-2);
+fprintf(tabout, ".nr TW \\n(%d\n", ncol+CRIGHT-1);
+if (boxflg || allflg || dboxflg)
+       fprintf(tabout, ".nr TW +%d*\\n(%d\n", sep[ncol-1], 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');
+}

diff --git a/usr/src/usr.bin/tbl/t7.c b/usr/src/usr.bin/tbl/t7.c
new file mode 100644 (file)
index 0000000..40bb471
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t7.c
@@ -0,0 +1,131 @@
+ /* 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(%du ",c+CMID);
+               case 'c':
+               case 'l':
+               case 'r':
+                   if (realsplit? rused[c]: (used[c]+lused[c]))
+                       fprintf(tabout, "\\n(%du ",c+CRIGHT);
+                       continue;
+               case 's':
+                       if (lspan(lform, c))
+                               fprintf(tabout, "\\n(%du ", c+CRIGHT);
+                       continue;
+               }
+       }
+fprintf(tabout, "\n");
+}
+ifline(s)
+       char *s;
+{
+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, ".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");
+}

diff --git a/usr/src/usr.bin/tbl/t8.c b/usr/src/usr.bin/tbl/t8.c
new file mode 100644 (file)
index 0000000..e868dd8
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t8.c
@@ -0,0 +1,327 @@
+ /* 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;
+int topat[MAXCOL];
+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;
+char *s, *size, *fn;
+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 (s>0 && 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[stynum[nl]][c]);
+       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");
+       }
+if (chfont)
+       fprintf(tabout, ".nr %2d \\n(.f\n", S1);
+fprintf(tabout, ".nr 35 1m\n");
+fprintf(tabout, "\\&");
+vct = 0;
+for(c=0; c<ncol; c++)
+       {
+       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 = c+CLEFT;
+               if (form=='a') ct = c+CMID;
+               if (form=='n' && table[nl][c].rcol && lused[c]==0) ct= c+CMID;
+               fprintf(tabout, "\\h'|\\n(%du'", ct);
+               }
+       s= table[nl][c].col;
+       fn = font[stynum[vforml]][c];
+       size = csize[stynum[vforml]][c];
+       if (*size==0)size=0;
+       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++;
+                                               fprintf(tabout, "'");
+                                               exvspen=1;
+                                               }
+                                       }
+                               fprintf(tabout, "%c%c",F1,F2);
+                               puttext(s,fn,size);
+                               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))
+                       {
+                       printf("\\l'|\\n(%du\\&%s'", c+CRIGHT, s+2);
+                       continue;
+                       }
+               ip = prev(nl);
+               cmidx = ctop[stynum[nl]][c]==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++;
+                               fprintf(tabout, "'");
+                               }
+                       }
+               fprintf(tabout, "%c", F1);
+               if (form!= 1)
+                       fprintf(tabout, "%c", F2);
+               if (vspen(s))
+                       vspf=1;
+               else
+               puttext(s, fn, size);
+               if (form !=2)
+                       fprintf(tabout, "%c", F2);
+               fprintf(tabout, "%c", F1);
+               }
+       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 == (ctop [stynum[nl]][c+1]==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++;
+                       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 = 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(%du+\\n(%du-\\n(%c-u)/2u\n",c+CLEFT,c-1+ctspan(lin,c)+CRIGHT, s);
+                       break;
+               case 'l':
+                       fprintf(tabout, "\\n(%du\n",c+CLEFT);
+                       break;
+               case 'a':
+                       fprintf(tabout, "\\n(%du\n",c+CMID);
+                       break;
+               case 'r':
+                       fprintf(tabout, "\\n(%du-\\n(%c-u\n", c+CRIGHT, s);
+                       break;
+               }
+       fprintf(tabout, ".in +\\n(%du\n", SIND);
+       fn=font[stynum[stl]][c];
+       putfont(fn);
+       pl = prev(stl);
+       if (stl>0 && pl>=0 && vspen(table[pl][c].col))
+               {
+               fprintf(tabout, ".sp |\\n(^%cu\n", 'a'+c);
+               if (ctop[stynum[stl]][c]==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\n", TMP, TMP);
+                       }
+               }
+       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);
+}

diff --git a/usr/src/usr.bin/tbl/t9.c b/usr/src/usr.bin/tbl/t9.c
new file mode 100644 (file)
index 0000000..dda72ee
--- /dev/null
+++ b/usr/src/usr.bin/tbl/t9.c
@@ -0,0 +1,62 @@
+ /* t9.c: write lines for tables over 200 lines */
+# include "t..c"
+static useln;
+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) && 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);
+       }
+instead[0]=fullbot[0]=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);
+return(1);
+}

diff --git a/usr/src/usr.bin/tbl/tb.c b/usr/src/usr.bin/tbl/tb.c
new file mode 100644 (file)
index 0000000..0a68bda
--- /dev/null
+++ b/usr/src/usr.bin/tbl/tb.c
@@ -0,0 +1,82 @@
+ /* 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];
+chspace()
+{
+char *pp;
+if (spvecs[spcount])
+       return(spvecs[spcount++]);
+if (spcount>=MAXVEC)
+       error("Too many characters in table");
+spvecs[spcount++]= pp = calloc(MAXCHS+200,1);
+if (pp== -1 || pp == 0)
+       error("no space for characters");
+return(pp);
+}
+# define MAXPC 50
+char *thisvec;
+int tpcount = -1;
+char *tpvecs[MAXPC];
+alocv(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 == -1)
+               error("no space for vectors");
+       }
+tp=thisvec;
+thisvec+=n;
+for(q=tp; q<thisvec; q++)
+       *q=0;
+return(tp);
+}
+release()
+{
+extern char *exstore;
+/* give back unwanted space in some vectors */
+spcount=0;
+tpcount= -1;
+exstore=0;
+}

diff --git a/usr/src/usr.bin/tbl/tc.c b/usr/src/usr.bin/tbl/tc.c
new file mode 100644 (file)
index 0000000..3c267c6
--- /dev/null
+++ b/usr/src/usr.bin/tbl/tc.c
@@ -0,0 +1,60 @@
+ /* 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);
+}

diff --git a/usr/src/usr.bin/tbl/te.c b/usr/src/usr.bin/tbl/te.c
new file mode 100644 (file)
index 0000000..75ea7de
--- /dev/null
+++ b/usr/src/usr.bin/tbl/te.c
@@ -0,0 +1,67 @@
+ /* 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
+}
+gets1(s)
+       char *s;
+{
+char *p;
+int nbl = 0;
+iline++;
+p=fgets(s,BUFSIZ,tabin);
+while (p==0)
+       {
+       if (swapin()==0)
+               return(0);
+       p = fgets(s,BUFSIZ,tabin);
+       }
+
+while (*s) s++;
+s--;
+if (*s == '\n') *s-- =0;
+for(nbl=0; *s == '\\' && s>p; s--)
+       nbl++;
+if (linstart && nbl % 2) /* fold escaped nl if in table */
+       gets1(s+1);
+
+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);
+}

diff --git a/usr/src/usr.bin/tbl/tf.c b/usr/src/usr.bin/tbl/tf.c
new file mode 100644 (file)
index 0000000..e65a632
--- /dev/null
+++ b/usr/src/usr.bin/tbl/tf.c
@@ -0,0 +1,51 @@
+ /* 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 .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", 'a'+i);
+       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");
+}

diff --git a/usr/src/usr.bin/tbl/tg.c b/usr/src/usr.bin/tbl/tg.c
new file mode 100644 (file)
index 0000000..6673cb6
--- /dev/null
+++ b/usr/src/usr.bin/tbl/tg.c
@@ -0,0 +1,69 @@
+ /* 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[256];
+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 %02d\n", icol+80);
+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[stynum[ilin]][icol];
+if ((sz && *sz) || (vs && *vs))
+       {
+       fprintf(tabout, ".nr %d \\n(.v\n", S2);
+       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", S2,S2);
+       }
+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(%d .ll \\n(%du\n", icol+CRIGHT, icol+CRIGHT);
+if (ctype(ilin,icol)=='a')
+       fprintf(tabout, ".ll -2n\n");
+fprintf(tabout, ".in 0\n");
+while (gets1(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);
+}

diff --git a/usr/src/usr.bin/tbl/ti.c b/usr/src/usr.bin/tbl/ti.c
new file mode 100644 (file)
index 0000000..5df0c3a
--- /dev/null
+++ b/usr/src/usr.bin/tbl/ti.c
@@ -0,0 +1,56 @@
+ /* 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)
+       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);
+}

diff --git a/usr/src/usr.bin/tbl/tm.c b/usr/src/usr.bin/tbl/tm.c
new file mode 100644 (file)
index 0000000..e9c0328
--- /dev/null
+++ b/usr/src/usr.bin/tbl/tm.c
@@ -0,0 +1,63 @@
+ /* tm.c: split numerical fields */
+# include "t..c"
+maknew(str)
+       char *str;
+{
+       /* make two numerical fields */
+       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=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=dpoint;
+               }
+       else
+               str = ba;
+       p =str;
+       if (exstore ==0 || exstore >exlim)
+               {
+               exstore = 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);
+}

diff --git a/usr/src/usr.bin/tbl/ts.c b/usr/src/usr.bin/tbl/ts.c
new file mode 100644 (file)
index 0000000..e0f8b1c
--- /dev/null
+++ b/usr/src/usr.bin/tbl/ts.c
@@ -0,0 +1,49 @@
+ /* 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++);
+}

diff --git a/usr/src/usr.bin/tbl/tt.c b/usr/src/usr.bin/tbl/tt.c
new file mode 100644 (file)
index 0000000..ae34556
--- /dev/null
+++ b/usr/src/usr.bin/tbl/tt.c
@@ -0,0 +1,85 @@
+ /* 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[il][ic]);
+}
+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(%du+|\\n(%du)/2u'", ic+CLEFT, ic+CRIGHT-1);
+}
+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);
+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);
+}

diff --git a/usr/src/usr.bin/tbl/tu.c b/usr/src/usr.bin/tbl/tu.c
new file mode 100644 (file)
index 0000000..4a08347
--- /dev/null
+++ b/usr/src/usr.bin/tbl/tu.c
@@ -0,0 +1,202 @@
+ /* 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;
+       int lcount, ln, linpos, oldpos, nodata, lnch;
+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(%du'", cl+CLEFT);
+       fprintf(tabout, "\\s\\n(%d",LSIZE);
+       if (linsize)
+               fprintf(tabout, "\\v'-\\n(%dp/6u'", LSIZE);
+       if (shortl)
+               fprintf(tabout, "\\l'|\\n(%du'", 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(%du+|\\n(%du)/2u%s%s'", cr+CRIGHT,
+                       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;
+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[i][c];
+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);
+}

diff --git a/usr/src/usr.bin/tbl/tv.c b/usr/src/usr.bin/tbl/tv.c
new file mode 100644 (file)
index 0000000..eaf0c8b
--- /dev/null
+++ b/usr/src/usr.bin/tbl/tv.c
@@ -0,0 +1,147 @@
+ /* 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 (s[0]== '\\') s++;
+if (s[1]!= 0)
+       return(0);
+switch(s[0])
+       {
+       case '_':
+               return('-');
+       case '=':
+               return('=');
+       }
+return(0);
+}