171ef9f71Sjaap #ifndef lint
2*cbcd6dcaSkarels /*
3634ac1b9Sjaap static char sccsid[]="@(#)n10.c 1.2 (CWI) 86/08/15";
4*cbcd6dcaSkarels */
5*cbcd6dcaSkarels static char sccsid[] = "@(#)n10.c 1.3 (Berkeley) 11/03/90";
671ef9f71Sjaap #endif
771ef9f71Sjaap
871ef9f71Sjaap /*
971ef9f71Sjaap n10.c
1071ef9f71Sjaap
1171ef9f71Sjaap Device interfaces
1271ef9f71Sjaap */
1371ef9f71Sjaap
1471ef9f71Sjaap #include "tdef.h"
1571ef9f71Sjaap #include "ext.h"
1671ef9f71Sjaap #include "tw.h"
1771ef9f71Sjaap #include <sgtty.h>
1871ef9f71Sjaap #include <ctype.h>
1971ef9f71Sjaap #include <sys/types.h>
2071ef9f71Sjaap #include <sys/stat.h>
2171ef9f71Sjaap
2271ef9f71Sjaap struct t t; /* terminal characteristics */
2371ef9f71Sjaap
2471ef9f71Sjaap int dtab;
2571ef9f71Sjaap int plotmode;
2671ef9f71Sjaap int esct;
2771ef9f71Sjaap
2871ef9f71Sjaap char xchname[4 * (NROFFCHARS-128)]; /* hy, em, etc. */
2971ef9f71Sjaap short xchtab[NROFFCHARS-128]; /* indexes into chname[] */
3071ef9f71Sjaap char *codestr;
3171ef9f71Sjaap char *chname = xchname;
3271ef9f71Sjaap short *chtab = xchtab;
3371ef9f71Sjaap
3471ef9f71Sjaap
3571ef9f71Sjaap int Inch;
3671ef9f71Sjaap int Hor;
3771ef9f71Sjaap int Vert;
3871ef9f71Sjaap int nfonts = 4; /* R, I, B, S */
3971ef9f71Sjaap
4071ef9f71Sjaap /* these characters are used as various signals or values
4171ef9f71Sjaap /* in miscellaneous places.
4271ef9f71Sjaap /* values are set in specnames in t10.c
4371ef9f71Sjaap */
4471ef9f71Sjaap
4571ef9f71Sjaap int c_hyphen;
4671ef9f71Sjaap int c_emdash;
4771ef9f71Sjaap int c_rule;
4871ef9f71Sjaap int c_minus;
4971ef9f71Sjaap int c_fi;
5071ef9f71Sjaap int c_fl;
5171ef9f71Sjaap int c_ff;
5271ef9f71Sjaap int c_ffi;
5371ef9f71Sjaap int c_ffl;
5471ef9f71Sjaap int c_acute;
5571ef9f71Sjaap int c_grave;
5671ef9f71Sjaap int c_under;
5771ef9f71Sjaap int c_rooten;
5871ef9f71Sjaap int c_boxrule;
5971ef9f71Sjaap int c_lefthand;
6071ef9f71Sjaap int c_dagger;
6171ef9f71Sjaap int c_isalnum;
6271ef9f71Sjaap
ptinit()6371ef9f71Sjaap ptinit()
6471ef9f71Sjaap {
6571ef9f71Sjaap register int i, j;
6671ef9f71Sjaap register char *p, *cp, *q;
6771ef9f71Sjaap int nread, fd;
6871ef9f71Sjaap extern char *skipstr(), *getstr(), *getint();
6971ef9f71Sjaap struct stat stbuf;
7071ef9f71Sjaap char check[50];
7171ef9f71Sjaap
7271ef9f71Sjaap strcat(termtab, devname);
7371ef9f71Sjaap if ((fd = open(termtab, 0)) < 0) {
7471ef9f71Sjaap errprint("cannot open %s", termtab);
7571ef9f71Sjaap exit(-1);
7671ef9f71Sjaap }
7771ef9f71Sjaap
7871ef9f71Sjaap fstat(fd, &stbuf);
79*cbcd6dcaSkarels codestr = malloc((int) stbuf.st_size);
8071ef9f71Sjaap
8171ef9f71Sjaap nread = read(fd, codestr, (int) stbuf.st_size);
8271ef9f71Sjaap close(fd);
8371ef9f71Sjaap
8471ef9f71Sjaap p = codestr;
8571ef9f71Sjaap p = skipstr(p); /* skip over type, could check */
8671ef9f71Sjaap p = skipstr(p); p = getint(p, &t.bset);
8771ef9f71Sjaap p = skipstr(p); p = getint(p, &t.breset);
8871ef9f71Sjaap p = skipstr(p); p = getint(p, &t.Hor);
8971ef9f71Sjaap p = skipstr(p); p = getint(p, &t.Vert);
9071ef9f71Sjaap p = skipstr(p); p = getint(p, &t.Newline);
9171ef9f71Sjaap p = skipstr(p); p = getint(p, &t.Char);
9271ef9f71Sjaap p = skipstr(p); p = getint(p, &t.Em);
9371ef9f71Sjaap p = skipstr(p); p = getint(p, &t.Halfline);
9471ef9f71Sjaap p = skipstr(p); p = getint(p, &t.Adj);
9571ef9f71Sjaap p = skipstr(p); p = getstr(p, t.twinit = p);
9671ef9f71Sjaap p = skipstr(p); p = getstr(p, t.twrest = p);
9771ef9f71Sjaap p = skipstr(p); p = getstr(p, t.twnl = p);
9871ef9f71Sjaap p = skipstr(p); p = getstr(p, t.hlr = p);
9971ef9f71Sjaap p = skipstr(p); p = getstr(p, t.hlf = p);
10071ef9f71Sjaap p = skipstr(p); p = getstr(p, t.flr = p);
10171ef9f71Sjaap p = skipstr(p); p = getstr(p, t.bdon = p);
10271ef9f71Sjaap p = skipstr(p); p = getstr(p, t.bdoff = p);
10371ef9f71Sjaap p = skipstr(p); p = getstr(p, t.iton = p);
10471ef9f71Sjaap p = skipstr(p); p = getstr(p, t.itoff = p);
10571ef9f71Sjaap p = skipstr(p); p = getstr(p, t.ploton = p);
10671ef9f71Sjaap p = skipstr(p); p = getstr(p, t.plotoff = p);
10771ef9f71Sjaap p = skipstr(p); p = getstr(p, t.up = p);
10871ef9f71Sjaap p = skipstr(p); p = getstr(p, t.down = p);
10971ef9f71Sjaap p = skipstr(p); p = getstr(p, t.right = p);
11071ef9f71Sjaap p = skipstr(p); p = getstr(p, t.left = p);
111634ac1b9Sjaap p = skipstr(p); p = getstr(p, t.eject = p);
11271ef9f71Sjaap
11371ef9f71Sjaap getstr(p, check);
11471ef9f71Sjaap if (strcmp(check, "charset") != 0) {
11571ef9f71Sjaap errprint("device table apparently curdled");
11671ef9f71Sjaap exit(1);
11771ef9f71Sjaap }
11871ef9f71Sjaap
11971ef9f71Sjaap for (i = 0; i < 128; i++)
12071ef9f71Sjaap t.width[i] = 1; /* default ascii widths */
12171ef9f71Sjaap
12271ef9f71Sjaap i = 0;
12371ef9f71Sjaap /* this ought to be a pointer array and in place in codestr */
12471ef9f71Sjaap cp = chname + 1; /* bug if starts at 0, in setch */
12571ef9f71Sjaap while (p < codestr + nread) {
12671ef9f71Sjaap while (*p == ' ' || *p == '\t' || *p == '\n')
12771ef9f71Sjaap p++;
12871ef9f71Sjaap chtab[i] = cp - chname; /* index, not pointer */
12971ef9f71Sjaap *cp++ = *p++; /* 2-char names */
13071ef9f71Sjaap *cp++ = *p++;
13171ef9f71Sjaap *cp++ = '\0';
13271ef9f71Sjaap while (*p == ' ' || *p == '\t')
13371ef9f71Sjaap p++;
13471ef9f71Sjaap t.width[i+128] = *p++ - '0';
13571ef9f71Sjaap while (*p == ' ' || *p == '\t')
13671ef9f71Sjaap p++;
13771ef9f71Sjaap t.codetab[i] = p;
13871ef9f71Sjaap p = getstr(p, p); /* compress string */
13971ef9f71Sjaap p++;
14071ef9f71Sjaap i++;
14171ef9f71Sjaap }
14271ef9f71Sjaap
14371ef9f71Sjaap sps = EM;
14471ef9f71Sjaap ics = EM * 2;
14571ef9f71Sjaap dtab = 8 * t.Em;
14671ef9f71Sjaap for (i = 0; i < 16; i++)
14771ef9f71Sjaap tabtab[i] = dtab * (i + 1);
14871ef9f71Sjaap pl = 11 * INCH;
14971ef9f71Sjaap po = PO;
15071ef9f71Sjaap spacesz = SS;
15171ef9f71Sjaap lss = lss1 = VS;
15271ef9f71Sjaap ll = ll1 = lt = lt1 = LL;
15371ef9f71Sjaap smnt = nfonts = 5; /* R I B BI S */
15471ef9f71Sjaap specnames(); /* install names like "hyphen", etc. */
15571ef9f71Sjaap if (eqflg)
15671ef9f71Sjaap t.Adj = t.Hor;
15771ef9f71Sjaap }
15871ef9f71Sjaap
skipstr(s)15971ef9f71Sjaap char *skipstr(s) /* skip over leading space plus string */
16071ef9f71Sjaap char *s;
16171ef9f71Sjaap {
16271ef9f71Sjaap while (*s == ' ' || *s == '\t' || *s == '\n')
16371ef9f71Sjaap s++;
16471ef9f71Sjaap while (*s != ' ' && *s != '\t' && *s != '\n')
16571ef9f71Sjaap if (*s++ == '\\')
16671ef9f71Sjaap s++;
16771ef9f71Sjaap return s;
16871ef9f71Sjaap }
16971ef9f71Sjaap
getstr(s,t)17071ef9f71Sjaap char *getstr(s, t) /* find next string in s, copy to t */
17171ef9f71Sjaap char *s, *t;
17271ef9f71Sjaap {
17371ef9f71Sjaap int quote = 0;
17471ef9f71Sjaap
17571ef9f71Sjaap while (*s == ' ' || *s == '\t' || *s == '\n')
17671ef9f71Sjaap s++;
17771ef9f71Sjaap if (*s == '"') {
17871ef9f71Sjaap s++;
17971ef9f71Sjaap quote = 1;
18071ef9f71Sjaap }
18171ef9f71Sjaap for (;;) {
18271ef9f71Sjaap if (quote && *s == '"') {
18371ef9f71Sjaap s++;
18471ef9f71Sjaap break;
18571ef9f71Sjaap }
18671ef9f71Sjaap if (!quote && (*s == ' ' || *s == '\t' || *s == '\n'))
18771ef9f71Sjaap break;
18871ef9f71Sjaap if (*s != '\\')
18971ef9f71Sjaap *t++ = *s++;
19071ef9f71Sjaap else {
19171ef9f71Sjaap s++; /* skip \\ */
19271ef9f71Sjaap if (isdigit(s[0]) && isdigit(s[1]) && isdigit(s[2])) {
19371ef9f71Sjaap *t++ = (s[0]-'0')<<6 | (s[1]-'0')<<3 | s[2]-'0';
19471ef9f71Sjaap s += 2;
19571ef9f71Sjaap } else if (isdigit(s[0])) {
19671ef9f71Sjaap *t++ = *s - '0';
19771ef9f71Sjaap } else if (*s == 'b') {
19871ef9f71Sjaap *t++ = '\b';
19971ef9f71Sjaap } else if (*s == 'n') {
20071ef9f71Sjaap *t++ = '\n';
20171ef9f71Sjaap } else if (*s == 'r') {
20271ef9f71Sjaap *t++ = '\r';
20371ef9f71Sjaap } else if (*s == 't') {
20471ef9f71Sjaap *t++ = '\t';
20571ef9f71Sjaap } else {
20671ef9f71Sjaap *t++ = *s;
20771ef9f71Sjaap }
20871ef9f71Sjaap s++;
20971ef9f71Sjaap }
21071ef9f71Sjaap }
21171ef9f71Sjaap *t = '\0';
21271ef9f71Sjaap return s;
21371ef9f71Sjaap }
21471ef9f71Sjaap
getint(s,pn)21571ef9f71Sjaap char *getint(s, pn) /* find integer at s */
21671ef9f71Sjaap char *s;
21771ef9f71Sjaap int *pn;
21871ef9f71Sjaap {
21971ef9f71Sjaap while (*s == ' ' || *s == '\t' || *s == '\n')
22071ef9f71Sjaap s++;
22171ef9f71Sjaap *pn = 0;
22271ef9f71Sjaap while (isdigit(*s))
22371ef9f71Sjaap *pn = 10 * *pn + *s++ - '0';
22471ef9f71Sjaap return s;
22571ef9f71Sjaap }
22671ef9f71Sjaap
specnames()22771ef9f71Sjaap specnames()
22871ef9f71Sjaap {
22971ef9f71Sjaap static struct {
23071ef9f71Sjaap int *n;
23171ef9f71Sjaap char *v;
23271ef9f71Sjaap } spnames[] = {
23371ef9f71Sjaap &c_hyphen, "hy",
23471ef9f71Sjaap &c_emdash, "em",
23571ef9f71Sjaap &c_rule, "ru",
23671ef9f71Sjaap &c_minus, "\\-",
23771ef9f71Sjaap &c_fi, "fi",
23871ef9f71Sjaap &c_fl, "fl",
23971ef9f71Sjaap &c_ff, "ff",
24071ef9f71Sjaap &c_ffi, "Fi",
24171ef9f71Sjaap &c_ffl, "Fl",
24271ef9f71Sjaap &c_acute, "aa",
24371ef9f71Sjaap &c_grave, "ga",
24471ef9f71Sjaap &c_under, "ul",
24571ef9f71Sjaap &c_rooten, "rn",
24671ef9f71Sjaap &c_boxrule, "br",
24771ef9f71Sjaap &c_lefthand, "lh",
24871ef9f71Sjaap &c_isalnum, "__",
24971ef9f71Sjaap 0, 0
25071ef9f71Sjaap };
25171ef9f71Sjaap int i;
25271ef9f71Sjaap
25371ef9f71Sjaap for (i = 0; spnames[i].n; i++)
25471ef9f71Sjaap *spnames[i].n = findch(spnames[i].v);
25571ef9f71Sjaap if (c_isalnum == 0)
25671ef9f71Sjaap c_isalnum = NROFFCHARS;
25771ef9f71Sjaap }
25871ef9f71Sjaap
25971ef9f71Sjaap
findch(s)26071ef9f71Sjaap findch(s) /* find char s in chname */
26171ef9f71Sjaap register char *s;
26271ef9f71Sjaap {
26371ef9f71Sjaap register int i;
26471ef9f71Sjaap
26571ef9f71Sjaap for (i = 0; chtab[i] != 0; i++)
26671ef9f71Sjaap if (strcmp(s, &chname[chtab[i]]) == 0)
26771ef9f71Sjaap return(i + 128);
26871ef9f71Sjaap return(0);
26971ef9f71Sjaap }
27071ef9f71Sjaap
twdone()27171ef9f71Sjaap twdone()
27271ef9f71Sjaap {
27371ef9f71Sjaap int waitf;
27471ef9f71Sjaap
27571ef9f71Sjaap oputs(t.twrest);
27671ef9f71Sjaap flusho();
27771ef9f71Sjaap if (pipeflg) {
278*cbcd6dcaSkarels close(fileno(ptid));
27971ef9f71Sjaap wait(&waitf);
28071ef9f71Sjaap }
28171ef9f71Sjaap if (ttysave != -1) {
28271ef9f71Sjaap ttys.sg_flags = ttysave;
28371ef9f71Sjaap stty(1, &ttys);
28471ef9f71Sjaap }
28571ef9f71Sjaap }
28671ef9f71Sjaap
28771ef9f71Sjaap
ptout(i)28871ef9f71Sjaap ptout(i)
28971ef9f71Sjaap tchar i;
29071ef9f71Sjaap {
29171ef9f71Sjaap *olinep++ = i;
29271ef9f71Sjaap if (olinep >= &oline[LNSIZE])
29371ef9f71Sjaap olinep--;
29471ef9f71Sjaap if (cbits(i) != '\n')
29571ef9f71Sjaap return;
29671ef9f71Sjaap olinep--;
29771ef9f71Sjaap lead += dip->blss + lss - t.Newline;
29871ef9f71Sjaap dip->blss = 0;
29971ef9f71Sjaap esct = esc = 0;
30071ef9f71Sjaap if (olinep > oline) {
30171ef9f71Sjaap move();
30271ef9f71Sjaap ptout1();
30371ef9f71Sjaap oputs(t.twnl);
30471ef9f71Sjaap } else {
30571ef9f71Sjaap lead += t.Newline;
30671ef9f71Sjaap move();
30771ef9f71Sjaap }
30871ef9f71Sjaap lead += dip->alss;
30971ef9f71Sjaap dip->alss = 0;
31071ef9f71Sjaap olinep = oline;
31171ef9f71Sjaap }
31271ef9f71Sjaap
31371ef9f71Sjaap
ptout1()31471ef9f71Sjaap ptout1()
31571ef9f71Sjaap {
31671ef9f71Sjaap register k;
31771ef9f71Sjaap register char *codep;
31871ef9f71Sjaap extern char *plot();
31971ef9f71Sjaap int w, j, phyw;
32071ef9f71Sjaap tchar * q, i;
32171ef9f71Sjaap static int oxfont = FT; /* start off in roman */
32271ef9f71Sjaap
32371ef9f71Sjaap for (q = oline; q < olinep; q++) {
32471ef9f71Sjaap i = *q;
32571ef9f71Sjaap if (ismot(i)) {
32671ef9f71Sjaap j = absmot(i);
32771ef9f71Sjaap if (isnmot(i))
32871ef9f71Sjaap j = -j;
32971ef9f71Sjaap if (isvmot(i))
33071ef9f71Sjaap lead += j;
33171ef9f71Sjaap else
33271ef9f71Sjaap esc += j;
33371ef9f71Sjaap continue;
33471ef9f71Sjaap }
33571ef9f71Sjaap if ((k = cbits(i)) <= 040) {
33671ef9f71Sjaap switch (k) {
33771ef9f71Sjaap case ' ': /*space*/
33871ef9f71Sjaap esc += t.Char;
33971ef9f71Sjaap break;
34071ef9f71Sjaap case '\033':
34171ef9f71Sjaap case '\007':
34271ef9f71Sjaap case '\016':
34371ef9f71Sjaap case '\017':
34471ef9f71Sjaap oput(k);
34571ef9f71Sjaap break;
34671ef9f71Sjaap }
34771ef9f71Sjaap continue;
34871ef9f71Sjaap }
34971ef9f71Sjaap phyw = w = t.Char * t.width[k];
35071ef9f71Sjaap if (iszbit(i))
35171ef9f71Sjaap w = 0;
35271ef9f71Sjaap if (esc || lead)
35371ef9f71Sjaap move();
35471ef9f71Sjaap esct += w;
35571ef9f71Sjaap xfont = fbits(i);
35671ef9f71Sjaap if (xfont != oxfont) {
35771ef9f71Sjaap switch (oxfont) {
35871ef9f71Sjaap case ULFONT: oputs(t.itoff); break;
35971ef9f71Sjaap case BDFONT: oputs(t.bdoff); break;
36071ef9f71Sjaap case BIFONT: oputs(t.itoff); oputs(t.bdoff); break;
36171ef9f71Sjaap }
36271ef9f71Sjaap switch (xfont) {
36371ef9f71Sjaap case ULFONT:
36471ef9f71Sjaap if (*t.iton & 0377) oputs(t.iton); break;
36571ef9f71Sjaap case BDFONT:
36671ef9f71Sjaap if (*t.bdon & 0377) oputs(t.bdon); break;
36771ef9f71Sjaap case BIFONT:
36871ef9f71Sjaap if (*t.bdon & 0377) oputs(t.bdon);
36971ef9f71Sjaap if (*t.iton & 0377) oputs(t.iton);
37071ef9f71Sjaap break;
37171ef9f71Sjaap }
37271ef9f71Sjaap oxfont = xfont;
37371ef9f71Sjaap }
37471ef9f71Sjaap if ((xfont == ULFONT || xfont == BIFONT) && !(*t.iton & 0377)) {
37571ef9f71Sjaap for (j = w / t.Char; j > 0; j--)
37671ef9f71Sjaap oput('_');
37771ef9f71Sjaap for (j = w / t.Char; j > 0; j--)
37871ef9f71Sjaap oput('\b');
37971ef9f71Sjaap }
38071ef9f71Sjaap if (!(*t.bdon & 0377) && ((j = bdtab[xfont]) || xfont == BDFONT || xfont == BIFONT))
38171ef9f71Sjaap j++;
38271ef9f71Sjaap else
38371ef9f71Sjaap j = 1; /* number of overstrikes for bold */
38471ef9f71Sjaap if (k < 128) { /* ordinary ascii */
38571ef9f71Sjaap oput(k);
38671ef9f71Sjaap while (--j > 0) {
38771ef9f71Sjaap oput('\b');
38871ef9f71Sjaap oput(k);
38971ef9f71Sjaap }
39071ef9f71Sjaap } else {
39171ef9f71Sjaap int oj = j;
39271ef9f71Sjaap codep = t.codetab[k-128];
39371ef9f71Sjaap while (*codep != 0) {
39471ef9f71Sjaap if (*codep & 0200) {
39571ef9f71Sjaap codep = plot(codep);
39671ef9f71Sjaap oput(' ');
39771ef9f71Sjaap } else {
39871ef9f71Sjaap if (*codep == '%') /* escape */
39971ef9f71Sjaap codep++;
40071ef9f71Sjaap oput(*codep);
40171ef9f71Sjaap if (*codep != '\b')
40271ef9f71Sjaap for (j = oj; --j > 0; ) {
40371ef9f71Sjaap oput('\b');
40471ef9f71Sjaap oput(*codep);
40571ef9f71Sjaap }
40671ef9f71Sjaap codep++;
40771ef9f71Sjaap }
40871ef9f71Sjaap }
40971ef9f71Sjaap }
41071ef9f71Sjaap if (!w)
41171ef9f71Sjaap for (j = phyw / t.Char; j > 0; j--)
41271ef9f71Sjaap oput('\b');
41371ef9f71Sjaap }
41471ef9f71Sjaap }
41571ef9f71Sjaap
41671ef9f71Sjaap
plot(x)41771ef9f71Sjaap char *plot(x)
41871ef9f71Sjaap char *x;
41971ef9f71Sjaap {
42071ef9f71Sjaap register int i;
42171ef9f71Sjaap register char *j, *k;
42271ef9f71Sjaap
42371ef9f71Sjaap oputs(t.ploton);
42471ef9f71Sjaap k = x;
42571ef9f71Sjaap if ((*k & 0377) == 0200)
42671ef9f71Sjaap k++;
42771ef9f71Sjaap for (; *k; k++) {
42871ef9f71Sjaap if (*k == '%') { /* quote char within plot mode */
42971ef9f71Sjaap oput(*++k);
43071ef9f71Sjaap } else if (*k & 0200) {
43171ef9f71Sjaap if (*k & 0100) {
43271ef9f71Sjaap if (*k & 040)
43371ef9f71Sjaap j = t.up;
43471ef9f71Sjaap else
43571ef9f71Sjaap j = t.down;
43671ef9f71Sjaap } else {
43771ef9f71Sjaap if (*k & 040)
43871ef9f71Sjaap j = t.left;
43971ef9f71Sjaap else
44071ef9f71Sjaap j = t.right;
44171ef9f71Sjaap }
44271ef9f71Sjaap if ((i = *k & 037) == 0) { /* 2nd 0200 turns it off */
44371ef9f71Sjaap ++k;
44471ef9f71Sjaap break;
44571ef9f71Sjaap }
44671ef9f71Sjaap while (i--)
44771ef9f71Sjaap oputs(j);
44871ef9f71Sjaap } else
44971ef9f71Sjaap oput(*k);
45071ef9f71Sjaap }
45171ef9f71Sjaap oputs(t.plotoff);
45271ef9f71Sjaap return(k);
45371ef9f71Sjaap }
45471ef9f71Sjaap
45571ef9f71Sjaap
move()45671ef9f71Sjaap move()
45771ef9f71Sjaap {
45871ef9f71Sjaap register k;
45971ef9f71Sjaap register char *i, *j;
46071ef9f71Sjaap char *p, *q;
46171ef9f71Sjaap int iesct, dt;
46271ef9f71Sjaap
46371ef9f71Sjaap iesct = esct;
46471ef9f71Sjaap if (esct += esc)
46571ef9f71Sjaap i = "\0";
46671ef9f71Sjaap else
46771ef9f71Sjaap i = "\n\0";
46871ef9f71Sjaap j = t.hlf;
46971ef9f71Sjaap p = t.right;
47071ef9f71Sjaap q = t.down;
47171ef9f71Sjaap if (lead) {
47271ef9f71Sjaap if (lead < 0) {
47371ef9f71Sjaap lead = -lead;
47471ef9f71Sjaap i = t.flr;
47571ef9f71Sjaap /* if(!esct)i = t.flr; else i = "\0";*/
47671ef9f71Sjaap j = t.hlr;
47771ef9f71Sjaap q = t.up;
47871ef9f71Sjaap }
47971ef9f71Sjaap if (*i & 0377) {
48071ef9f71Sjaap k = lead / t.Newline;
48171ef9f71Sjaap lead = lead % t.Newline;
48271ef9f71Sjaap while (k--)
48371ef9f71Sjaap oputs(i);
48471ef9f71Sjaap }
48571ef9f71Sjaap if (*j & 0377) {
48671ef9f71Sjaap k = lead / t.Halfline;
48771ef9f71Sjaap lead = lead % t.Halfline;
48871ef9f71Sjaap while (k--)
48971ef9f71Sjaap oputs(j);
49071ef9f71Sjaap } else { /* no half-line forward, not at line begining */
49171ef9f71Sjaap k = lead / t.Newline;
49271ef9f71Sjaap lead = lead % t.Newline;
49371ef9f71Sjaap if (k > 0)
49471ef9f71Sjaap esc = esct;
49571ef9f71Sjaap i = "\n";
49671ef9f71Sjaap while (k--)
49771ef9f71Sjaap oputs(i);
49871ef9f71Sjaap }
49971ef9f71Sjaap }
50071ef9f71Sjaap if (esc) {
50171ef9f71Sjaap if (esc < 0) {
50271ef9f71Sjaap esc = -esc;
50371ef9f71Sjaap j = "\b";
50471ef9f71Sjaap p = t.left;
50571ef9f71Sjaap } else {
50671ef9f71Sjaap j = " ";
50771ef9f71Sjaap if (hflg)
50871ef9f71Sjaap while ((dt = dtab - (iesct % dtab)) <= esc) {
50971ef9f71Sjaap if (dt % t.Em)
51071ef9f71Sjaap break;
51171ef9f71Sjaap oput(TAB);
51271ef9f71Sjaap esc -= dt;
51371ef9f71Sjaap iesct += dt;
51471ef9f71Sjaap }
51571ef9f71Sjaap }
51671ef9f71Sjaap k = esc / t.Em;
51771ef9f71Sjaap esc = esc % t.Em;
51871ef9f71Sjaap while (k--)
51971ef9f71Sjaap oputs(j);
52071ef9f71Sjaap }
52171ef9f71Sjaap if ((*t.ploton & 0377) && (esc || lead)) {
52271ef9f71Sjaap oputs(t.ploton);
52371ef9f71Sjaap esc /= t.Hor;
52471ef9f71Sjaap lead /= t.Vert;
52571ef9f71Sjaap while (esc--)
52671ef9f71Sjaap oputs(p);
52771ef9f71Sjaap while (lead--)
52871ef9f71Sjaap oputs(q);
52971ef9f71Sjaap oputs(t.plotoff);
53071ef9f71Sjaap }
53171ef9f71Sjaap esc = lead = 0;
53271ef9f71Sjaap }
53371ef9f71Sjaap
53471ef9f71Sjaap
ptlead()53571ef9f71Sjaap ptlead()
53671ef9f71Sjaap {
53771ef9f71Sjaap move();
53871ef9f71Sjaap }
53971ef9f71Sjaap
54071ef9f71Sjaap
dostop()54171ef9f71Sjaap dostop()
54271ef9f71Sjaap {
54371ef9f71Sjaap char junk;
54471ef9f71Sjaap
54571ef9f71Sjaap flusho();
54671ef9f71Sjaap read(2, &junk, 1);
54771ef9f71Sjaap }
54871ef9f71Sjaap
54971ef9f71Sjaap
newpage()55071ef9f71Sjaap newpage(){;}
pttrailer()55171ef9f71Sjaap pttrailer(){;}
552