=================================================================== RCS file: /cvs/mandoc/roff.c,v retrieving revision 1.257 retrieving revision 1.294 diff -u -p -r1.257 -r1.294 --- mandoc/roff.c 2015/01/28 15:03:45 1.257 +++ mandoc/roff.c 2017/04/24 23:06:18 1.294 @@ -1,7 +1,7 @@ -/* $Id: roff.c,v 1.257 2015/01/28 15:03:45 schwarze Exp $ */ +/* $Id: roff.c,v 1.294 2017/04/24 23:06:18 schwarze Exp $ */ /* - * Copyright (c) 2010, 2011, 2012, 2014 Kristaps Dzonsons - * Copyright (c) 2010-2015 Ingo Schwarze + * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons + * Copyright (c) 2010-2015, 2017 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -28,261 +28,15 @@ #include "mandoc.h" #include "mandoc_aux.h" +#include "roff.h" #include "libmandoc.h" +#include "roff_int.h" #include "libroff.h" -/* Maximum number of nested if-else conditionals. */ -#define RSTACK_MAX 128 - /* Maximum number of string expansions per line, to break infinite loops. */ #define EXPAND_LIMIT 1000 -enum rofft { - ROFF_ab, - ROFF_ad, - ROFF_af, - ROFF_aln, - ROFF_als, - ROFF_am, - ROFF_am1, - ROFF_ami, - ROFF_ami1, - ROFF_as, - ROFF_as1, - ROFF_asciify, - ROFF_backtrace, - ROFF_bd, - ROFF_bleedat, - ROFF_blm, - ROFF_box, - ROFF_boxa, - ROFF_bp, - ROFF_BP, - /* MAN_br, MDOC_br */ - ROFF_break, - ROFF_breakchar, - ROFF_brnl, - ROFF_brp, - ROFF_brpnl, - ROFF_c2, - ROFF_cc, - ROFF_ce, - ROFF_cf, - ROFF_cflags, - ROFF_ch, - ROFF_char, - ROFF_chop, - ROFF_class, - ROFF_close, - ROFF_CL, - ROFF_color, - ROFF_composite, - ROFF_continue, - ROFF_cp, - ROFF_cropat, - ROFF_cs, - ROFF_cu, - ROFF_da, - ROFF_dch, - ROFF_Dd, - ROFF_de, - ROFF_de1, - ROFF_defcolor, - ROFF_dei, - ROFF_dei1, - ROFF_device, - ROFF_devicem, - ROFF_di, - ROFF_do, - ROFF_ds, - ROFF_ds1, - ROFF_dwh, - ROFF_dt, - ROFF_ec, - ROFF_ecr, - ROFF_ecs, - ROFF_el, - ROFF_em, - ROFF_EN, - ROFF_eo, - ROFF_EP, - ROFF_EQ, - ROFF_errprint, - ROFF_ev, - ROFF_evc, - ROFF_ex, - ROFF_fallback, - ROFF_fam, - ROFF_fc, - ROFF_fchar, - ROFF_fcolor, - ROFF_fdeferlig, - ROFF_feature, - /* MAN_fi; ignored in mdoc(7) */ - ROFF_fkern, - ROFF_fl, - ROFF_flig, - ROFF_fp, - ROFF_fps, - ROFF_fschar, - ROFF_fspacewidth, - ROFF_fspecial, - /* MAN_ft; ignored in mdoc(7) */ - ROFF_ftr, - ROFF_fzoom, - ROFF_gcolor, - ROFF_hc, - ROFF_hcode, - ROFF_hidechar, - ROFF_hla, - ROFF_hlm, - ROFF_hpf, - ROFF_hpfa, - ROFF_hpfcode, - ROFF_hw, - ROFF_hy, - ROFF_hylang, - ROFF_hylen, - ROFF_hym, - ROFF_hypp, - ROFF_hys, - ROFF_ie, - ROFF_if, - ROFF_ig, - /* MAN_in; ignored in mdoc(7) */ - ROFF_index, - ROFF_it, - ROFF_itc, - ROFF_IX, - ROFF_kern, - ROFF_kernafter, - ROFF_kernbefore, - ROFF_kernpair, - ROFF_lc, - ROFF_lc_ctype, - ROFF_lds, - ROFF_length, - ROFF_letadj, - ROFF_lf, - ROFF_lg, - ROFF_lhang, - ROFF_linetabs, - /* MAN_ll, MDOC_ll */ - ROFF_lnr, - ROFF_lnrf, - ROFF_lpfx, - ROFF_ls, - ROFF_lsm, - ROFF_lt, - ROFF_mc, - ROFF_mediasize, - ROFF_minss, - ROFF_mk, - ROFF_mso, - ROFF_na, - ROFF_ne, - /* MAN_nf; ignored in mdoc(7) */ - ROFF_nh, - ROFF_nhychar, - ROFF_nm, - ROFF_nn, - ROFF_nop, - ROFF_nr, - ROFF_nrf, - ROFF_nroff, - ROFF_ns, - ROFF_nx, - ROFF_open, - ROFF_opena, - ROFF_os, - ROFF_output, - ROFF_padj, - ROFF_papersize, - ROFF_pc, - ROFF_pev, - ROFF_pi, - ROFF_PI, - ROFF_pl, - ROFF_pm, - ROFF_pn, - ROFF_pnr, - ROFF_po, - ROFF_ps, - ROFF_psbb, - ROFF_pshape, - ROFF_pso, - ROFF_ptr, - ROFF_pvs, - ROFF_rchar, - ROFF_rd, - ROFF_recursionlimit, - ROFF_return, - ROFF_rfschar, - ROFF_rhang, - ROFF_rj, - ROFF_rm, - ROFF_rn, - ROFF_rnn, - ROFF_rr, - ROFF_rs, - ROFF_rt, - ROFF_schar, - ROFF_sentchar, - ROFF_shc, - ROFF_shift, - ROFF_sizes, - ROFF_so, - /* MAN_sp, MDOC_sp */ - ROFF_spacewidth, - ROFF_special, - ROFF_spreadwarn, - ROFF_ss, - ROFF_sty, - ROFF_substring, - ROFF_sv, - ROFF_sy, - ROFF_T_, - ROFF_ta, - ROFF_tc, - ROFF_TE, - ROFF_TH, - ROFF_ti, - ROFF_tkf, - ROFF_tl, - ROFF_tm, - ROFF_tm1, - ROFF_tmc, - ROFF_tr, - ROFF_track, - ROFF_transchar, - ROFF_trf, - ROFF_trimat, - ROFF_trin, - ROFF_trnt, - ROFF_troff, - ROFF_TS, - ROFF_uf, - ROFF_ul, - ROFF_unformat, - ROFF_unwatch, - ROFF_unwatchn, - ROFF_vpt, - ROFF_vs, - ROFF_warn, - ROFF_warnscale, - ROFF_watch, - ROFF_watchlength, - ROFF_watchn, - ROFF_wh, - ROFF_while, - ROFF_write, - ROFF_writec, - ROFF_writem, - ROFF_xflag, - ROFF_cblock, - ROFF_USERDEF, - ROFF_MAX -}; +/* --- data types --------------------------------------------------------- */ /* * An incredibly-simple string buffer. @@ -312,7 +66,6 @@ struct roffreg { struct roff { struct mparse *parse; /* parse point */ - const struct mchars *mchars; /* character table */ struct roffnode *last; /* leaf of stack */ int *rstack; /* stack of inverted `ie' values */ struct roffreg *regtab; /* number registers */ @@ -331,11 +84,12 @@ struct roff { int rstacksz; /* current size limit of rstack */ int rstackpos; /* position in rstack */ int format; /* current file in mdoc or man format */ + int argc; /* number of args of the last macro */ char control; /* control character */ }; struct roffnode { - enum rofft tok; /* type of node */ + enum roff_tok tok; /* type of node */ struct roffnode *parent; /* up one in stack */ int line; /* parse line */ int col; /* parse col */ @@ -346,7 +100,7 @@ struct roffnode { }; #define ROFF_ARGS struct roff *r, /* parse ctx */ \ - enum rofft tok, /* tok of macro */ \ + enum roff_tok tok, /* tok of macro */ \ struct buf *buf, /* input buffer */ \ int ln, /* parse line */ \ int ppos, /* original pos in buffer */ \ @@ -373,11 +127,13 @@ struct predef { #define PREDEF(__name, __str) \ { (__name), (__str) }, -static enum rofft roffhash_find(const char *, size_t); +/* --- function prototypes ------------------------------------------------ */ + +static enum roff_tok roffhash_find(const char *, size_t); static void roffhash_init(void); static void roffnode_cleanscope(struct roff *); static void roffnode_pop(struct roff *); -static void roffnode_push(struct roff *, enum rofft, +static void roffnode_push(struct roff *, enum roff_tok, const char *, int, int); static enum rofferr roff_block(ROFF_ARGS); static enum rofferr roff_block_text(ROFF_ARGS); @@ -391,29 +147,33 @@ static enum rofferr roff_cond_text(ROFF_ARGS); static enum rofferr roff_cond_sub(ROFF_ARGS); static enum rofferr roff_ds(ROFF_ARGS); static enum rofferr roff_eqndelim(struct roff *, struct buf *, int); -static int roff_evalcond(struct roff *r, int, - const char *, int *); +static int roff_evalcond(struct roff *r, int, char *, int *); static int roff_evalnum(struct roff *, int, const char *, int *, int *, int); static int roff_evalpar(struct roff *, int, - const char *, int *, int *); + const char *, int *, int *, int); static int roff_evalstrcond(const char *, int *); static void roff_free1(struct roff *); static void roff_freereg(struct roffreg *); static void roff_freestr(struct roffkv *); static size_t roff_getname(struct roff *, char **, int, int); -static int roff_getnum(const char *, int *, int *); +static int roff_getnum(const char *, int *, int *, int); static int roff_getop(const char *, int *, char *); static int roff_getregn(const struct roff *, const char *, size_t); -static int roff_getregro(const char *name); +static int roff_getregro(const struct roff *, + const char *name); static const char *roff_getstrn(const struct roff *, const char *, size_t); +static int roff_hasregn(const struct roff *, + const char *, size_t); static enum rofferr roff_insec(ROFF_ARGS); static enum rofferr roff_it(ROFF_ARGS); static enum rofferr roff_line_ignore(ROFF_ARGS); +static void roff_man_alloc1(struct roff_man *); +static void roff_man_free1(struct roff_man *); static enum rofferr roff_nr(ROFF_ARGS); -static enum rofft roff_parse(struct roff *, char *, int *, +static enum roff_tok roff_parse(struct roff *, char *, int *, int, int); static enum rofferr roff_parsetext(struct buf *, int, int *); static enum rofferr roff_res(struct roff *, struct buf *, int, int); @@ -435,15 +195,125 @@ static enum rofferr roff_T_(ROFF_ARGS); static enum rofferr roff_unsupp(ROFF_ARGS); static enum rofferr roff_userdef(ROFF_ARGS); +/* --- constant data ------------------------------------------------------ */ + /* See roffhash_find() */ #define ASCII_HI 126 #define ASCII_LO 33 #define HASHWIDTH (ASCII_HI - ASCII_LO + 1) +#define ROFFNUM_SCALE (1 << 0) /* Honour scaling in roff_getnum(). */ +#define ROFFNUM_WHITE (1 << 1) /* Skip whitespace in roff_evalnum(). */ + +const char *__roff_name[MAN_MAX + 1] = { + "ab", "ad", "af", "aln", + "als", "am", "am1", "ami", + "ami1", "as", "as1", "asciify", + "backtrace", "bd", "bleedat", "blm", + "box", "boxa", "bp", "BP", + "break", "breakchar", "brnl", "brp", + "brpnl", "c2", "cc", "ce", + "cf", "cflags", "ch", "char", + "chop", "class", "close", "CL", + "color", "composite", "continue", "cp", + "cropat", "cs", "cu", "da", + "dch", "Dd", "de", "de1", + "defcolor", "dei", "dei1", "device", + "devicem", "di", "do", "ds", + "ds1", "dwh", "dt", "ec", + "ecr", "ecs", "el", "em", + "EN", "eo", "EP", "EQ", + "errprint", "ev", "evc", "ex", + "fallback", "fam", "fc", "fchar", + "fcolor", "fdeferlig", "feature", "fkern", + "fl", "flig", "fp", "fps", + "fschar", "fspacewidth", "fspecial", "ftr", + "fzoom", "gcolor", "hc", "hcode", + "hidechar", "hla", "hlm", "hpf", + "hpfa", "hpfcode", "hw", "hy", + "hylang", "hylen", "hym", "hypp", + "hys", "ie", "if", "ig", + "index", "it", "itc", "IX", + "kern", "kernafter", "kernbefore", "kernpair", + "lc", "lc_ctype", "lds", "length", + "letadj", "lf", "lg", "lhang", + "linetabs", "lnr", "lnrf", "lpfx", + "ls", "lsm", "lt", "mc", + "mediasize", "minss", "mk", "mso", + "na", "ne", "nh", "nhychar", + "nm", "nn", "nop", "nr", + "nrf", "nroff", "ns", "nx", + "open", "opena", "os", "output", + "padj", "papersize", "pc", "pev", + "pi", "PI", "pl", "pm", + "pn", "pnr", "po", "ps", + "psbb", "pshape", "pso", "ptr", + "pvs", "rchar", "rd", "recursionlimit", + "return", "rfschar", "rhang", "rj", + "rm", "rn", "rnn", "rr", + "rs", "rt", "schar", "sentchar", + "shc", "shift", "sizes", "so", + "spacewidth", "special", "spreadwarn", "ss", + "sty", "substring", "sv", "sy", + "T&", "ta", "tc", "TE", + "TH", "ti", "tkf", "tl", + "tm", "tm1", "tmc", "tr", + "track", "transchar", "trf", "trimat", + "trin", "trnt", "troff", "TS", + "uf", "ul", "unformat", "unwatch", + "unwatchn", "vpt", "vs", "warn", + "warnscale", "watch", "watchlength", "watchn", + "wh", "while", "write", "writec", + "writem", "xflag", ".", NULL, + "text", + "Dd", "Dt", "Os", "Sh", + "Ss", "Pp", "D1", "Dl", + "Bd", "Ed", "Bl", "El", + "It", "Ad", "An", "Ap", + "Ar", "Cd", "Cm", "Dv", + "Er", "Ev", "Ex", "Fa", + "Fd", "Fl", "Fn", "Ft", + "Ic", "In", "Li", "Nd", + "Nm", "Op", "Ot", "Pa", + "Rv", "St", "Va", "Vt", + "Xr", "%A", "%B", "%D", + "%I", "%J", "%N", "%O", + "%P", "%R", "%T", "%V", + "Ac", "Ao", "Aq", "At", + "Bc", "Bf", "Bo", "Bq", + "Bsx", "Bx", "Db", "Dc", + "Do", "Dq", "Ec", "Ef", + "Em", "Eo", "Fx", "Ms", + "No", "Ns", "Nx", "Ox", + "Pc", "Pf", "Po", "Pq", + "Qc", "Ql", "Qo", "Qq", + "Re", "Rs", "Sc", "So", + "Sq", "Sm", "Sx", "Sy", + "Tn", "Ux", "Xc", "Xo", + "Fo", "Fc", "Oo", "Oc", + "Bk", "Ek", "Bt", "Hf", + "Fr", "Ud", "Lb", "Lp", + "Lk", "Mt", "Brq", "Bro", + "Brc", "%C", "Es", "En", + "Dx", "%Q", "br", "sp", + "%U", "Ta", "ll", NULL, + "TH", "SH", "SS", "TP", + "LP", "PP", "P", "IP", + "HP", "SM", "SB", "BI", + "IB", "BR", "RB", "R", + "B", "I", "IR", "RI", + "br", "sp", "nf", "fi", + "RE", "RS", "DT", "UC", + "PD", "AT", "in", "ft", + "OP", "EX", "EE", "UR", + "UE", "ll", NULL +}; +const char *const *roff_name = __roff_name; + static struct roffmac *hash[HASHWIDTH]; -static struct roffmac roffs[ROFF_MAX] = { +static struct roffmac roffs[TOKEN_NONE] = { { "ab", roff_unsupp, NULL, NULL, 0, NULL }, { "ad", roff_line_ignore, NULL, NULL, 0, NULL }, { "af", roff_line_ignore, NULL, NULL, 0, NULL }, @@ -728,6 +598,8 @@ static int roffit_lines; /* number of lines to delay static char *roffit_macro; /* nil-terminated macro line */ +/* --- request table ------------------------------------------------------ */ + static void roffhash_init(void) { @@ -750,10 +622,10 @@ roffhash_init(void) } /* - * Look up a roff token by its name. Returns ROFF_MAX if no macro by + * Look up a roff token by its name. Returns TOKEN_NONE if no macro by * the nil-terminated string name could be found. */ -static enum rofft +static enum roff_tok roffhash_find(const char *p, size_t s) { int buc; @@ -767,19 +639,21 @@ roffhash_find(const char *p, size_t s) */ if (p[0] < ASCII_LO || p[0] > ASCII_HI) - return(ROFF_MAX); + return TOKEN_NONE; buc = ROFF_HASH(p); if (NULL == (n = hash[buc])) - return(ROFF_MAX); + return TOKEN_NONE; for ( ; n; n = n->next) if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s]) - return((enum rofft)(n - roffs)); + return (enum roff_tok)(n - roffs); - return(ROFF_MAX); + return TOKEN_NONE; } +/* --- stack of request blocks -------------------------------------------- */ + /* * Pop the current node off of the stack of roff instructions currently * pending. @@ -803,7 +677,7 @@ roffnode_pop(struct roff *r) * removed with roffnode_pop(). */ static void -roffnode_push(struct roff *r, enum rofft tok, const char *name, +roffnode_push(struct roff *r, enum roff_tok tok, const char *name, int line, int col) { struct roffnode *p; @@ -820,6 +694,8 @@ roffnode_push(struct roff *r, enum rofft tok, const ch r->last = p; } +/* --- roff parser state data management ---------------------------------- */ + static void roff_free1(struct roff *r) { @@ -879,22 +755,371 @@ roff_free(struct roff *r) } struct roff * -roff_alloc(struct mparse *parse, const struct mchars *mchars, int options) +roff_alloc(struct mparse *parse, int options) { struct roff *r; r = mandoc_calloc(1, sizeof(struct roff)); r->parse = parse; - r->mchars = mchars; r->options = options; r->format = options & (MPARSE_MDOC | MPARSE_MAN); r->rstackpos = -1; roffhash_init(); - return(r); + return r; } +/* --- syntax tree state data management ---------------------------------- */ + +static void +roff_man_free1(struct roff_man *man) +{ + + if (man->first != NULL) + roff_node_delete(man, man->first); + free(man->meta.msec); + free(man->meta.vol); + free(man->meta.os); + free(man->meta.arch); + free(man->meta.title); + free(man->meta.name); + free(man->meta.date); +} + +static void +roff_man_alloc1(struct roff_man *man) +{ + + memset(&man->meta, 0, sizeof(man->meta)); + man->first = mandoc_calloc(1, sizeof(*man->first)); + man->first->type = ROFFT_ROOT; + man->last = man->first; + man->last_es = NULL; + man->flags = 0; + man->macroset = MACROSET_NONE; + man->lastsec = man->lastnamed = SEC_NONE; + man->next = ROFF_NEXT_CHILD; +} + +void +roff_man_reset(struct roff_man *man) +{ + + roff_man_free1(man); + roff_man_alloc1(man); +} + +void +roff_man_free(struct roff_man *man) +{ + + roff_man_free1(man); + free(man); +} + +struct roff_man * +roff_man_alloc(struct roff *roff, struct mparse *parse, + const char *defos, int quick) +{ + struct roff_man *man; + + man = mandoc_calloc(1, sizeof(*man)); + man->parse = parse; + man->roff = roff; + man->defos = defos; + man->quick = quick; + roff_man_alloc1(man); + return man; +} + +/* --- syntax tree handling ----------------------------------------------- */ + +struct roff_node * +roff_node_alloc(struct roff_man *man, int line, int pos, + enum roff_type type, int tok) +{ + struct roff_node *n; + + n = mandoc_calloc(1, sizeof(*n)); + n->line = line; + n->pos = pos; + n->tok = tok; + n->type = type; + n->sec = man->lastsec; + + if (man->flags & MDOC_SYNOPSIS) + n->flags |= NODE_SYNPRETTY; + else + n->flags &= ~NODE_SYNPRETTY; + if (man->flags & MDOC_NEWLINE) + n->flags |= NODE_LINE; + man->flags &= ~MDOC_NEWLINE; + + return n; +} + +void +roff_node_append(struct roff_man *man, struct roff_node *n) +{ + + switch (man->next) { + case ROFF_NEXT_SIBLING: + if (man->last->next != NULL) { + n->next = man->last->next; + man->last->next->prev = n; + } else + man->last->parent->last = n; + man->last->next = n; + n->prev = man->last; + n->parent = man->last->parent; + break; + case ROFF_NEXT_CHILD: + if (man->last->child != NULL) { + n->next = man->last->child; + man->last->child->prev = n; + } else + man->last->last = n; + man->last->child = n; + n->parent = man->last; + break; + default: + abort(); + } + man->last = n; + + switch (n->type) { + case ROFFT_HEAD: + n->parent->head = n; + break; + case ROFFT_BODY: + if (n->end != ENDBODY_NOT) + return; + n->parent->body = n; + break; + case ROFFT_TAIL: + n->parent->tail = n; + break; + default: + return; + } + + /* + * Copy over the normalised-data pointer of our parent. Not + * everybody has one, but copying a null pointer is fine. + */ + + n->norm = n->parent->norm; + assert(n->parent->type == ROFFT_BLOCK); +} + +void +roff_word_alloc(struct roff_man *man, int line, int pos, const char *word) +{ + struct roff_node *n; + + n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE); + n->string = roff_strdup(man->roff, word); + roff_node_append(man, n); + n->flags |= NODE_VALID | NODE_ENDED; + man->next = ROFF_NEXT_SIBLING; +} + +void +roff_word_append(struct roff_man *man, const char *word) +{ + struct roff_node *n; + char *addstr, *newstr; + + n = man->last; + addstr = roff_strdup(man->roff, word); + mandoc_asprintf(&newstr, "%s %s", n->string, addstr); + free(addstr); + free(n->string); + n->string = newstr; + man->next = ROFF_NEXT_SIBLING; +} + +void +roff_elem_alloc(struct roff_man *man, int line, int pos, int tok) +{ + struct roff_node *n; + + n = roff_node_alloc(man, line, pos, ROFFT_ELEM, tok); + roff_node_append(man, n); + man->next = ROFF_NEXT_CHILD; +} + +struct roff_node * +roff_block_alloc(struct roff_man *man, int line, int pos, int tok) +{ + struct roff_node *n; + + n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok); + roff_node_append(man, n); + man->next = ROFF_NEXT_CHILD; + return n; +} + +struct roff_node * +roff_head_alloc(struct roff_man *man, int line, int pos, int tok) +{ + struct roff_node *n; + + n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok); + roff_node_append(man, n); + man->next = ROFF_NEXT_CHILD; + return n; +} + +struct roff_node * +roff_body_alloc(struct roff_man *man, int line, int pos, int tok) +{ + struct roff_node *n; + + n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok); + roff_node_append(man, n); + man->next = ROFF_NEXT_CHILD; + return n; +} + +void +roff_addeqn(struct roff_man *man, const struct eqn *eqn) +{ + struct roff_node *n; + + n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE); + n->eqn = eqn; + if (eqn->ln > man->last->line) + n->flags |= NODE_LINE; + roff_node_append(man, n); + man->next = ROFF_NEXT_SIBLING; +} + +void +roff_addtbl(struct roff_man *man, const struct tbl_span *tbl) +{ + struct roff_node *n; + + if (man->macroset == MACROSET_MAN) + man_breakscope(man, TOKEN_NONE); + n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE); + n->span = tbl; + roff_node_append(man, n); + n->flags |= NODE_VALID | NODE_ENDED; + man->next = ROFF_NEXT_SIBLING; +} + +void +roff_node_unlink(struct roff_man *man, struct roff_node *n) +{ + + /* Adjust siblings. */ + + if (n->prev) + n->prev->next = n->next; + if (n->next) + n->next->prev = n->prev; + + /* Adjust parent. */ + + if (n->parent != NULL) { + if (n->parent->child == n) + n->parent->child = n->next; + if (n->parent->last == n) + n->parent->last = n->prev; + } + + /* Adjust parse point. */ + + if (man == NULL) + return; + if (man->last == n) { + if (n->prev == NULL) { + man->last = n->parent; + man->next = ROFF_NEXT_CHILD; + } else { + man->last = n->prev; + man->next = ROFF_NEXT_SIBLING; + } + } + if (man->first == n) + man->first = NULL; +} + +void +roff_node_free(struct roff_node *n) +{ + + if (n->args != NULL) + mdoc_argv_free(n->args); + if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM) + free(n->norm); + free(n->string); + free(n); +} + +void +roff_node_delete(struct roff_man *man, struct roff_node *n) +{ + + while (n->child != NULL) + roff_node_delete(man, n->child); + roff_node_unlink(man, n); + roff_node_free(n); +} + +void +deroff(char **dest, const struct roff_node *n) +{ + char *cp; + size_t sz; + + if (n->type != ROFFT_TEXT) { + for (n = n->child; n != NULL; n = n->next) + deroff(dest, n); + return; + } + + /* Skip leading whitespace. */ + + for (cp = n->string; *cp != '\0'; cp++) { + if (cp[0] == '\\' && cp[1] != '\0' && + strchr(" %&0^|~", cp[1]) != NULL) + cp++; + else if ( ! isspace((unsigned char)*cp)) + break; + } + + /* Skip trailing backslash. */ + + sz = strlen(cp); + if (sz > 0 && cp[sz - 1] == '\\') + sz--; + + /* Skip trailing whitespace. */ + + for (; sz; sz--) + if ( ! isspace((unsigned char)cp[sz-1])) + break; + + /* Skip empty strings. */ + + if (sz == 0) + return; + + if (*dest == NULL) { + *dest = mandoc_strndup(cp, sz); + return; + } + + mandoc_asprintf(&cp, "%s %*s", *dest, (int)sz, cp); + free(*dest); + *dest = cp; +} + +/* --- main functions of the roff parser ---------------------------------- */ + /* * In the current line, expand escape sequences that tend to get * used in numerical expressions and conditional requests. @@ -949,7 +1174,6 @@ roff_res(struct roff *r, struct buf *buf, int ln, int res = NULL; break; case 'B': - /* FALLTHROUGH */ case 'w': term = cp[1]; /* FALLTHROUGH */ @@ -960,7 +1184,7 @@ roff_res(struct roff *r, struct buf *buf, int ln, int esc = mandoc_escape(&cp, &stnam, &inaml); if (esc == ESCAPE_ERROR || (esc == ESCAPE_SPECIAL && - mchars_spec2cp(r->mchars, stnam, inaml) < 0)) + mchars_spec2cp(stnam, inaml) < 0)) mandoc_vmsg(MANDOCERR_ESC_BAD, r->parse, ln, (int)(stesc - buf->buf), "%.*s", (int)(cp - stesc), stesc); @@ -970,7 +1194,7 @@ roff_res(struct roff *r, struct buf *buf, int ln, int if (EXPAND_LIMIT < ++expand_count) { mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, ln, (int)(stesc - buf->buf), NULL); - return(ROFF_IGN); + return ROFF_IGN; } /* @@ -1024,11 +1248,8 @@ roff_res(struct roff *r, struct buf *buf, int ln, int } switch (mandoc_escape(&cp, NULL, NULL)) { case ESCAPE_SPECIAL: - /* FALLTHROUGH */ case ESCAPE_UNICODE: - /* FALLTHROUGH */ case ESCAPE_NUMBERED: - /* FALLTHROUGH */ case ESCAPE_OVERSTRIKE: naml++; break; @@ -1050,7 +1271,8 @@ roff_res(struct roff *r, struct buf *buf, int ln, int case 'B': npos = 0; ubuf[0] = arg_complete && - roff_evalnum(r, ln, stnam, &npos, NULL, 0) && + roff_evalnum(r, ln, stnam, &npos, + NULL, ROFFNUM_SCALE) && stnam + npos + 1 == cp ? '1' : '0'; ubuf[1] = '\0'; break; @@ -1076,7 +1298,7 @@ roff_res(struct roff *r, struct buf *buf, int ln, int } else if (buf->sz + strlen(res) > SHRT_MAX) { mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, ln, (int)(stesc - buf->buf), NULL); - return(ROFF_IGN); + return ROFF_IGN; } /* Replace the escape sequence by the string. */ @@ -1092,13 +1314,11 @@ roff_res(struct roff *r, struct buf *buf, int ln, int free(buf->buf); buf->buf = nbuf; } - return(ROFF_CONT); + return ROFF_CONT; } /* - * Process text streams: - * Convert all breakable hyphens into ASCII_HYPH. - * Decrement and spring input line trap. + * Process text streams. */ static enum rofferr roff_parsetext(struct buf *buf, int pos, int *offs) @@ -1109,6 +1329,22 @@ roff_parsetext(struct buf *buf, int pos, int *offs) int isz; enum mandoc_esc esc; + /* Spring the input line trap. */ + + if (roffit_lines == 1) { + isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro); + free(buf->buf); + buf->buf = p; + buf->sz = isz + 1; + *offs = 0; + free(roffit_macro); + roffit_lines = 0; + return ROFF_REPARSE; + } else if (roffit_lines > 1) + --roffit_lines; + + /* Convert all breakable hyphens into ASCII_HYPH. */ + start = p = buf->buf + pos; while (*p != '\0') { @@ -1124,6 +1360,8 @@ roff_parsetext(struct buf *buf, int pos, int *offs) esc = mandoc_escape((const char **)&p, NULL, NULL); if (esc == ESCAPE_ERROR) break; + while (*p == '-') + p++; continue; } else if (p == start) { p++; @@ -1135,26 +1373,13 @@ roff_parsetext(struct buf *buf, int pos, int *offs) *p = ASCII_HYPH; p++; } - - /* Spring the input line trap. */ - if (roffit_lines == 1) { - isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro); - free(buf->buf); - buf->buf = p; - buf->sz = isz + 1; - *offs = 0; - free(roffit_macro); - roffit_lines = 0; - return(ROFF_REPARSE); - } else if (roffit_lines > 1) - --roffit_lines; - return(ROFF_CONT); + return ROFF_CONT; } enum rofferr roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs) { - enum rofft t; + enum roff_tok t; enum rofferr e; int pos; /* parse point */ int spos; /* saved parse point for messages */ @@ -1170,7 +1395,7 @@ roff_parseln(struct roff *r, int ln, struct buf *buf, (r->eqn == NULL || r->eqn_inline)) { e = roff_eqndelim(r, buf, pos); if (e == ROFF_REPARSE) - return(e); + return e; assert(e == ROFF_CONT); } @@ -1178,7 +1403,7 @@ roff_parseln(struct roff *r, int ln, struct buf *buf, e = roff_res(r, buf, ln, pos); if (e == ROFF_IGN) - return(e); + return e; assert(e == ROFF_CONT); ctl = roff_getcontrol(r, buf->buf, &pos); @@ -1193,27 +1418,26 @@ roff_parseln(struct roff *r, int ln, struct buf *buf, if (r->last != NULL && ! ctl) { t = r->last->tok; - assert(roffs[t].text); e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs); - assert(e == ROFF_IGN || e == ROFF_CONT); - if (e != ROFF_CONT) - return(e); + if (e == ROFF_IGN) + return e; + assert(e == ROFF_CONT); } if (r->eqn != NULL) - return(eqn_read(&r->eqn, ln, buf->buf, ppos, offs)); + return eqn_read(&r->eqn, ln, buf->buf, ppos, offs); if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0')) - return(tbl_read(r->tbl, ln, buf->buf, pos)); + return tbl_read(r->tbl, ln, buf->buf, ppos); if ( ! ctl) - return(roff_parsetext(buf, pos, offs)); + return roff_parsetext(buf, pos, offs); /* Skip empty request lines. */ if (buf->buf[pos] == '"') { mandoc_msg(MANDOCERR_COMMENT_BAD, r->parse, ln, pos, NULL); - return(ROFF_IGN); + return ROFF_IGN; } else if (buf->buf[pos] == '\0') - return(ROFF_IGN); + return ROFF_IGN; /* * If a scope is open, go to the child handler for that macro, @@ -1223,8 +1447,7 @@ roff_parseln(struct roff *r, int ln, struct buf *buf, if (r->last) { t = r->last->tok; - assert(roffs[t].sub); - return((*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs)); + return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs); } /* No scope is open. This is a new request or macro. */ @@ -1234,16 +1457,16 @@ roff_parseln(struct roff *r, int ln, struct buf *buf, /* Tables ignore most macros. */ - if (r->tbl != NULL && (t == ROFF_MAX || t == ROFF_TS)) { + if (r->tbl != NULL && (t == TOKEN_NONE || t == ROFF_TS)) { mandoc_msg(MANDOCERR_TBLMACRO, r->parse, ln, pos, buf->buf + spos); if (t == ROFF_TS) - return(ROFF_IGN); + return ROFF_IGN; while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ') pos++; - while (buf->buf[pos] != '\0' && buf->buf[pos] == ' ') + while (buf->buf[pos] == ' ') pos++; - return(tbl_read(r->tbl, ln, buf->buf, pos)); + return tbl_read(r->tbl, ln, buf->buf, pos); } /* @@ -1251,13 +1474,12 @@ roff_parseln(struct roff *r, int ln, struct buf *buf, * Let the standard macro set parsers handle it. */ - if (t == ROFF_MAX) - return(ROFF_CONT); + if (t == TOKEN_NONE) + return ROFF_CONT; /* Execute a roff request or a user defined macro. */ - assert(roffs[t].proc); - return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs)); + return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); } void @@ -1286,18 +1508,18 @@ roff_endparse(struct roff *r) * Parse a roff node's type from the input buffer. This must be in the * form of ".foo xxx" in the usual way. */ -static enum rofft +static enum roff_tok roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos) { char *cp; const char *mac; size_t maclen; - enum rofft t; + enum roff_tok t; cp = buf + *pos; if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp) - return(ROFF_MAX); + return TOKEN_NONE; mac = cp; maclen = roff_getname(r, &cp, ln, ppos); @@ -1305,12 +1527,14 @@ roff_parse(struct roff *r, char *buf, int *pos, int ln t = (r->current_string = roff_getstrn(r, mac, maclen)) ? ROFF_USERDEF : roffhash_find(mac, maclen); - if (ROFF_MAX != t) + if (t != TOKEN_NONE) *pos = cp - buf; - return(t); + return t; } +/* --- handling of request blocks ----------------------------------------- */ + static enum rofferr roff_cblock(ROFF_ARGS) { @@ -1323,26 +1547,22 @@ roff_cblock(ROFF_ARGS) if (r->last == NULL) { mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, ".."); - return(ROFF_IGN); + return ROFF_IGN; } switch (r->last->tok) { case ROFF_am: /* ROFF_am1 is remapped to ROFF_am in roff_block(). */ - /* FALLTHROUGH */ case ROFF_ami: - /* FALLTHROUGH */ case ROFF_de: /* ROFF_de1 is remapped to ROFF_de in roff_block(). */ - /* FALLTHROUGH */ case ROFF_dei: - /* FALLTHROUGH */ case ROFF_ig: break; default: mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, ".."); - return(ROFF_IGN); + return ROFF_IGN; } if (buf->buf[pos] != '\0') @@ -1351,7 +1571,7 @@ roff_cblock(ROFF_ARGS) roffnode_pop(r); roffnode_cleanscope(r); - return(ROFF_IGN); + return ROFF_IGN; } @@ -1378,9 +1598,7 @@ roff_ccond(struct roff *r, int ln, int ppos) switch (r->last->tok) { case ROFF_el: - /* FALLTHROUGH */ case ROFF_ie: - /* FALLTHROUGH */ case ROFF_if: break; default: @@ -1446,7 +1664,7 @@ roff_block(ROFF_ARGS) if (namesz == 0 && tok != ROFF_ig) { mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, roffs[tok].name); - return(ROFF_IGN); + return ROFF_IGN; } roffnode_push(r, tok, name, ln, ppos); @@ -1461,7 +1679,7 @@ roff_block(ROFF_ARGS) roff_setstrn(&r->strtab, name, namesz, "", 0, 0); if (*cp == '\0') - return(ROFF_IGN); + return ROFF_IGN; /* Get the custom end marker. */ @@ -1488,13 +1706,13 @@ roff_block(ROFF_ARGS) mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, ln, pos, ".%s ... %s", roffs[tok].name, cp); - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr roff_block_sub(ROFF_ARGS) { - enum rofft t; + enum roff_tok t; int i, j; /* @@ -1523,9 +1741,9 @@ roff_block_sub(ROFF_ARGS) pos = i; if (roff_parse(r, buf->buf, &pos, ln, ppos) != - ROFF_MAX) - return(ROFF_RERUN); - return(ROFF_IGN); + TOKEN_NONE) + return ROFF_RERUN; + return ROFF_IGN; } } @@ -1539,11 +1757,10 @@ roff_block_sub(ROFF_ARGS) if (t != ROFF_cblock) { if (tok != ROFF_ig) roff_setstr(r, r->last->name, buf->buf + ppos, 2); - return(ROFF_IGN); + return ROFF_IGN; } - assert(roffs[t].proc); - return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs)); + return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); } static enum rofferr @@ -1553,13 +1770,13 @@ roff_block_text(ROFF_ARGS) if (tok != ROFF_ig) roff_setstr(r, r->last->name, buf->buf + pos, 2); - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr roff_cond_sub(ROFF_ARGS) { - enum rofft t; + enum roff_tok t; char *ep; int rr; @@ -1572,11 +1789,8 @@ roff_cond_sub(ROFF_ARGS) * required or when the conditional evaluated to true. */ - if ((t != ROFF_MAX) && - (rr || roffs[t].flags & ROFFMAC_STRUCT)) { - assert(roffs[t].proc); - return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs)); - } + if (t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT)) + return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); /* * If `\}' occurs on a macro line without a preceding macro, @@ -1597,7 +1811,7 @@ roff_cond_sub(ROFF_ARGS) if (*ep != '\0') ++ep; } - return(rr ? ROFF_CONT : ROFF_IGN); + return rr ? ROFF_CONT : ROFF_IGN; } static enum rofferr @@ -1618,9 +1832,11 @@ roff_cond_text(ROFF_ARGS) if (*ep != '\0') ++ep; } - return(rr ? ROFF_CONT : ROFF_IGN); + return rr ? ROFF_CONT : ROFF_IGN; } +/* --- handling of numeric and conditional expressions -------------------- */ + /* * Parse a single signed integer number. Stop at the first non-digit. * If there is at least one digit, return success and advance the @@ -1628,18 +1844,22 @@ roff_cond_text(ROFF_ARGS) * Ignore overflows, treat them just like the C language. */ static int -roff_getnum(const char *v, int *pos, int *res) +roff_getnum(const char *v, int *pos, int *res, int flags) { - int myres, n, p; + int myres, scaled, n, p; if (NULL == res) res = &myres; p = *pos; n = v[p] == '-'; - if (n) + if (n || v[p] == '+') p++; + if (flags & ROFFNUM_WHITE) + while (isspace((unsigned char)v[p])) + p++; + for (*res = 0; isdigit((unsigned char)v[p]); p++) *res = 10 * *res + v[p] - '0'; if (p == *pos + n) @@ -1652,42 +1872,41 @@ roff_getnum(const char *v, int *pos, int *res) switch (v[p]) { case 'f': - *res *= 65536; + scaled = *res * 65536; break; case 'i': - *res *= 240; + scaled = *res * 240; break; case 'c': - *res *= 240; - *res /= 2.54; + scaled = *res * 240 / 2.54; break; case 'v': - /* FALLTROUGH */ case 'P': - *res *= 40; + scaled = *res * 40; break; case 'm': - /* FALLTROUGH */ case 'n': - *res *= 24; + scaled = *res * 24; break; case 'p': - *res *= 10; - *res /= 3; + scaled = *res * 10 / 3; break; case 'u': + scaled = *res; break; case 'M': - *res *= 6; - *res /= 25; + scaled = *res * 6 / 25; break; default: + scaled = *res; p--; break; } + if (flags & ROFFNUM_SCALE) + *res = scaled; *pos = p + 1; - return(1); + return 1; } /* @@ -1730,7 +1949,7 @@ out: else if (*s3 != '\0') s3++; *pos = s3 - v; - return(match); + return match; } /* @@ -1738,8 +1957,10 @@ out: * or string condition. */ static int -roff_evalcond(struct roff *r, int ln, const char *v, int *pos) +roff_evalcond(struct roff *r, int ln, char *v, int *pos) { + char *cp, *name; + size_t sz; int number, savepos, wanttrue; if ('!' == v[*pos]) { @@ -1750,43 +1971,41 @@ roff_evalcond(struct roff *r, int ln, const char *v, i switch (v[*pos]) { case '\0': - return(0); + return 0; case 'n': - /* FALLTHROUGH */ case 'o': (*pos)++; - return(wanttrue); + return wanttrue; case 'c': - /* FALLTHROUGH */ case 'd': - /* FALLTHROUGH */ case 'e': - /* FALLTHROUGH */ - case 'r': - /* FALLTHROUGH */ case 't': - /* FALLTHROUGH */ case 'v': (*pos)++; - return(!wanttrue); + return !wanttrue; + case 'r': + cp = name = v + ++*pos; + sz = roff_getname(r, &cp, ln, *pos); + *pos = cp - v; + return (sz && roff_hasregn(r, name, sz)) == wanttrue; default: break; } savepos = *pos; - if (roff_evalnum(r, ln, v, pos, &number, 0)) - return((number > 0) == wanttrue); + if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE)) + return (number > 0) == wanttrue; else if (*pos == savepos) - return(roff_evalstrcond(v, pos) == wanttrue); + return roff_evalstrcond(v, pos) == wanttrue; else - return (0); + return 0; } static enum rofferr roff_line_ignore(ROFF_ARGS) { - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -1795,7 +2014,7 @@ roff_insec(ROFF_ARGS) mandoc_msg(MANDOCERR_REQ_INSEC, r->parse, ln, ppos, roffs[tok].name); - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -1804,7 +2023,7 @@ roff_unsupp(ROFF_ARGS) mandoc_msg(MANDOCERR_REQ_UNSUPP, r->parse, ln, ppos, roffs[tok].name); - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -1863,6 +2082,8 @@ roff_cond(ROFF_ARGS) if (buf->buf[pos] == '\\' && buf->buf[pos + 1] == '{') { r->last->endspan = -1; pos += 2; + while (buf->buf[pos] == ' ') + pos++; goto out; } @@ -1880,7 +2101,7 @@ roff_cond(ROFF_ARGS) out: *offs = pos; - return(ROFF_RERUN); + return ROFF_RERUN; } static enum rofferr @@ -1905,11 +2126,11 @@ roff_ds(ROFF_ARGS) name = string = buf->buf + pos; if (*name == '\0') - return(ROFF_IGN); + return ROFF_IGN; namesz = roff_getname(r, &string, ln, pos); if (name[namesz] == '\\') - return(ROFF_IGN); + return ROFF_IGN; /* Read past the initial double-quote, if any. */ if (*string == '"') @@ -1918,7 +2139,7 @@ roff_ds(ROFF_ARGS) /* The rest is the value. */ roff_setstrn(&r->strtab, name, namesz, string, strlen(string), ROFF_as == tok); - return(ROFF_IGN); + return ROFF_IGN; } /* @@ -1934,17 +2155,11 @@ roff_getop(const char *v, int *pos, char *res) switch (*res) { case '+': - /* FALLTHROUGH */ case '-': - /* FALLTHROUGH */ case '*': - /* FALLTHROUGH */ case '/': - /* FALLTHROUGH */ case '%': - /* FALLTHROUGH */ case '&': - /* FALLTHROUGH */ case ':': break; case '<': @@ -1984,11 +2199,11 @@ roff_getop(const char *v, int *pos, char *res) (*pos)++; break; default: - return(0); + return 0; } (*pos)++; - return(*res); + return *res; } /* @@ -1997,15 +2212,15 @@ roff_getop(const char *v, int *pos, char *res) */ static int roff_evalpar(struct roff *r, int ln, - const char *v, int *pos, int *res) + const char *v, int *pos, int *res, int flags) { if ('(' != v[*pos]) - return(roff_getnum(v, pos, res)); + return roff_getnum(v, pos, res, flags); (*pos)++; - if ( ! roff_evalnum(r, ln, v, pos, res, 1)) - return(0); + if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE)) + return 0; /* * Omission of the closing parenthesis @@ -2016,9 +2231,9 @@ roff_evalpar(struct roff *r, int ln, if (')' == v[*pos]) (*pos)++; else if (NULL == res) - return(0); + return 0; - return(1); + return 1; } /* @@ -2027,7 +2242,7 @@ roff_evalpar(struct roff *r, int ln, */ static int roff_evalnum(struct roff *r, int ln, const char *v, - int *pos, int *res, int skipwhite) + int *pos, int *res, int flags) { int mypos, operand2; char operator; @@ -2037,29 +2252,29 @@ roff_evalnum(struct roff *r, int ln, const char *v, pos = &mypos; } - if (skipwhite) + if (flags & ROFFNUM_WHITE) while (isspace((unsigned char)v[*pos])) (*pos)++; - if ( ! roff_evalpar(r, ln, v, pos, res)) - return(0); + if ( ! roff_evalpar(r, ln, v, pos, res, flags)) + return 0; while (1) { - if (skipwhite) + if (flags & ROFFNUM_WHITE) while (isspace((unsigned char)v[*pos])) (*pos)++; if ( ! roff_getop(v, pos, &operator)) break; - if (skipwhite) + if (flags & ROFFNUM_WHITE) while (isspace((unsigned char)v[*pos])) (*pos)++; - if ( ! roff_evalpar(r, ln, v, pos, &operand2)) - return(0); + if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags)) + return 0; - if (skipwhite) + if (flags & ROFFNUM_WHITE) while (isspace((unsigned char)v[*pos])) (*pos)++; @@ -2130,9 +2345,11 @@ roff_evalnum(struct roff *r, int ln, const char *v, abort(); } } - return(1); + return 1; } +/* --- register management ------------------------------------------------ */ + void roff_setreg(struct roff *r, const char *name, int val, char sign) { @@ -2169,24 +2386,26 @@ roff_setreg(struct roff *r, const char *name, int val, * were to turn up, another special value would have to be chosen. */ static int -roff_getregro(const char *name) +roff_getregro(const struct roff *r, const char *name) { switch (*name) { + case '$': /* Number of arguments of the last macro evaluated. */ + return r->argc; case 'A': /* ASCII approximation mode is always off. */ - return(0); + return 0; case 'g': /* Groff compatibility mode is always on. */ - return(1); + return 1; case 'H': /* Fixed horizontal resolution. */ - return (24); + return 24; case 'j': /* Always adjust left margin only. */ - return(0); + return 0; case 'T': /* Some output device is always defined. */ - return(1); + return 1; case 'V': /* Fixed vertical resolution. */ - return (40); + return 40; default: - return (-1); + return -1; } } @@ -2197,16 +2416,16 @@ roff_getreg(const struct roff *r, const char *name) int val; if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) { - val = roff_getregro(name + 1); + val = roff_getregro(r, name + 1); if (-1 != val) - return (val); + return val; } for (reg = r->regtab; reg; reg = reg->next) if (0 == strcmp(name, reg->key.p)) - return(reg->val); + return reg->val; - return(0); + return 0; } static int @@ -2216,19 +2435,39 @@ roff_getregn(const struct roff *r, const char *name, s int val; if ('.' == name[0] && 2 == len) { - val = roff_getregro(name + 1); + val = roff_getregro(r, name + 1); if (-1 != val) - return (val); + return val; } for (reg = r->regtab; reg; reg = reg->next) if (len == reg->key.sz && 0 == strncmp(name, reg->key.p, len)) - return(reg->val); + return reg->val; - return(0); + return 0; } +static int +roff_hasregn(const struct roff *r, const char *name, size_t len) +{ + struct roffreg *reg; + int val; + + if ('.' == name[0] && 2 == len) { + val = roff_getregro(r, name + 1); + if (-1 != val) + return 1; + } + + for (reg = r->regtab; reg; reg = reg->next) + if (len == reg->key.sz && + 0 == strncmp(name, reg->key.p, len)) + return 1; + + return 0; +} + static void roff_freereg(struct roffreg *reg) { @@ -2252,21 +2491,21 @@ roff_nr(ROFF_ARGS) key = val = buf->buf + pos; if (*key == '\0') - return(ROFF_IGN); + return ROFF_IGN; keysz = roff_getname(r, &val, ln, pos); if (key[keysz] == '\\') - return(ROFF_IGN); + return ROFF_IGN; key[keysz] = '\0'; sign = *val; if (sign == '+' || sign == '-') val++; - if (roff_evalnum(r, ln, val, NULL, &iv, 0)) + if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE)) roff_setreg(r, key, iv, sign); - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -2278,7 +2517,7 @@ roff_rr(ROFF_ARGS) name = cp = buf->buf + pos; if (*name == '\0') - return(ROFF_IGN); + return ROFF_IGN; namesz = roff_getname(r, &cp, ln, pos); name[namesz] = '\0'; @@ -2294,9 +2533,11 @@ roff_rr(ROFF_ARGS) free(reg->key.p); free(reg); } - return(ROFF_IGN); + return ROFF_IGN; } +/* --- handler functions for roff requests -------------------------------- */ + static enum rofferr roff_rm(ROFF_ARGS) { @@ -2312,31 +2553,36 @@ roff_rm(ROFF_ARGS) if (name[namesz] == '\\') break; } - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr roff_it(ROFF_ARGS) { - char *cp; - size_t len; int iv; /* Parse the number of lines. */ - cp = buf->buf + pos; - len = strcspn(cp, " \t"); - cp[len] = '\0'; - if ((iv = mandoc_strntoi(cp, len, 10)) <= 0) { + + if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) { mandoc_msg(MANDOCERR_IT_NONUM, r->parse, ln, ppos, buf->buf + 1); - return(ROFF_IGN); + return ROFF_IGN; } - cp += len + 1; - /* Arm the input line trap. */ + while (isspace((unsigned char)buf->buf[pos])) + pos++; + + /* + * Arm the input line trap. + * Special-casing "an-trap" is an ugly workaround to cope + * with DocBook stupidly fiddling with man(7) internals. + */ + roffit_lines = iv; - roffit_macro = mandoc_strdup(cp); - return(ROFF_IGN); + roffit_macro = mandoc_strdup(iv != 1 || + strcmp(buf->buf + pos, "an-trap") ? + buf->buf + pos : "br"); + return ROFF_IGN; } static enum rofferr @@ -2351,7 +2597,7 @@ roff_Dd(ROFF_ARGS) if (r->format == 0) r->format = MPARSE_MDOC; - return(ROFF_CONT); + return ROFF_CONT; } static enum rofferr @@ -2366,7 +2612,7 @@ roff_TH(ROFF_ARGS) if (r->format == 0) r->format = MPARSE_MAN; - return(ROFF_CONT); + return ROFF_CONT; } static enum rofferr @@ -2376,10 +2622,13 @@ roff_TE(ROFF_ARGS) if (NULL == r->tbl) mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "TE"); - else - tbl_end(&r->tbl); - - return(ROFF_IGN); + else if ( ! tbl_end(&r->tbl)) { + free(buf->buf); + buf->buf = mandoc_strdup(".sp"); + buf->sz = 4; + return ROFF_REPARSE; + } + return ROFF_IGN; } static enum rofferr @@ -2392,7 +2641,7 @@ roff_T_(ROFF_ARGS) else tbl_restart(ppos, ln, r->tbl); - return(ROFF_IGN); + return ROFF_IGN; } /* @@ -2415,7 +2664,7 @@ roff_eqndelim(struct roff *r, struct buf *buf, int pos cp2 = strchr(cp1, r->eqn == NULL ? r->last_eqn->odelim : r->last_eqn->cdelim); if (cp2 == NULL) - return(ROFF_CONT); + return ROFF_CONT; *cp2++ = '\0'; bef_pr = bef_nl = aft_nl = aft_pr = ""; @@ -2458,7 +2707,7 @@ roff_eqndelim(struct roff *r, struct buf *buf, int pos /* Toggle the in-line state of the eqn subsystem. */ r->eqn_inline = r->eqn == NULL; - return(ROFF_REPARSE); + return ROFF_REPARSE; } static enum rofferr @@ -2483,7 +2732,7 @@ roff_EQ(ROFF_ARGS) mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, ".EQ %s", buf->buf + pos); - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -2491,7 +2740,7 @@ roff_EN(ROFF_ARGS) { mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN"); - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -2513,7 +2762,7 @@ roff_TS(ROFF_ARGS) r->first_tbl = r->last_tbl = tbl; r->tbl = r->last_tbl = tbl; - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -2521,7 +2770,7 @@ roff_brp(ROFF_ARGS) { buf->buf[pos - 1] = '\0'; - return(ROFF_CONT); + return ROFF_CONT; } static enum rofferr @@ -2535,9 +2784,10 @@ roff_cc(ROFF_ARGS) r->control = 0; if (*p != '\0') - mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL); + mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, + ln, p - buf->buf, "cc ... %s", p); - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -2550,8 +2800,8 @@ roff_tr(ROFF_ARGS) p = buf->buf + pos; if (*p == '\0') { - mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL); - return(ROFF_IGN); + mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr"); + return ROFF_IGN; } while (*p != '\0') { @@ -2563,7 +2813,7 @@ roff_tr(ROFF_ARGS) if (esc == ESCAPE_ERROR) { mandoc_msg(MANDOCERR_ESC_BAD, r->parse, ln, (int)(p - buf->buf), first); - return(ROFF_IGN); + return ROFF_IGN; } fsz = (size_t)(p - first); } @@ -2574,12 +2824,12 @@ roff_tr(ROFF_ARGS) if (esc == ESCAPE_ERROR) { mandoc_msg(MANDOCERR_ESC_BAD, r->parse, ln, (int)(p - buf->buf), second); - return(ROFF_IGN); + return ROFF_IGN; } ssz = (size_t)(p - second); } else if (*second == '\0') { - mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, - ln, (int)(p - buf->buf), NULL); + mandoc_vmsg(MANDOCERR_TR_ODD, r->parse, + ln, first - buf->buf, "tr %s", first); second = " "; p--; } @@ -2599,7 +2849,7 @@ roff_tr(ROFF_ARGS) r->xtab[(int)*first].sz = ssz; } - return(ROFF_IGN); + return ROFF_IGN; } static enum rofferr @@ -2625,61 +2875,155 @@ roff_so(ROFF_ARGS) free(buf->buf); buf->buf = cp; *offs = 0; - return(ROFF_REPARSE); + return ROFF_REPARSE; } *offs = pos; - return(ROFF_SO); + return ROFF_SO; } +/* --- user defined strings and macros ------------------------------------ */ + static enum rofferr roff_userdef(ROFF_ARGS) { - const char *arg[9]; + const char *arg[9], *ap; char *cp, *n1, *n2; - int i; + int expand_count, i, ib, ie; + size_t asz, rsz; /* * Collect pointers to macro argument strings * and NUL-terminate them. */ + + r->argc = 0; cp = buf->buf + pos; - for (i = 0; i < 9; i++) - arg[i] = *cp == '\0' ? "" : - mandoc_getarg(r->parse, &cp, ln, &pos); + for (i = 0; i < 9; i++) { + if (*cp == '\0') + arg[i] = ""; + else { + arg[i] = mandoc_getarg(r->parse, &cp, ln, &pos); + r->argc = i + 1; + } + } /* * Expand macro arguments. */ - buf->sz = 0; - n1 = cp = mandoc_strdup(r->current_string); - while ((cp = strstr(cp, "\\$")) != NULL) { - i = cp[2] - '1'; - if (0 > i || 8 < i) { - /* Not an argument invocation. */ - cp += 2; + + buf->sz = strlen(r->current_string) + 1; + n1 = n2 = cp = mandoc_malloc(buf->sz); + memcpy(n1, r->current_string, buf->sz); + expand_count = 0; + while (*cp != '\0') { + + /* Scan ahead for the next argument invocation. */ + + if (*cp++ != '\\') continue; + if (*cp++ != '$') + continue; + if (*cp == '*') { /* \\$* inserts all arguments */ + ib = 0; + ie = r->argc - 1; + } else { /* \\$1 .. \\$9 insert one argument */ + ib = ie = *cp - '1'; + if (ib < 0 || ib > 8) + continue; } - *cp = '\0'; - buf->sz = mandoc_asprintf(&n2, "%s%s%s", - n1, arg[i], cp + 3) + 1; - cp = n2 + (cp - n1); - free(n1); - n1 = n2; + cp -= 2; + + /* + * Prevent infinite recursion. + */ + + if (cp >= n2) + expand_count = 1; + else if (++expand_count > EXPAND_LIMIT) { + mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, + ln, (int)(cp - n1), NULL); + free(buf->buf); + buf->buf = n1; + return ROFF_IGN; + } + + /* + * Determine the size of the expanded argument, + * taking escaping of quotes into account. + */ + + asz = ie > ib ? ie - ib : 0; /* for blanks */ + for (i = ib; i <= ie; i++) { + for (ap = arg[i]; *ap != '\0'; ap++) { + asz++; + if (*ap == '"') + asz += 3; + } + } + if (asz != 3) { + + /* + * Determine the size of the rest of the + * unexpanded macro, including the NUL. + */ + + rsz = buf->sz - (cp - n1) - 3; + + /* + * When shrinking, move before + * releasing the storage. + */ + + if (asz < 3) + memmove(cp + asz, cp + 3, rsz); + + /* + * Resize the storage for the macro + * and readjust the parse pointer. + */ + + buf->sz += asz - 3; + n2 = mandoc_realloc(n1, buf->sz); + cp = n2 + (cp - n1); + n1 = n2; + + /* + * When growing, make room + * for the expanded argument. + */ + + if (asz > 3) + memmove(cp + asz, cp + 3, rsz); + } + + /* Copy the expanded argument, escaping quotes. */ + + n2 = cp; + for (i = ib; i <= ie; i++) { + for (ap = arg[i]; *ap != '\0'; ap++) { + if (*ap == '"') { + memcpy(n2, "\\(dq", 4); + n2 += 4; + } else + *n2++ = *ap; + } + if (i < ie) + *n2++ = ' '; + } } /* * Replace the macro invocation * by the expanded macro. */ + free(buf->buf); buf->buf = n1; - if (buf->sz == 0) - buf->sz = strlen(buf->buf) + 1; *offs = 0; - return(buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ? - ROFF_REPARSE : ROFF_APPEND); + return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ? + ROFF_REPARSE : ROFF_APPEND; } static size_t @@ -2690,7 +3034,7 @@ roff_getname(struct roff *r, char **cpp, int ln, int p name = *cpp; if ('\0' == *name) - return(0); + return 0; /* Read until end of name and terminate it with NUL. */ for (cp = name; 1; cp++) { @@ -2717,7 +3061,7 @@ roff_getname(struct roff *r, char **cpp, int ln, int p cp++; *cpp = cp; - return(namesz); + return namesz; } /* @@ -2817,14 +3161,14 @@ roff_getstrn(const struct roff *r, const char *name, s for (n = r->strtab; n; n = n->next) if (0 == strncmp(name, n->key.p, len) && '\0' == n->key.p[(int)len]) - return(n->val.p); + return n->val.p; for (i = 0; i < PREDEFS_MAX; i++) if (0 == strncmp(name, predefs[i].name, len) && '\0' == predefs[i].name[(int)len]) - return(predefs[i].str); + return predefs[i].str; - return(NULL); + return NULL; } static void @@ -2840,18 +3184,20 @@ roff_freestr(struct roffkv *r) } } +/* --- accessors and utility functions ------------------------------------ */ + const struct tbl_span * roff_span(const struct roff *r) { - return(r->tbl ? tbl_span(r->tbl) : NULL); + return r->tbl ? tbl_span(r->tbl) : NULL; } const struct eqn * roff_eqn(const struct roff *r) { - return(r->last_eqn ? &r->last_eqn->eqn : NULL); + return r->last_eqn ? &r->last_eqn->eqn : NULL; } /* @@ -2869,9 +3215,9 @@ roff_strdup(const struct roff *r, const char *p) enum mandoc_esc esc; if (NULL == r->xmbtab && NULL == r->xtab) - return(mandoc_strdup(p)); + return mandoc_strdup(p); else if ('\0' == *p) - return(mandoc_strdup("")); + return mandoc_strdup(""); /* * Step through each character looking for term matches @@ -2885,7 +3231,8 @@ roff_strdup(const struct roff *r, const char *p) ssz = 0; while ('\0' != *p) { - if ('\\' != *p && r->xtab && r->xtab[(int)*p].p) { + assert((unsigned int)*p < 128); + if ('\\' != *p && r->xtab && r->xtab[(unsigned int)*p].p) { sz = r->xtab[(int)*p].sz; res = mandoc_realloc(res, ssz + sz + 1); memcpy(res + ssz, r->xtab[(int)*p].p, sz); @@ -2943,14 +3290,14 @@ roff_strdup(const struct roff *r, const char *p) } res[(int)ssz] = '\0'; - return(res); + return res; } int roff_getformat(const struct roff *r) { - return(r->format); + return r->format; } /* @@ -2973,17 +3320,17 @@ roff_getcontrol(const struct roff *r, const char *cp, if (0 != r->control && cp[pos] == r->control) pos++; else if (0 != r->control) - return(0); + return 0; else if ('\\' == cp[pos] && '.' == cp[pos + 1]) pos += 2; else if ('.' == cp[pos] || '\'' == cp[pos]) pos++; else - return(0); + return 0; while (' ' == cp[pos] || '\t' == cp[pos]) pos++; *ppos = pos; - return(1); + return 1; }