ref: 596ab1ebe789bcf00d98bcaf41b8a546606344a9
dir: /tr.c/
/* built-in troff requests */ #include <ctype.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include "roff.h" static int tr_nl = 1; /* just read a newline */ static int tr_bm = -1; /* blank line macro */ static int tr_sm = -1; /* leading space macro */ char c_pc[GNLEN] = "%"; /* page number character */ int c_ec = '\\'; /* escape character */ int c_cc = '.'; /* control character */ int c_c2 = '\''; /* no-break control character */ /* skip everything until the end of line */ static void jmp_eol(void) { int c; do { c = cp_next(); } while (c >= 0 && c != '\n'); } static void tr_vs(char **args) { int vs = args[1] ? eval_re(args[1], n_v, 'p') : n_v0; n_v0 = n_v; n_v = MAX(0, vs); } static void tr_ls(char **args) { int ls = args[1] ? eval_re(args[1], n_L, 0) : n_L0; n_L0 = n_L; n_L = MAX(1, ls); } static void tr_pl(char **args) { int n = eval_re(args[1] ? args[1] : "11i", n_p, 'v'); n_p = MAX(0, n); } static void tr_nr(char **args) { int id; if (!args[2]) return; id = map(args[1]); num_set(id, eval_re(args[2], num_get(id), 'u')); num_setinc(id, args[3] ? eval(args[3], 'u') : 0); } static void tr_rr(char **args) { int i; for (i = 1; i < NARGS; i++) if (args[i]) num_del(map(args[i])); } static void tr_af(char **args) { if (args[2]) num_setfmt(map(args[1]), args[2]); } static void tr_ds(char **args) { str_set(map(args[1]), args[2] ? args[2] : ""); } static void tr_as(char **args) { int reg; char *s1, *s2, *s; reg = map(args[1]); s1 = str_get(reg) ? str_get(reg) : ""; s2 = args[2] ? args[2] : ""; s = xmalloc(strlen(s1) + strlen(s2) + 1); strcpy(s, s1); strcat(s, s2); str_set(reg, s); free(s); } static void tr_rm(char **args) { int i; for (i = 1; i < NARGS; i++) if (args[i]) str_rm(map(args[i])); } static void tr_rn(char **args) { if (!args[2]) return; str_rn(map(args[1]), map(args[2])); } static void tr_po(char **args) { int po = args[1] ? eval_re(args[1], n_o, 'm') : n_o0; n_o0 = n_o; n_o = MAX(0, po); } /* read a string argument of a macro */ static char *read_string(void) { struct sbuf sbuf; int c; int empty; sbuf_init(&sbuf); cp_copymode(1); while ((c = cp_next()) == ' ') ; empty = c <= 0 || c == '\n'; if (c == '"') c = cp_next(); while (c > 0 && c != '\n') { if (c != c_ni) sbuf_add(&sbuf, c); c = cp_next(); } if (c >= 0) cp_back(c); cp_copymode(0); if (empty) { sbuf_done(&sbuf); return NULL; } return sbuf_out(&sbuf); } /* read a space separated macro argument; if two, read at most two characters */ static char *read_name(int two) { struct sbuf sbuf; int c = cp_next(); int i = 0; sbuf_init(&sbuf); while (c == ' ' || c == '\t' || c == c_ni) c = cp_next(); while (c > 0 && c != ' ' && c != '\t' && c != '\n' && (!two || i < 2)) { if (c != c_ni) { sbuf_add(&sbuf, c); i++; } c = cp_next(); } if (c >= 0) cp_back(c); return sbuf_out(&sbuf); } static void macrobody(struct sbuf *sbuf, char *end) { int first = 1; int c; char *req = NULL; cp_back('\n'); cp_copymode(1); while ((c = cp_next()) >= 0) { if (sbuf && !first) sbuf_add(sbuf, c); first = 0; if (c == '\n') { if ((c = cp_next()) != c_cc) { cp_back(c); continue; } req = read_name(n_cp); if (!strcmp(end, req)) { in_push(end, NULL); cp_back(c_cc); break; } if (sbuf) { sbuf_add(sbuf, c_cc); sbuf_append(sbuf, req); } free(req); req = NULL; } } free(req); cp_copymode(0); } static void tr_de(char **args) { struct sbuf sbuf; int id; if (!args[1]) return; id = map(args[1]); sbuf_init(&sbuf); if (args[0][1] == 'a' && args[0][2] == 'm' && str_get(id)) sbuf_append(&sbuf, str_get(id)); macrobody(&sbuf, args[2] ? args[2] : "."); str_set(id, sbuf_buf(&sbuf)); sbuf_done(&sbuf); if (!n_cp && args[3]) /* parse the arguments as request argv[3] */ str_dset(id, str_dget(map(args[3]))); } static void tr_ig(char **args) { macrobody(NULL, args[1] ? args[1] : "."); } /* read into sbuf until stop; if stop is NULL, stop at whitespace */ static int read_until(struct sbuf *sbuf, char *stop, int (*next)(void), void (*back)(int)) { char cs[GNLEN], cs2[GNLEN]; int c; while ((c = next()) >= 0) { if (c == c_ni) continue; back(c); if (c == '\n') return 1; if (!stop && (c == ' ' || c == '\t')) return 0; charnext(cs, next, back); if (stop && !strcmp(stop, cs)) return 0; charnext_str(cs2, cs); sbuf_append(sbuf, cs2); } return 1; } /* evaluate .if strcmp (i.e. 'str'str') */ static int if_strcmp(int (*next)(void), void (*back)(int)) { char delim[GNLEN]; struct sbuf s1, s2; int ret; charnext(delim, next, back); sbuf_init(&s1); sbuf_init(&s2); read_until(&s1, delim, next, back); read_until(&s2, delim, next, back); cp_reqbeg(); ret = !strcmp(sbuf_buf(&s1), sbuf_buf(&s2)); sbuf_done(&s1); sbuf_done(&s2); return ret; } /* evaluate .if condition letters */ static int if_cond(int (*next)(void), void (*back)(int)) { switch (cp_next()) { case 'o': return n_pg % 2; case 'e': return !(n_pg % 2); case 't': return 1; case 'n': return 0; } return 0; } /* evaluate .if condition */ static int if_eval(int (*next)(void), void (*back)(int)) { struct sbuf sbuf; int ret; sbuf_init(&sbuf); read_until(&sbuf, NULL, next, back); ret = eval(sbuf_buf(&sbuf), '\0') > 0; sbuf_done(&sbuf); return ret; } static int eval_if(int (*next)(void), void (*back)(int)) { int neg = 0; int ret; int c; do { c = next(); } while (c == ' ' || c == '\t'); if (c == '!') { neg = 1; c = next(); } back(c); if (strchr("oetn", c)) { ret = if_cond(next, back); } else if (c == ' ') { ret = 0; } else if (!isdigit(c) && !strchr("-+*/%<=>&:.|()", c)) { ret = if_strcmp(next, back); } else { ret = if_eval(next, back); } return ret != neg; } static int ie_cond[NIES]; /* .ie condition stack */ static int ie_depth; static void tr_if(char **args) { int c = eval_if(cp_next, cp_back); if (args[0][1] == 'i' && args[0][2] == 'e') /* .ie command */ if (ie_depth < NIES) ie_cond[ie_depth++] = c; cp_blk(!c); } static void tr_el(char **args) { cp_blk(ie_depth > 0 ? ie_cond[--ie_depth] : 1); } static void tr_na(char **args) { n_na = 1; } static int adjmode(int c, int def) { switch (c) { case 'l': return AD_L; case 'r': return AD_R; case 'c': return AD_C; case 'b': case 'n': return AD_B; case 'k': return AD_B | AD_K; } return def; } static void tr_ad(char **args) { char *s = args[1]; n_na = 0; if (!s) return; if (isdigit((unsigned char) s[0])) n_j = atoi(s) & 15; else n_j = s[0] == 'p' ? AD_P | adjmode(s[1], AD_B) : adjmode(s[0], n_j); } static void tr_tm(char **args) { fprintf(stderr, "%s\n", args[1] ? args[1] : ""); } static void tr_so(char **args) { if (args[1]) in_so(args[1]); } static void tr_nx(char **args) { in_nx(args[1]); } static void tr_shift(char **args) { int n = args[1] ? atoi(args[1]) : 1; while (n-- >= 1) in_shift(); } static void tr_ex(char **args) { in_ex(); } static void tr_sy(char **args) { system(args[1]); } static void tr_lt(char **args) { int lt = args[1] ? eval_re(args[1], n_lt, 'm') : n_t0; n_t0 = n_t0; n_lt = MAX(0, lt); } static void tr_pc(char **args) { char *s = args[1]; if (!s || charread(&s, c_pc) < 0) strcpy(c_pc, ""); } static void tr_tl(char **args) { int c; do { c = cp_next(); } while (c >= 0 && (c == ' ' || c == '\t')); cp_back(c); ren_tl(cp_next, cp_back); do { c = cp_next(); } while (c >= 0 && c != '\n'); } static void tr_ec(char **args) { c_ec = args[1] ? args[1][0] : '\\'; } static void tr_cc(char **args) { c_cc = args[1] ? args[1][0] : '.'; } static void tr_c2(char **args) { c_c2 = args[1] ? args[1][0] : '\''; } static void tr_eo(char **args) { c_ec = -1; } static void tr_hc(char **args) { char *s = args[1]; if (!s || charread(&s, c_hc) < 0) strcpy(c_hc, "\\%"); } /* sentence ending and their transparent characters */ static char eos_sent[NCHARS][GNLEN] = { ".", "?", "!", }; static int eos_sentcnt = 3; static char eos_tran[NCHARS][GNLEN] = { "'", "\"", ")", "]", "*", }; static int eos_trancnt = 5; static void tr_eos(char **args) { eos_sentcnt = 0; eos_trancnt = 0; if (args[1]) { char *s = args[1]; while (s && charread(&s, eos_sent[eos_sentcnt]) >= 0) if (eos_sentcnt < NCHARS - 1) eos_sentcnt++; } if (args[2]) { char *s = args[2]; while (s && charread(&s, eos_tran[eos_trancnt]) >= 0) if (eos_trancnt < NCHARS - 1) eos_trancnt++; } } int c_eossent(char *s) { int i; for (i = 0; i < eos_sentcnt; i++) if (!strcmp(eos_sent[i], s)) return 1; return 0; } int c_eostran(char *s) { int i; for (i = 0; i < eos_trancnt; i++) if (!strcmp(eos_tran[i], s)) return 1; return 0; } /* hyphenation dashes and hyphenation inhibiting character */ static char hy_dash[NCHARS][GNLEN] = { "\\:", "-", "em", "en", "\\-", "--", "hy", }; static int hy_dashcnt = 7; static char hy_stop[NCHARS][GNLEN] = { "\\%", }; static int hy_stopcnt = 1; static void tr_nh(char **args) { n_hy = 0; } static void tr_hy(char **args) { n_hy = args[1] ? eval_re(args[1], n_hy, '\0') : 1; } static void tr_hlm(char **args) { n_hlm = args[1] ? eval_re(args[1], n_hlm, '\0') : 0; } static void tr_hycost(char **args) { n_hycost = args[1] ? eval_re(args[1], n_hycost, '\0') : 0; n_hycost2 = args[2] ? eval_re(args[2], n_hycost2, '\0') : 0; n_hycost3 = args[3] ? eval_re(args[3], n_hycost3, '\0') : 0; } static void tr_hydash(char **args) { hy_dashcnt = 0; if (args[1]) { char *s = args[1]; while (s && charread(&s, hy_dash[hy_dashcnt]) >= 0) if (hy_dashcnt < NCHARS - 1) hy_dashcnt++; } } static void tr_hystop(char **args) { hy_stopcnt = 0; if (args[1]) { char *s = args[1]; while (s && charread(&s, hy_stop[hy_stopcnt]) >= 0) if (hy_stopcnt < NCHARS - 1) hy_stopcnt++; } } int c_hydash(char *s) { int i; for (i = 0; i < hy_dashcnt; i++) if (!strcmp(hy_dash[i], s)) return 1; return 0; } int c_hystop(char *s) { int i; for (i = 0; i < hy_stopcnt; i++) if (!strcmp(hy_stop[i], s)) return 1; return 0; } int c_hymark(char *s) { return !strcmp(c_bp, s) || !strcmp(c_hc, s); } static void tr_pmll(char **args) { n_pmll = args[1] ? eval_re(args[1], n_pmll, '\0') : 0; n_pmllcost = args[2] ? eval_re(args[2], n_pmllcost, '\0') : 100; } static void tr_lg(char **args) { if (args[1]) n_lg = eval(args[1], '\0'); } static void tr_kn(char **args) { if (args[1]) n_kn = eval(args[1], '\0'); } static void tr_cp(char **args) { if (args[1]) n_cp = atoi(args[1]); } static void tr_ss(char **args) { if (args[1]) { n_ss = eval_re(args[1], n_ss, 0); n_sss = args[2] ? eval_re(args[2], n_sss, 0) : n_ss; } } static void tr_ssh(char **args) { n_ssh = args[1] ? eval_re(args[1], n_ssh, 0) : 0; } static void tr_cs(char **args) { struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL; if (fn) font_setcs(fn, args[2] ? eval(args[2], 0) : 0, args[3] ? eval(args[3], 0) : 0); } static void tr_fzoom(char **args) { struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL; if (fn) font_setzoom(fn, args[2] ? eval(args[2], 0) : 0); } static void tr_tkf(char **args) { struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL; if (fn && args[5]) font_track(fn, eval(args[2], 0), eval(args[3], 0), eval(args[4], 0), eval(args[5], 0)); } static void tr_ff(char **args) { struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL; int i; for (i = 2; i < NARGS; i++) if (fn && args[i] && args[i][0] && args[i][1]) font_feat(fn, args[i] + 1, args[i][0] == '+'); } static void tr_ffsc(char **args) { struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL; if (fn) font_scrp(fn, args[2]); if (fn) font_lang(fn, args[3]); } static void tr_nm(char **args) { if (!args[1]) { n_nm = 0; return; } n_nm = 1; n_ln = eval_re(args[1], n_ln, 0); n_ln = MAX(0, n_ln); if (args[2] && isdigit((unsigned char) args[2][0])) n_nM = MAX(1, eval(args[2], 0)); if (args[3] && isdigit((unsigned char) args[3][0])) n_nS = MAX(0, eval(args[3], 0)); if (args[4] && isdigit((unsigned char) args[4][0])) n_nI = MAX(0, eval(args[4], 0)); } static void tr_nn(char **args) { n_nn = args[1] ? eval(args[1], 0) : 1; } static void tr_bd(char **args) { struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL; if (!args[1] || !strcmp("S", args[1])) return; if (fn) font_setbd(fn, args[2] ? eval(args[2], 'u') : 0); } static void tr_it(char **args) { if (args[2]) { n_it = map(args[2]); n_itn = eval(args[1], 0); } else { n_it = 0; } } static void tr_mc(char **args) { char *s = args[1]; if (s && charread(&s, c_mc) >= 0) { n_mc = 1; n_mcn = args[2] ? eval(args[2], 'm') : SC_EM; } else { n_mc = 0; } } static void tr_tc(char **args) { char *s = args[1]; if (!s || charread(&s, c_tc) < 0) strcpy(c_tc, ""); } static void tr_lc(char **args) { char *s = args[1]; if (!s || charread(&s, c_lc) < 0) strcpy(c_lc, ""); } static void tr_lf(char **args) { if (args[1]) in_lf(args[2], eval(args[1], 0)); } static void tr_chop(char **args) { struct sbuf sbuf; int id; id = map(args[1]); if (str_get(id)) { sbuf_init(&sbuf); sbuf_append(&sbuf, str_get(id)); if (!sbuf_empty(&sbuf)) { sbuf_cut(&sbuf, sbuf_len(&sbuf) - 1); str_set(id, sbuf_buf(&sbuf)); } sbuf_done(&sbuf); } } /* character translation (.tr) */ static struct dict *cmap; /* character mapping */ static char cmap_src[NCMAPS][GNLEN]; /* source character */ static char cmap_dst[NCMAPS][GNLEN]; /* character mapping */ static int cmap_n; /* number of translated character */ void cmap_add(char *c1, char *c2) { int i = dict_get(cmap, c1); if (i >= 0) { strcpy(cmap_dst[i], c2); } else if (cmap_n < NCMAPS) { strcpy(cmap_src[cmap_n], c1); strcpy(cmap_dst[cmap_n], c2); dict_put(cmap, cmap_src[cmap_n], cmap_n); cmap_n++; } } char *cmap_map(char *c) { int i = dict_get(cmap, c); return i >= 0 ? cmap_dst[i] : c; } static void tr_tr(char **args) { char *s = args[1]; char c1[GNLEN], c2[GNLEN]; while (s && charread(&s, c1) >= 0) { if (charread(&s, c2) < 0) strcpy(c2, " "); cmap_add(c1, c2); } } /* character definition (.char) */ static char cdef_src[NCDEFS][GNLEN]; /* source character */ static char *cdef_dst[NCDEFS]; /* character definition */ static int cdef_fn[NCDEFS]; /* owning font */ static int cdef_n; /* number of defined characters */ static int cdef_expanding; /* inside cdef_expand() call */ static int cdef_find(char *c, int fn) { int i; for (i = 0; i < cdef_n; i++) if ((!cdef_fn[i] || cdef_fn[i] == fn) && !strcmp(cdef_src[i], c)) return i; return -1; } /* return the definition of the given character */ char *cdef_map(char *c, int fn) { int i = cdef_find(c, fn); return !cdef_expanding && i >= 0 ? cdef_dst[i] : NULL; } int cdef_expand(struct wb *wb, char *s, int fn) { char *d = cdef_map(s, fn); if (!d) return 1; cdef_expanding = 1; ren_parse(wb, d); cdef_expanding = 0; return 0; } static void cdef_remove(char *fn, char *cs) { char c[GNLEN]; int i; int fp = fn ? dev_pos(fn) : -1; if (!cs || charread(&cs, c) < 0) return; for (i = 0; i < cdef_n; i++) { if (!strcmp(cdef_src[i], c)) { if (!fn || (fp > 0 && cdef_fn[i] == fp)) { free(cdef_dst[i]); cdef_dst[i] = NULL; cdef_src[i][0] = '\0'; } } } } static void cdef_add(char *fn, char *cs, char *def) { char c[GNLEN]; int i; if (!def || charread(&cs, c) < 0) return; i = cdef_find(c, fn ? dev_pos(fn) : -1); if (i < 0) { for (i = 0; i < cdef_n; i++) if (!cdef_dst[i]) break; if (i == cdef_n && cdef_n < NCDEFS) cdef_n++; } if (i >= 0 && i < cdef_n) { snprintf(cdef_src[i], sizeof(cdef_src[i]), "%s", c); cdef_dst[i] = xmalloc(strlen(def) + 1); strcpy(cdef_dst[i], def); cdef_fn[i] = fn ? dev_pos(fn) : 0; } } static void tr_rchar(char **args) { int i; for (i = 1; i < NARGS; i++) if (args[i]) cdef_remove(NULL, args[i]); } static void tr_char(char **args) { if (args[2]) cdef_add(NULL, args[1], args[2]); else cdef_remove(NULL, args[1]); } static void tr_ochar(char **args) { if (args[3]) cdef_add(args[1], args[2], args[3]); else cdef_remove(args[1], args[2]); } static void tr_fmap(char **args) { struct font *fn = args[1] ? dev_font(dev_pos(args[1])) : NULL; if (fn && args[2]) font_map(fn, args[2], args[3]); } static void tr_blm(char **args) { tr_bm = args[1] ? map(args[1]) : -1; } static void tr_lsm(char **args) { tr_sm = args[1] ? map(args[1]) : -1; } static void tr_co(char **args) { char *src = args[1]; char *dst = args[2]; if (src && dst && str_get(map(src))) str_set(map(dst), str_get(map(src))); } static void tr_coa(char **args) { char *src = args[1]; char *dst = args[2]; if (src && dst && str_get(map(src))) { struct sbuf sb; sbuf_init(&sb); if (str_get(map(dst))) sbuf_append(&sb, str_get(map(dst))); sbuf_append(&sb, str_get(map(src))); str_set(map(dst), sbuf_buf(&sb)); sbuf_done(&sb); } } static void tr_coo(char **args) { char *reg = args[1]; char *path = args[2]; FILE *fp; if (!reg || !reg[0] || !path || !path[0]) return; if ((fp = fopen(path, "w"))) { if (str_get(map(reg))) fputs(str_get(map(reg)), fp); fclose(fp); } } static void tr_coi(char **args) { char *reg = args[1]; char *path = args[2]; char buf[1024]; FILE *fp; if (!reg || !reg[0] || !path || !path[0]) return; if ((fp = fopen(path + 1, "r"))) { struct sbuf sb; sbuf_init(&sb); while (fgets(buf, sizeof(buf), fp)) sbuf_append(&sb, buf); str_set(map(reg), sbuf_buf(&sb)); sbuf_done(&sb); fclose(fp); } } static void tr_dv(char **args) { if (args[1]) out_x(args[1]); } /* read a single macro argument */ static int macroarg(struct sbuf *sbuf, int brk, int (*next)(void), void (*back)(int)) { int quoted = 0; int c; c = next(); while (c == ' ') c = next(); if (c == '\n' || c == brk) back(c); if (c < 0 || c == '\n' || c == brk) return 1; if (c == '"') { quoted = 1; c = next(); } while (c >= 0 && c != '\n' && (quoted || c != brk)) { if (!quoted && c == ' ') break; if (quoted && c == '"') { c = next(); if (c != '"') break; } if (c == c_ec) { sbuf_add(sbuf, c); c = next(); } sbuf_add(sbuf, c); c = next(); } sbuf_add(sbuf, 0); if (c >= 0) back(c); return 0; } /* split the arguments in sbuf, after calling one of mkargs_*() */ static void chopargs(struct sbuf *sbuf, char **args) { char *s = sbuf_buf(sbuf); char *e = s + sbuf_len(sbuf); int n = 0; while (n < NARGS && s && s < e) { args[n++] = s; if ((s = memchr(s, '\0', e - s))) s++; } } /* read macro arguments; free the returned pointer when done */ char *tr_args(char **args, int brk, int (*next)(void), void (*back)(int)) { struct sbuf sbuf; sbuf_init(&sbuf); while (!macroarg(&sbuf, brk, next, back)) ; chopargs(&sbuf, args); return sbuf_out(&sbuf); } /* read regular macro arguments */ static void mkargs_macro(struct sbuf *sbuf) { cp_copymode(1); while (!macroarg(sbuf, -1, cp_next, cp_back)) ; jmp_eol(); cp_copymode(0); } /* read request arguments; trims tabs too */ static void mkargs_req(struct sbuf *sbuf) { int n = 0; int c; c = cp_next(); while (n < NARGS) { int ok = 0; while (c == ' ' || c == '\t') c = cp_next(); while (c >= 0 && c != '\n' && c != ' ' && c != '\t') { if (c != c_ni) sbuf_add(sbuf, c); c = cp_next(); ok = 1; } if (ok) { n++; sbuf_add(sbuf, 0); } if (c == '\n') cp_back(c); if (c < 0 || c == '\n') break; } jmp_eol(); } /* read arguments for .ds and .char */ static void mkargs_ds(struct sbuf *sbuf) { char *s = read_name(n_cp); sbuf_append(sbuf, s); sbuf_add(sbuf, 0); free(s); s = read_string(); if (s) { sbuf_append(sbuf, s); sbuf_add(sbuf, 0); free(s); } jmp_eol(); } /* read arguments for .ochar */ static void mkargs_ochar(struct sbuf *sbuf) { char *s = read_name(0); sbuf_append(sbuf, s); sbuf_add(sbuf, 0); free(s); mkargs_ds(sbuf); } /* read arguments for .nr */ static void mkargs_reg1(struct sbuf *sbuf) { char *s = read_name(n_cp); sbuf_append(sbuf, s); sbuf_add(sbuf, 0); free(s); mkargs_req(sbuf); } /* do not read any arguments; for .if, .ie and .el */ static void mkargs_null(struct sbuf *sbuf) { } /* read the whole line for .tm */ static void mkargs_eol(struct sbuf *sbuf) { int c; cp_copymode(1); c = cp_next(); while (c == ' ') c = cp_next(); while (c >= 0 && c != '\n') { if (c != c_ni) sbuf_add(sbuf, c); c = cp_next(); } cp_copymode(0); } static struct cmd { char *id; void (*f)(char **args); void (*args)(struct sbuf *sbuf); } cmds[] = { {TR_DIVBEG, tr_divbeg}, {TR_DIVEND, tr_divend}, {TR_DIVVS, tr_divvs}, {TR_POPREN, tr_popren}, {">>", tr_l2r}, {"<<", tr_r2l}, {"ab", tr_ab, mkargs_eol}, {"ad", tr_ad}, {"af", tr_af}, {"am", tr_de, mkargs_reg1}, {"as", tr_as, mkargs_ds}, {"bd", tr_bd}, {"blm", tr_blm}, {"bp", tr_bp}, {"br", tr_br}, {"c2", tr_c2}, {"cc", tr_cc}, {"ce", tr_ce}, {"ch", tr_ch}, {"char", tr_char, mkargs_ds}, {"chop", tr_chop, mkargs_reg1}, {"cl", tr_cl}, {"co", tr_co}, {"co+", tr_coa}, {"co<", tr_coi, mkargs_ds}, {"co>", tr_coo, mkargs_ds}, {"cp", tr_cp}, {"cs", tr_cs}, {"da", tr_di}, {"de", tr_de, mkargs_reg1}, {"di", tr_di}, {"ds", tr_ds, mkargs_ds}, {"dt", tr_dt}, {"dv", tr_dv, mkargs_eol}, {"ec", tr_ec}, {"el", tr_el, mkargs_null}, {"em", tr_em}, {"eo", tr_eo}, {"eos", tr_eos}, {"ev", tr_ev}, {"ex", tr_ex}, {"fc", tr_fc}, {"ff", tr_ff}, {"fi", tr_fi}, {"fl", tr_br}, {"fmap", tr_fmap}, {"fp", tr_fp}, {"ffsc", tr_ffsc}, {"fspecial", tr_fspecial}, {"ft", tr_ft}, {"fzoom", tr_fzoom}, {"hc", tr_hc}, {"hcode", tr_hcode}, {"hlm", tr_hlm}, {"hpf", tr_hpf}, {"hpfa", tr_hpfa}, {"hy", tr_hy}, {"hycost", tr_hycost}, {"hydash", tr_hydash}, {"hystop", tr_hystop}, {"hw", tr_hw}, {"ie", tr_if, mkargs_null}, {"if", tr_if, mkargs_null}, {"ig", tr_ig}, {"in", tr_in}, {"in2", tr_in2}, {"it", tr_it}, {"kn", tr_kn}, {"lc", tr_lc}, {"lf", tr_lf}, {"lg", tr_lg}, {"ll", tr_ll}, {"ls", tr_ls}, {"lsm", tr_lsm}, {"lt", tr_lt}, {"mc", tr_mc}, {"mk", tr_mk}, {"na", tr_na}, {"ne", tr_ne}, {"nf", tr_nf}, {"nh", tr_nh}, {"nm", tr_nm}, {"nn", tr_nn}, {"nr", tr_nr, mkargs_reg1}, {"ns", tr_ns}, {"nx", tr_nx}, {"ochar", tr_ochar, mkargs_ochar}, {"os", tr_os}, {"pc", tr_pc}, {"pl", tr_pl}, {"pmll", tr_pmll}, {"pn", tr_pn}, {"po", tr_po}, {"ps", tr_ps}, {"rchar", tr_rchar}, {"rm", tr_rm}, {"rn", tr_rn}, {"rr", tr_rr}, {"rs", tr_rs}, {"rt", tr_rt}, {"shift", tr_shift}, {"so", tr_so}, {"sp", tr_sp}, {"ss", tr_ss}, {"ssh", tr_ssh}, {"sv", tr_sv}, {"sy", tr_sy, mkargs_eol}, {"ta", tr_ta}, {"tc", tr_tc}, {"ti", tr_ti}, {"ti2", tr_ti2}, {"tkf", tr_tkf}, {"tl", tr_tl, mkargs_null}, {"tm", tr_tm, mkargs_eol}, {"tr", tr_tr, mkargs_eol}, {"vs", tr_vs}, {"wh", tr_wh}, }; static char *dotted(char *name, int dot) { char *out = xmalloc(strlen(name) + 2); out[0] = dot; strcpy(out + 1, name); return out; } /* execute a built-in request */ void tr_req(int reg, char **args) { struct cmd *req = str_dget(reg); if (req) req->f(args); } /* interpolate a macro for tr_nextreq() */ static void tr_nextreq_exec(char *mac, char *arg0, int readargs) { char *args[NARGS + 3] = {arg0}; struct cmd *req = str_dget(map(mac)); char *str = str_get(map(mac)); struct sbuf sbuf; sbuf_init(&sbuf); if (readargs) { if (req && req->args) req->args(&sbuf); if (req && !req->args) mkargs_req(&sbuf); if (!req) mkargs_macro(&sbuf); chopargs(&sbuf, args + 1); } if (str) in_push(str, args); if (!str && req) req->f(args); sbuf_done(&sbuf); } /* read the next troff request; return zero if a request was executed. */ int tr_nextreq(void) { char *mac; char *arg0 = NULL; int c; if (!tr_nl) return 1; c = cp_next(); /* transparent line indicator */ if (c == c_ec) { int c2 = cp_next(); if (c2 == '!') { char *args[NARGS + 3] = {"\\!"}; struct sbuf sbuf; sbuf_init(&sbuf); cp_copymode(1); mkargs_eol(&sbuf); cp_copymode(0); chopargs(&sbuf, args + 1); tr_transparent(args); sbuf_done(&sbuf); return 0; } cp_back(c2); } /* not a request, a blank line, or a line with leading spaces */ if (c < 0 || (c != c_cc && c != c_c2 && (c != '\n' || tr_bm < 0) && (c != ' ' || tr_sm < 0))) { cp_back(c); return 1; } cp_reqbeg(); if (c == '\n') { /* blank line macro */ mac = malloc(strlen(map_name(tr_bm)) + 1); strcpy(mac, map_name(tr_bm)); arg0 = dotted(mac, '.'); tr_nextreq_exec(mac, arg0, 0); } else if (c == ' ') { /* leading space macro */ int i; mac = malloc(strlen(map_name(tr_sm)) + 1); strcpy(mac, map_name(tr_sm)); for (i = 0; c == ' '; i++) c = cp_next(); cp_back(c); n_lsn = i; arg0 = dotted(mac, '.'); tr_nextreq_exec(mac, arg0, 0); } else { mac = read_name(n_cp); arg0 = dotted(mac, c); tr_nextreq_exec(mac, arg0, 1); } free(arg0); free(mac); return 0; } int tr_next(void) { int c; while (!tr_nextreq()) ; c = cp_next(); tr_nl = c == '\n' || c < 0; return c; } void tr_init(void) { int i; for (i = 0; i < LEN(cmds); i++) str_dset(map(cmds[i].id), &cmds[i]); cmap = dict_make(-1, 0, 2); } void tr_done(void) { int i; for (i = 0; i < cdef_n; i++) free(cdef_dst[i]); dict_free(cmap); }