ref: 0d691c38d6f30f1acaf8c2d2c710ad0648208c4b
dir: /ren.c/
/* rendering lines and managing traps */
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "roff.h"
#define NOPAGE 0x40000000 /* undefined bp_next */
#define cfmt env_fmt() /* current formatter */
#define cwb env_wb() /* current word buffer */
/* diversions */
struct div {
struct sbuf sbuf; /* diversion output */
int reg; /* diversion register */
int tpos; /* diversion trap position */
int treg; /* diversion trap register */
int dl; /* diversion width */
int prev_d; /* previous \n(.d value */
int prev_h; /* previous \n(.h value */
int prev_mk; /* previous .mk internal register */
int prev_ns; /* previous .ns value */
};
static struct div divs[NPREV]; /* diversion stack */
static struct div *cdiv; /* current diversion */
static int ren_div; /* rendering a diversion */
static int ren_divvs; /* the amount of .v in diversions */
static int trap_em = -1; /* end macro */
static int ren_nl; /* just after a newline */
static int ren_partial; /* reading an input line in render_rec() */
static int ren_unbuf[8]; /* ren_back() buffer */
static int ren_un;
static int ren_aborted; /* .ab executed */
static int bp_first = 1; /* prior to the first page */
static int bp_next = NOPAGE; /* next page number */
static int bp_ejected; /* current ejected page */
static int bp_final; /* 1: executing em, 2: the final page, 3: the 2nd final page */
static int ren_level; /* the depth of render_rec() calls */
static char c_fa[GNLEN]; /* field delimiter */
static char c_fb[GNLEN]; /* field padding */
static int ren_next(void)
{
return ren_un > 0 ? ren_unbuf[--ren_un] : tr_next();
}
static void ren_back(int c)
{
ren_unbuf[ren_un++] = c;
}
void tr_di(char **args)
{
if (args[1]) {
cdiv = cdiv ? cdiv + 1 : divs;
memset(cdiv, 0, sizeof(*cdiv));
sbuf_init(&cdiv->sbuf);
cdiv->reg = map(args[1]);
cdiv->treg = -1;
if (args[0][2] == 'a' && str_get(cdiv->reg)) /* .da */
sbuf_append(&cdiv->sbuf, str_get(cdiv->reg));
sbuf_printf(&cdiv->sbuf, "%c%s\n", c_cc, TR_DIVBEG);
cdiv->prev_d = n_d;
cdiv->prev_h = n_h;
cdiv->prev_mk = n_mk;
cdiv->prev_ns = n_ns;
n_d = 0;
n_h = 0;
n_mk = 0;
n_ns = 0;
} else if (cdiv) {
sbuf_printf(&cdiv->sbuf, "%c%s\n", c_cc, TR_DIVEND);
str_set(cdiv->reg, sbuf_buf(&cdiv->sbuf));
sbuf_done(&cdiv->sbuf);
n_dl = cdiv->dl;
n_dn = n_d;
n_d = cdiv->prev_d;
n_h = cdiv->prev_h;
n_mk = cdiv->prev_mk;
n_ns = cdiv->prev_ns;
cdiv = cdiv > divs ? cdiv - 1 : NULL;
}
}
int f_divreg(void)
{
return cdiv ? cdiv->reg : -1;
}
int f_hpos(void)
{
return fmt_wid(cfmt) + wb_wid(cwb);
}
void tr_divbeg(char **args)
{
odiv_beg();
ren_div++;
}
void tr_divend(char **args)
{
if (ren_div <= 0)
errdie("neatroff: diversion stack empty\n");
odiv_end();
ren_div--;
}
void tr_divvs(char **args)
{
ren_divvs = eval(args[1], 'u');
}
void tr_transparent(char **args)
{
if (cdiv)
sbuf_printf(&cdiv->sbuf, "%s\n", args[1]);
else
out("%s\n", args[1]);
}
static int trap_reg(int pos);
static int trap_pos(int pos);
static void trap_exec(int reg);
static void ren_page(int force)
{
if (!force && bp_final >= 2)
return;
n_nl = 0;
n_d = 0;
n_h = 0;
n_pg = bp_next != NOPAGE ? bp_next : n_pg + 1;
bp_next = NOPAGE;
n_PG += 1;
out("p%d\n", n_PG);
out("V%d\n", 0);
if (trap_pos(-1) == 0)
trap_exec(trap_reg(-1));
}
static int ren_first(void)
{
if (bp_first && !cdiv) {
bp_first = 0;
ren_page(1);
return 0;
}
return 1;
}
/* when nodiv, do not append .sp to diversions */
static void ren_sp(int n, int nodiv)
{
int linevs = !n; /* the vertical spacing before a line */
ren_first();
if (!n && ren_div && ren_divvs && !n_u)
n = ren_divvs; /* .v at the time of diversion */
ren_divvs = 0;
n_ns = 0;
n_d += n ? n : n_v;
if (n_d > n_h)
n_h = n_d;
if (cdiv && !nodiv) {
if (linevs)
sbuf_printf(&cdiv->sbuf, "%c%s %du\n", c_cc, TR_DIVVS, n_v);
else
sbuf_printf(&cdiv->sbuf, "%csp %du\n", c_cc, n ? n : n_v);
}
if (!cdiv)
n_nl = n_d;
}
static int render_rec(int level);
static void trap_exec(int reg)
{
char cmd[16];
int partial = ren_partial && (!ren_un || ren_unbuf[0] != '\n');
if (str_get(reg)) {
sprintf(cmd, "%c%s %d\n", c_cc, TR_POPREN, ren_level);
in_push(cmd, NULL);
in_push(str_get(reg), NULL);
if (partial)
in_push("\n", NULL);
render_rec(++ren_level);
/* executed the trap while in the middle of an input line */
if (partial)
fmt_suppressnl(cfmt);
}
}
static int detect_traps(int beg, int end)
{
int pos = trap_pos(beg);
return pos >= 0 && (cdiv || pos < n_p) && pos <= end;
}
/* return 1 if executed a trap */
static int ren_traps(int beg, int end, int dosp)
{
int pos = trap_pos(beg);
if (detect_traps(beg, end)) {
if (dosp && pos > beg)
ren_sp(pos - beg, 0);
trap_exec(trap_reg(beg));
return 1;
}
return 0;
}
static int detect_pagelimit(int ne)
{
return !cdiv && n_nl + ne >= n_p;
}
/* start a new page if needed */
static int ren_pagelimit(int ne)
{
if (detect_pagelimit(ne)) {
ren_page(0);
return 1;
}
return 0;
}
/* return 1 if triggered a trap */
static int down(int n)
{
if (ren_traps(n_d, n_d + (n ? n : n_v), 1))
return 1;
ren_sp(MAX(n, -n_d), 0);
return ren_pagelimit(0);
}
/* line adjustment */
static int ren_ljust(struct sbuf *spre, int w, int ad, int li, int lI, int ll)
{
int ljust = li;
int llen = ll - lI - li;
n_n = w;
if ((ad & AD_B) == AD_C)
ljust += llen > w ? (llen - w) / 2 : 0;
if ((ad & AD_B) == AD_R)
ljust += llen - w;
if (ljust)
sbuf_printf(spre, "%ch'%du'", c_ec, ljust);
if (cdiv && cdiv->dl < w + ljust)
cdiv->dl = w + ljust;
return ljust;
}
/* append the line to the current diversion or send it to out.c */
static void ren_out(char *beg, char *mid, char *end)
{
if (cdiv) {
sbuf_append(&cdiv->sbuf, beg);
sbuf_append(&cdiv->sbuf, mid);
sbuf_append(&cdiv->sbuf, end);
sbuf_append(&cdiv->sbuf, "\n");
} else {
out("H%d\n", n_o);
out("V%d\n", n_d);
out_line(beg);
out_line(mid);
out_line(end);
}
}
static void ren_dir(struct sbuf *sbuf)
{
struct sbuf fixed;
sbuf_init(&fixed);
dir_fix(&fixed, sbuf_buf(sbuf));
sbuf_done(sbuf);
sbuf_init(sbuf);
sbuf_append(sbuf, sbuf_buf(&fixed));
sbuf_done(&fixed);
}
static int zwid(void)
{
struct glyph *g = dev_glyph("0", n_f);
return g ? font_gwid(g->font, dev_font(n_f), n_s, g->wid) : 0;
}
/* append the line number to the output line */
static void ren_lnum(struct sbuf *spre)
{
char num[16] = "";
char dig[16] = "";
struct wb wb;
int i = 0;
wb_init(&wb);
if (n_nn <= 0 && (n_ln % n_nM) == 0)
sprintf(num, "%d", n_ln);
wb_hmov(&wb, n_nI * zwid());
if (strlen(num) < 3)
wb_hmov(&wb, (3 - strlen(num)) * zwid());
while (num[i]) {
dig[0] = num[i++];
wb_put(&wb, dig);
}
wb_hmov(&wb, n_nS * zwid());
sbuf_append(spre, wb_buf(&wb));
wb_done(&wb);
if (n_nn > 0)
n_nn--;
else
n_ln++;
}
/* append margin character */
static void ren_mc(struct sbuf *sbuf, int w, int ljust)
{
struct wb wb;
wb_init(&wb);
if (w + ljust < n_l + n_mcn)
wb_hmov(&wb, n_l + n_mcn - w - ljust);
wb_putexpand(&wb, c_mc);
sbuf_append(sbuf, wb_buf(&wb));
wb_done(&wb);
}
/* process a line and print it with ren_out() */
static int ren_line(char *line, int w, int ad, int body,
int li, int lI, int ll, int els_neg, int els_pos)
{
struct sbuf sbeg, send, sbuf;
int prev_d, lspc, ljust;
ren_first();
sbuf_init(&sbeg);
sbuf_init(&send);
sbuf_init(&sbuf);
sbuf_append(&sbuf, line);
lspc = MAX(1, n_L) * n_v; /* line space, ignoreing \x */
prev_d = n_d;
if (!n_ns || line[0] || els_neg || els_pos) {
if (els_neg)
ren_sp(-els_neg, 1);
ren_sp(0, 0);
if (line[0] && n_nm && body)
ren_lnum(&sbeg);
if (!ren_div && dir_do)
ren_dir(&sbuf);
ljust = ren_ljust(&sbeg, w, ad, li, lI, ll);
if (line[0] && body && n_mc)
ren_mc(&send, w, ljust);
ren_out(sbuf_buf(&sbeg), sbuf_buf(&sbuf), sbuf_buf(&send));
n_ns = 0;
if (els_pos)
ren_sp(els_pos, 1);
}
sbuf_done(&sbeg);
sbuf_done(&send);
sbuf_done(&sbuf);
n_a = els_pos;
if (detect_traps(prev_d, n_d) || detect_pagelimit(lspc - n_v)) {
if (!ren_pagelimit(lspc - n_v))
ren_traps(prev_d, n_d, 0);
return 1;
}
if (lspc - n_v && down(lspc - n_v))
return 1;
return 0;
}
/* read a line from fmt and send it to ren_line() */
static int ren_passline(struct fmt *fmt)
{
char *buf;
int ll, li, lI, els_neg, els_pos, w, ret;
int ad = n_j;
ren_first();
if (!fmt_morewords(fmt))
return 0;
buf = fmt_nextline(fmt, &w, &li, &lI, &ll, &els_neg, &els_pos);
if ((n_cp && !n_u) || n_na)
ad = AD_L;
else if ((ad & AD_B) == AD_B)
ad = n_td > 0 ? AD_R : AD_L;
if (n_ce)
ad = AD_C;
ret = ren_line(buf, w, ad, 1, li, lI, ll, els_neg, els_pos);
free(buf);
return ret;
}
/* output formatted lines in fmt */
static int ren_fmtpop(struct fmt *fmt)
{
int ret = 0;
while (fmt_morelines(fmt))
ret = ren_passline(fmt);
return ret;
}
/* format and output all lines in fmt */
static void ren_fmtpopall(struct fmt *fmt)
{
while (fmt_fill(fmt, 0))
ren_fmtpop(fmt);
ren_fmtpop(fmt);
}
/* pass the given word buffer to the current line buffer (cfmt) */
static void ren_fmtword(struct wb *wb)
{
while (fmt_word(cfmt, wb))
ren_fmtpop(cfmt);
wb_reset(wb);
}
/* output current line; returns 1 if triggered a trap */
static int ren_br(void)
{
ren_first();
ren_fmtword(cwb);
while (fmt_fill(cfmt, 1))
ren_fmtpop(cfmt);
return ren_fmtpop(cfmt);
}
void tr_br(char **args)
{
if (args[0][0] == c_cc)
ren_br();
else
ren_fmtpopall(cfmt); /* output the completed lines */
}
void tr_sp(char **args)
{
int traps = 0;
int n;
if (args[0][0] == c_cc)
traps = ren_br();
n = args[1] ? eval(args[1], 'v') : n_v;
if (n && (!n_ns || ren_div) && !traps)
down(n);
}
void tr_sv(char **args)
{
int n = eval(args[1], 'v');
n_sv = 0;
if (n_d + n < f_nexttrap())
down(n);
else
n_sv = n;
}
void tr_ns(char **args)
{
n_ns = 1;
}
void tr_rs(char **args)
{
n_ns = 0;
}
void tr_os(char **args)
{
if (n_sv)
down(n_sv);
n_sv = 0;
}
void tr_mk(char **args)
{
if (args[1])
num_set(map(args[1]), n_d);
else
n_mk = n_d;
}
void tr_rt(char **args)
{
int n = args[1] ? eval_re(args[1], n_d, 'v') : n_mk;
if (n >= 0 && n < n_d)
ren_sp(n - n_d, 0);
}
void tr_ne(char **args)
{
int n = args[1] ? eval(args[1], 'v') : n_v;
if (!ren_first())
return;
if (!ren_traps(n_d, n_d + n - 1, 1))
ren_pagelimit(n);
}
static void ren_ejectpage(int br)
{
ren_first();
bp_ejected = n_PG;
if (br)
ren_br();
while (n_PG == bp_ejected && !cdiv) {
if (detect_traps(n_d, n_p)) {
ren_traps(n_d, n_p, 1);
} else {
bp_ejected = 0;
ren_page(0);
}
}
}
void tr_bp(char **args)
{
if (!cdiv && (args[1] || !n_ns)) {
if (args[1])
bp_next = eval_re(args[1], n_pg, 0);
ren_ejectpage(args[0][0] == c_cc);
}
}
void tr_pn(char **args)
{
if (args[1])
bp_next = eval_re(args[1], n_pg, 0);
}
static void ren_ps(char *s)
{
int ps = !s || !*s || !strcmp("0", s) ?
n_s0 * SC_PT : eval_re(s, n_s * SC_PT, 'p');
n_s0 = n_s;
n_s = MAX(1, (ps + SC_PT / 2) / SC_PT);
}
void tr_ps(char **args)
{
ren_ps(args[1]);
}
void tr_ll(char **args)
{
int ll = args[1] ? eval_re(args[1], n_l, 'm') : n_l0;
n_l0 = n_l;
n_l = MAX(0, ll);
}
void tr_in(char **args)
{
int in = args[1] ? eval_re(args[1], n_i, 'm') : n_i0;
if (args[0][0] == c_cc)
ren_br();
n_i0 = n_i;
n_i = MAX(0, in);
n_ti = -1;
}
void tr_ti(char **args)
{
if (args[0][0] == c_cc)
ren_br();
if (args[1])
n_ti = eval_re(args[1], n_i, 'm');
}
void tr_l2r(char **args)
{
dir_do = 1;
if (args[0][0] == c_cc)
ren_br();
n_td = 0;
n_cd = 0;
}
void tr_r2l(char **args)
{
dir_do = 1;
if (args[0][0] == c_cc)
ren_br();
n_td = 1;
n_cd = 1;
}
void tr_in2(char **args)
{
int I = args[1] ? eval_re(args[1], n_I, 'm') : n_I0;
if (args[0][0] == c_cc)
ren_br();
n_I0 = n_I;
n_I = MAX(0, I);
n_tI = -1;
}
void tr_ti2(char **args)
{
if (args[0][0] == c_cc)
ren_br();
if (args[1])
n_tI = eval_re(args[1], n_I, 'm');
}
static void ren_ft(char *s)
{
int fn = !s || !*s || !strcmp("P", s) ? n_f0 : dev_pos(s);
if (fn < 0) {
errmsg("neatroff: failed to mount <%s>\n", s);
} else {
n_f0 = n_f;
n_f = fn;
}
}
void tr_ft(char **args)
{
ren_ft(args[1]);
}
void tr_fp(char **args)
{
int pos;
if (!args[2])
return;
pos = isdigit((unsigned char) args[1][0]) ? atoi(args[1]) : -1;
if (dev_mnt(pos, args[2], args[3] ? args[3] : args[2]) < 0)
errmsg("neatroff: failed to mount <%s>\n", args[2]);
}
void tr_nf(char **args)
{
if (args[0][0] == c_cc)
ren_br();
n_u = 0;
}
void tr_fi(char **args)
{
if (args[0][0] == c_cc)
ren_br();
n_u = 1;
}
void tr_ce(char **args)
{
if (args[0][0] == c_cc)
ren_br();
n_ce = args[1] ? atoi(args[1]) : 1;
}
void tr_fc(char **args)
{
char *fa = args[1];
char *fb = args[2];
if (fa && charread(&fa, c_fa) >= 0) {
if (!fb || charread(&fb, c_fb) < 0)
strcpy(c_fb, " ");
} else {
c_fa[0] = '\0';
c_fb[0] = '\0';
}
}
static void ren_cl(char *s)
{
int m = !s || !*s ? n_m0 : clr_get(s);
n_m0 = n_m;
n_m = m;
}
void tr_cl(char **args)
{
ren_cl(args[1]);
}
void tr_ab(char **args)
{
fprintf(stderr, "%s\n", args[1]);
ren_aborted = 1;
}
static void ren_cmd(struct wb *wb, int c, char *arg)
{
switch (c) {
case ' ':
wb_hmov(wb, font_swid(dev_font(n_f), n_s, n_ss));
break;
case 'b':
ren_bcmd(wb, arg);
break;
case 'c':
wb_setpart(wb);
break;
case 'D':
ren_dcmd(wb, arg);
break;
case 'd':
wb_vmov(wb, SC_EM / 2);
break;
case 'f':
ren_ft(arg);
break;
case 'h':
wb_hmov(wb, eval(arg, 'm'));
break;
case 'j':
wb_setcost(wb, eval(arg, 0));
break;
case 'k':
num_set(map(arg), wb == cwb ? f_hpos() - n_lb : wb_wid(wb));
break;
case 'L':
ren_vlcmd(wb, arg);
break;
case 'l':
ren_hlcmd(wb, arg);
break;
case 'm':
ren_cl(arg);
break;
case 'o':
ren_ocmd(wb, arg);
break;
case 'p':
if (wb == cwb)
while (fmt_fillreq(cfmt))
ren_fmtpop(cfmt);
break;
case 'r':
wb_vmov(wb, -SC_EM);
break;
case 's':
ren_ps(arg);
break;
case 'u':
wb_vmov(wb, -SC_EM / 2);
break;
case 'v':
wb_vmov(wb, eval(arg, 'v'));
break;
case 'X':
wb_etc(wb, arg);
break;
case 'x':
wb_els(wb, eval(arg, 'v'));
break;
case 'Z':
ren_zcmd(wb, arg);
break;
case '0':
wb_hmov(wb, zwid());
break;
case '|':
wb_hmov(wb, SC_EM / 6);
break;
case '&':
wb_hmov(wb, 0);
break;
case '^':
wb_hmov(wb, SC_EM / 12);
break;
case '/':
wb_italiccorrection(wb);
break;
case ',':
wb_italiccorrectionleft(wb);
break;
case '<':
case '>':
n_cd = c == '<';
wb_flushdir(wb);
break;
}
}
static void ren_field(struct wb *wb, int (*next)(void), void (*back)(int));
static void ren_tab(struct wb *wb, char *tc, int (*next)(void), void (*back)(int));
/* insert a character, escape sequence, field or etc into wb */
static void ren_put(struct wb *wb, char *c, int (*next)(void), void (*back)(int))
{
int w;
if (c[0] == ' ' || c[0] == '\n') {
wb_put(wb, c);
return;
}
if (c[0] == '\t' || c[0] == '') {
ren_tab(wb, c[0] == '\t' ? c_tc : c_lc, next, back);
return;
}
if (c_fa[0] && !strcmp(c_fa, c)) {
ren_field(wb, next, back);
return;
}
if (c[0] == c_ec) {
if (c[1] == 'z') {
w = wb_wid(wb);
ren_char(wb, next, back);
wb_hmov(wb, w - wb_wid(wb));
return;
}
if (strchr(" bCcDdefHhjkLlmNoprSsuvXxZz0^|!{}&/,<>", c[1])) {
char *arg = NULL;
if (strchr(ESC_P, c[1]))
arg = unquotednext(c[1], next, back);
if (strchr(ESC_Q, c[1]))
arg = quotednext(next, back);
if (c[1] == 'e') {
snprintf(c, GNLEN, "%c%c", c_ec, c_ec);
} else if (c[1] == 'N') {
snprintf(c, GNLEN, "GID=%s", arg);
} else {
ren_cmd(wb, c[1], arg);
free(arg);
return;
}
free(arg);
}
}
if (ren_div) {
wb_putraw(wb, c);
return;
}
if (cdef_map(c, n_f)) /* .char characters */
wb_putexpand(wb, c);
else
wb_put(wb, c);
}
/* read one character and place it inside wb buffer */
int ren_char(struct wb *wb, int (*next)(void), void (*back)(int))
{
char c[GNLEN * 4];
if (charnext(c, next, back) < 0)
return -1;
ren_put(wb, c, next, back);
return 0;
}
/* like ren_char(); return 1 if d1 was read and 2 if d2 was read */
static int ren_chardel(struct wb *wb, int (*next)(void), void (*back)(int),
char *d1, char *d2)
{
char c[GNLEN * 4];
if (charnext(c, next, back) < 0)
return -1;
if (d1 && !strcmp(d1, c))
return 1;
if (d2 && !strcmp(d2, c))
return 2;
ren_put(wb, c, next, back);
return 0;
}
/* read the argument of \w and push its width */
int ren_wid(int (*next)(void), void (*back)(int))
{
char delim[GNLEN];
int c, n;
struct wb wb;
wb_init(&wb);
charnext(delim, next, back);
odiv_beg();
c = next();
while (c >= 0 && c != '\n') {
back(c);
if (ren_chardel(&wb, next, back, delim, NULL))
break;
c = next();
}
odiv_end();
n = wb_wid(&wb);
wb_wconf(&wb, &n_ct, &n_st, &n_sb, &n_llx, &n_lly, &n_urx, &n_ury);
wb_done(&wb);
return n;
}
/* return 1 if d1 was read and 2 if d2 was read */
static int ren_until(struct wb *wb, int (*next)(void), void (*back)(int),
char *d1, char *d2)
{
int c, ret;
c = next();
while (c >= 0 && c != '\n') {
back(c);
ret = ren_chardel(wb, next, back, d1, d2);
if (ret)
return ret;
c = next();
}
if (c == '\n')
back(c);
return 0;
}
/* like ren_until(); map src to dst */
static int ren_untilmap(struct wb *wb, int (*next)(void), void (*back)(int),
char *end, char *src, char *dst)
{
int ret;
while ((ret = ren_until(wb, next, back, src, end)) == 1) {
sstr_push(dst);
ren_until(wb, sstr_next, sstr_back, end, NULL);
sstr_pop();
}
return 0;
}
static void wb_cpy(struct wb *dst, struct wb *src, int left)
{
wb_hmov(dst, left - wb_wid(dst));
wb_cat(dst, src);
}
void ren_tl(int (*next)(void), void (*back)(int))
{
struct wb wb, wb2;
char *pgnum;
char delim[GNLEN];
ren_first();
pgnum = num_str(map("%"));
wb_init(&wb);
wb_init(&wb2);
charnext(delim, next, back);
if (!strcmp("\n", delim))
back('\n');
/* the left-adjusted string */
ren_untilmap(&wb2, next, back, delim, c_pc, pgnum);
wb_cpy(&wb, &wb2, 0);
/* the centered string */
ren_untilmap(&wb2, next, back, delim, c_pc, pgnum);
wb_cpy(&wb, &wb2, (n_lt - wb_wid(&wb2)) / 2);
/* the right-adjusted string */
ren_untilmap(&wb2, next, back, delim, c_pc, pgnum);
wb_cpy(&wb, &wb2, n_lt - wb_wid(&wb2));
/* flushing the line */
ren_line(wb_buf(&wb), wb_wid(&wb), AD_L, 0,
0, 0, n_lt, wb.els_neg, wb.els_pos);
wb_done(&wb2);
wb_done(&wb);
}
static void ren_field(struct wb *wb, int (*next)(void), void (*back)(int))
{
struct wb wbs[NFIELDS];
int i, n = 0;
int wid = 0;
int left, right, cur_left;
int pad, rem;
while (n < LEN(wbs)) {
wb_init(&wbs[n]);
if (ren_until(&wbs[n++], next, back, c_fb, c_fa) != 1)
break;
}
left = wb == cwb ? f_hpos() : wb_wid(wb);
right = tab_next(left);
for (i = 0; i < n; i++)
wid += wb_wid(&wbs[i]);
pad = (right - left - wid) / (n > 1 ? n - 1 : 1);
rem = (right - left - wid) % (n > 1 ? n - 1 : 1);
for (i = 0; i < n; i++) {
if (i == 0)
cur_left = left;
else if (i == n - 1)
cur_left = right - wb_wid(&wbs[i]);
else
cur_left = wb_wid(wb) + pad + (i + rem >= n);
wb_cpy(wb, &wbs[i], cur_left);
wb_done(&wbs[i]);
}
}
static void ren_tab(struct wb *wb, char *tc, int (*next)(void), void (*back)(int))
{
struct wb t;
int pos = wb == cwb ? f_hpos() : wb_wid(wb);
int ins = tab_next(pos); /* insertion position */
int typ = tab_type(pos); /* tab type */
int c;
wb_init(&t);
if (typ == 'R' || typ == 'C') {
c = next();
while (c >= 0 && c != '\n' && c != '\t' && c != '') {
back(c);
ren_char(&t, next, back);
c = next();
}
back(c);
}
if (typ == 'C')
ins -= wb_wid(&t) / 2;
if (typ == 'R')
ins -= wb_wid(&t);
if (!tc[0] || ins <= pos)
wb_hmov(wb, ins - pos);
else
ren_hline(wb, ins - pos, tc);
wb_cat(wb, &t);
wb_done(&t);
}
/* parse characters and troff requests of s and append them to wb */
int ren_parse(struct wb *wb, char *s)
{
int c;
odiv_beg();
sstr_push(s);
c = sstr_next();
while (c >= 0) {
sstr_back(c);
if (ren_char(wb, sstr_next, sstr_back))
break;
c = sstr_next();
}
sstr_pop();
odiv_end();
return 0;
}
/* cause nested render_rec() to exit */
void tr_popren(char **args)
{
ren_level = args[1] ? atoi(args[1]) : 0;
}
#define FMT_PAR() (n_u && !n_na && !n_ce && (n_j & AD_P) == AD_P)
/* read characters from tr.c and pass the rendered lines to out.c */
static int render_rec(int level)
{
int c;
while (ren_level >= level) {
while (!ren_un && !tr_nextreq())
if (ren_level < level)
break;
if (ren_level < level)
break;
if (ren_aborted)
return 1;
c = ren_next();
if (c < 0) {
if (bp_final >= 2)
break;
if (bp_final == 0) {
bp_final = 1;
if (trap_em >= 0)
trap_exec(trap_em);
} else {
bp_final = 2;
ren_ejectpage(1);
}
}
if (c >= 0)
ren_partial = c != '\n';
/* add cwb (the current word) to cfmt */
if (c == ' ' || c == '\n') {
if (!wb_part(cwb)) { /* not after a \c */
ren_fmtword(cwb);
if (c == '\n')
while (fmt_newline(cfmt))
ren_fmtpop(cfmt);
if (!FMT_PAR())
ren_fmtpopall(cfmt);
if (c == ' ')
fmt_space(cfmt);
}
}
/* flush the line if necessary */
if (c == ' ' || c == '\n' || c < 0)
ren_fmtpop(cfmt);
if (c == '\n' || ren_nl) /* end or start of input line */
n_lb = f_hpos();
if (c == '\n' && n_it && --n_itn == 0)
trap_exec(n_it);
if (c == '\n' && !wb_part(cwb))
n_ce = MAX(0, n_ce - 1);
if (c != ' ' && c >= 0) {
ren_back(c);
ren_char(cwb, ren_next, ren_back);
}
if (c >= 0)
ren_nl = c == '\n';
}
return 0;
}
/* render input words */
int render(void)
{
n_nl = -1;
while (!tr_nextreq())
;
ren_first(); /* transition to the first page */
render_rec(0);
bp_final = 3;
if (fmt_morewords(cfmt))
ren_page(1);
ren_br();
return 0;
}
/* trap handling */
#define tposval(i) (tpos[i] < 0 ? n_p + tpos[i] : tpos[i])
static int tpos[NTRAPS]; /* trap positions */
static int treg[NTRAPS]; /* trap registers */
static int ntraps;
static int trap_first(int pos)
{
int best = -1;
int i;
for (i = 0; i < ntraps; i++)
if (treg[i] >= 0 && tposval(i) > pos)
if (best < 0 || tposval(i) < tposval(best))
best = i;
return best;
}
static int trap_byreg(int reg)
{
int i;
for (i = 0; i < ntraps; i++)
if (treg[i] == reg)
return i;
return -1;
}
static int trap_bypos(int reg, int pos)
{
int i;
for (i = 0; i < ntraps; i++)
if (treg[i] >= 0 && tposval(i) == pos)
if (reg == -1 || treg[i] == reg)
return i;
return -1;
}
void tr_wh(char **args)
{
int reg, pos, id;
if (!args[1])
return;
pos = eval(args[1], 'v');
id = trap_bypos(-1, pos);
if (!args[2]) {
if (id >= 0)
treg[id] = -1;
return;
}
reg = map(args[2]);
if (id < 0) /* find an unused position in treg[] */
id = trap_byreg(-1);
if (id < 0)
id = ntraps++;
tpos[id] = pos;
treg[id] = reg;
}
void tr_ch(char **args)
{
int reg;
int id;
if (!args[1])
return;
reg = map(args[1]);
id = trap_byreg(reg);
if (id >= 0) {
if (args[2])
tpos[id] = eval(args[2], 'v');
else
treg[id] = -1;
}
}
void tr_dt(char **args)
{
if (!cdiv)
return;
if (args[2]) {
cdiv->tpos = eval(args[1], 'v');
cdiv->treg = map(args[2]);
} else {
cdiv->treg = -1;
}
}
void tr_em(char **args)
{
trap_em = args[1] ? map(args[1]) : -1;
}
static int trap_pos(int pos)
{
int ret = trap_first(pos);
if (bp_final >= 3)
return -1;
if (cdiv)
return cdiv->treg && cdiv->tpos > pos ? cdiv->tpos : -1;
return ret >= 0 ? tposval(ret) : -1;
}
static int trap_reg(int pos)
{
int ret = trap_first(pos);
if (cdiv)
return cdiv->treg && cdiv->tpos > pos ? cdiv->treg : -1;
return ret >= 0 ? treg[ret] : -1;
}
int f_nexttrap(void)
{
int pos = trap_pos(n_d);
if (cdiv)
return pos >= 0 ? pos : 0x7fffffff;
return (pos >= 0 && pos < n_p ? pos : n_p) - n_d;
}