contrib/mdocml/roff.c

   1 /*      $Id: roff.c,v 1.306 2017/06/07 00:50:34 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010-2015, 2017 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include "config.h"
  19
  20 #include <sys/types.h>
  21
  22 #include <assert.h>
  23 #include <ctype.h>
  24 #include <limits.h>
  25 #include <stddef.h>
  26 #include <stdint.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "mandoc.h"
  32 #include "mandoc_aux.h"
  33 #include "mandoc_ohash.h"
  34 #include "roff.h"
  35 #include "libmandoc.h"
  36 #include "roff_int.h"
  37 #include "libroff.h"
  38
  39 /* Maximum number of string expansions per line, to break infinite loops. */
  40 #define EXPAND_LIMIT    1000
  41
  42 /* --- data types --------------------------------------------------------- */
  43
  44 /*
  45  * An incredibly-simple string buffer.
  46  */
  47 struct  roffstr {
  48         char            *p; /* nil-terminated buffer */
  49         size_t           sz; /* saved strlen(p) */
  50 };
  51
  52 /*
  53  * A key-value roffstr pair as part of a singly-linked list.
  54  */
  55 struct  roffkv {
  56         struct roffstr   key;
  57         struct roffstr   val;
  58         struct roffkv   *next; /* next in list */
  59 };
  60
  61 /*
  62  * A single number register as part of a singly-linked list.
  63  */
  64 struct  roffreg {
  65         struct roffstr   key;
  66         int              val;
  67         struct roffreg  *next;
  68 };
  69
  70 /*
  71  * Association of request and macro names with token IDs.
  72  */
  73 struct  roffreq {
  74         enum roff_tok    tok;
  75         char             name[];
  76 };
  77
  78 struct  roff {
  79         struct mparse   *parse; /* parse point */
  80         struct roff_man *man; /* mdoc or man parser */
  81         struct roffnode *last; /* leaf of stack */
  82         int             *rstack; /* stack of inverted `ie' values */
  83         struct ohash    *reqtab; /* request lookup table */
  84         struct roffreg  *regtab; /* number registers */
  85         struct roffkv   *strtab; /* user-defined strings & macros */
  86         struct roffkv   *rentab; /* renamed strings & macros */
  87         struct roffkv   *xmbtab; /* multi-byte trans table (`tr') */
  88         struct roffstr  *xtab; /* single-byte trans table (`tr') */
  89         const char      *current_string; /* value of last called user macro */
  90         struct tbl_node *first_tbl; /* first table parsed */
  91         struct tbl_node *last_tbl; /* last table parsed */
  92         struct tbl_node *tbl; /* current table being parsed */
  93         struct eqn_node *last_eqn; /* last equation parsed */
  94         struct eqn_node *first_eqn; /* first equation parsed */
  95         struct eqn_node *eqn; /* current equation being parsed */
  96         int              eqn_inline; /* current equation is inline */
  97         int              options; /* parse options */
  98         int              rstacksz; /* current size limit of rstack */
  99         int              rstackpos; /* position in rstack */
 100         int              format; /* current file in mdoc or man format */
 101         int              argc; /* number of args of the last macro */
 102         char             control; /* control character */
 103         char             escape; /* escape character */
 104 };
 105
 106 struct  roffnode {
 107         enum roff_tok    tok; /* type of node */
 108         struct roffnode *parent; /* up one in stack */
 109         int              line; /* parse line */
 110         int              col; /* parse col */
 111         char            *name; /* node name, e.g. macro name */
 112         char            *end; /* end-rules: custom token */
 113         int              endspan; /* end-rules: next-line or infty */
 114         int              rule; /* current evaluation rule */
 115 };
 116
 117 #define ROFF_ARGS        struct roff *r, /* parse ctx */ \
 118                          enum roff_tok tok, /* tok of macro */ \
 119                          struct buf *buf, /* input buffer */ \
 120                          int ln, /* parse line */ \
 121                          int ppos, /* original pos in buffer */ \
 122                          int pos, /* current pos in buffer */ \
 123                          int *offs /* reset offset of buffer data */
 124
 125 typedef enum rofferr (*roffproc)(ROFF_ARGS);
 126
 127 struct  roffmac {
 128         roffproc         proc; /* process new macro */
 129         roffproc         text; /* process as child text of macro */
 130         roffproc         sub; /* process as child of macro */
 131         int              flags;
 132 #define ROFFMAC_STRUCT  (1 << 0) /* always interpret */
 133 };
 134
 135 struct  predef {
 136         const char      *name; /* predefined input name */
 137         const char      *str; /* replacement symbol */
 138 };
 139
 140 #define PREDEF(__name, __str) \
 141         { (__name), (__str) },
 142
 143 /* --- function prototypes ------------------------------------------------ */
 144
 145 static  void             roffnode_cleanscope(struct roff *);
 146 static  void             roffnode_pop(struct roff *);
 147 static  void             roffnode_push(struct roff *, enum roff_tok,
 148                                 const char *, int, int);
 149 static  enum rofferr     roff_block(ROFF_ARGS);
 150 static  enum rofferr     roff_block_text(ROFF_ARGS);
 151 static  enum rofferr     roff_block_sub(ROFF_ARGS);
 152 static  enum rofferr     roff_br(ROFF_ARGS);
 153 static  enum rofferr     roff_cblock(ROFF_ARGS);
 154 static  enum rofferr     roff_cc(ROFF_ARGS);
 155 static  void             roff_ccond(struct roff *, int, int);
 156 static  enum rofferr     roff_cond(ROFF_ARGS);
 157 static  enum rofferr     roff_cond_text(ROFF_ARGS);
 158 static  enum rofferr     roff_cond_sub(ROFF_ARGS);
 159 static  enum rofferr     roff_ds(ROFF_ARGS);
 160 static  enum rofferr     roff_ec(ROFF_ARGS);
 161 static  enum rofferr     roff_eo(ROFF_ARGS);
 162 static  enum rofferr     roff_eqndelim(struct roff *, struct buf *, int);
 163 static  int              roff_evalcond(struct roff *r, int, char *, int *);
 164 static  int              roff_evalnum(struct roff *, int,
 165                                 const char *, int *, int *, int);
 166 static  int              roff_evalpar(struct roff *, int,
 167                                 const char *, int *, int *, int);
 168 static  int              roff_evalstrcond(const char *, int *);
 169 static  void             roff_free1(struct roff *);
 170 static  void             roff_freereg(struct roffreg *);
 171 static  void             roff_freestr(struct roffkv *);
 172 static  size_t           roff_getname(struct roff *, char **, int, int);
 173 static  int              roff_getnum(const char *, int *, int *, int);
 174 static  int              roff_getop(const char *, int *, char *);
 175 static  int              roff_getregn(const struct roff *,
 176                                 const char *, size_t);
 177 static  int              roff_getregro(const struct roff *,
 178                                 const char *name);
 179 static  const char      *roff_getrenn(const struct roff *,
 180                                 const char *, size_t);
 181 static  const char      *roff_getstrn(const struct roff *,
 182                                 const char *, size_t);
 183 static  int              roff_hasregn(const struct roff *,
 184                                 const char *, size_t);
 185 static  enum rofferr     roff_insec(ROFF_ARGS);
 186 static  enum rofferr     roff_it(ROFF_ARGS);
 187 static  enum rofferr     roff_line_ignore(ROFF_ARGS);
 188 static  void             roff_man_alloc1(struct roff_man *);
 189 static  void             roff_man_free1(struct roff_man *);
 190 static  enum rofferr     roff_manyarg(ROFF_ARGS);
 191 static  enum rofferr     roff_nr(ROFF_ARGS);
 192 static  enum rofferr     roff_onearg(ROFF_ARGS);
 193 static  enum roff_tok    roff_parse(struct roff *, char *, int *,
 194                                 int, int);
 195 static  enum rofferr     roff_parsetext(struct roff *, struct buf *,
 196                                 int, int *);
 197 static  enum rofferr     roff_renamed(ROFF_ARGS);
 198 static  enum rofferr     roff_res(struct roff *, struct buf *, int, int);
 199 static  enum rofferr     roff_rm(ROFF_ARGS);
 200 static  enum rofferr     roff_rn(ROFF_ARGS);
 201 static  enum rofferr     roff_rr(ROFF_ARGS);
 202 static  void             roff_setstr(struct roff *,
 203                                 const char *, const char *, int);
 204 static  void             roff_setstrn(struct roffkv **, const char *,
 205                                 size_t, const char *, size_t, int);
 206 static  enum rofferr     roff_so(ROFF_ARGS);
 207 static  enum rofferr     roff_tr(ROFF_ARGS);
 208 static  enum rofferr     roff_Dd(ROFF_ARGS);
 209 static  enum rofferr     roff_TH(ROFF_ARGS);
 210 static  enum rofferr     roff_TE(ROFF_ARGS);
 211 static  enum rofferr     roff_TS(ROFF_ARGS);
 212 static  enum rofferr     roff_EQ(ROFF_ARGS);
 213 static  enum rofferr     roff_EN(ROFF_ARGS);
 214 static  enum rofferr     roff_T_(ROFF_ARGS);
 215 static  enum rofferr     roff_unsupp(ROFF_ARGS);
 216 static  enum rofferr     roff_userdef(ROFF_ARGS);
 217
 218 /* --- constant data ------------------------------------------------------ */
 219
 220 #define ROFFNUM_SCALE   (1 << 0)  /* Honour scaling in roff_getnum(). */
 221 #define ROFFNUM_WHITE   (1 << 1)  /* Skip whitespace in roff_evalnum(). */
 222
 223 const char *__roff_name[MAN_MAX + 1] = {
 224         "br",           "ce",           "ft",           "ll",
 225         "mc",           "sp",           "ta",           "ti",
 226         NULL,
 227         "ab",           "ad",           "af",           "aln",
 228         "als",          "am",           "am1",          "ami",
 229         "ami1",         "as",           "as1",          "asciify",
 230         "backtrace",    "bd",           "bleedat",      "blm",
 231         "box",          "boxa",         "bp",           "BP",
 232         "break",        "breakchar",    "brnl",         "brp",
 233         "brpnl",        "c2",           "cc",
 234         "cf",           "cflags",       "ch",           "char",
 235         "chop",         "class",        "close",        "CL",
 236         "color",        "composite",    "continue",     "cp",
 237         "cropat",       "cs",           "cu",           "da",
 238         "dch",          "Dd",           "de",           "de1",
 239         "defcolor",     "dei",          "dei1",         "device",
 240         "devicem",      "di",           "do",           "ds",
 241         "ds1",          "dwh",          "dt",           "ec",
 242         "ecr",          "ecs",          "el",           "em",
 243         "EN",           "eo",           "EP",           "EQ",
 244         "errprint",     "ev",           "evc",          "ex",
 245         "fallback",     "fam",          "fc",           "fchar",
 246         "fcolor",       "fdeferlig",    "feature",      "fkern",
 247         "fl",           "flig",         "fp",           "fps",
 248         "fschar",       "fspacewidth",  "fspecial",     "ftr",
 249         "fzoom",        "gcolor",       "hc",           "hcode",
 250         "hidechar",     "hla",          "hlm",          "hpf",
 251         "hpfa",         "hpfcode",      "hw",           "hy",
 252         "hylang",       "hylen",        "hym",          "hypp",
 253         "hys",          "ie",           "if",           "ig",
 254         "index",        "it",           "itc",          "IX",
 255         "kern",         "kernafter",    "kernbefore",   "kernpair",
 256         "lc",           "lc_ctype",     "lds",          "length",
 257         "letadj",       "lf",           "lg",           "lhang",
 258         "linetabs",     "lnr",          "lnrf",         "lpfx",
 259         "ls",           "lsm",          "lt",
 260         "mediasize",    "minss",        "mk",           "mso",
 261         "na",           "ne",           "nh",           "nhychar",
 262         "nm",           "nn",           "nop",          "nr",
 263         "nrf",          "nroff",        "ns",           "nx",
 264         "open",         "opena",        "os",           "output",
 265         "padj",         "papersize",    "pc",           "pev",
 266         "pi",           "PI",           "pl",           "pm",
 267         "pn",           "pnr",          "po",           "ps",
 268         "psbb",         "pshape",       "pso",          "ptr",
 269         "pvs",          "rchar",        "rd",           "recursionlimit",
 270         "return",       "rfschar",      "rhang",        "rj",
 271         "rm",           "rn",           "rnn",          "rr",
 272         "rs",           "rt",           "schar",        "sentchar",
 273         "shc",          "shift",        "sizes",        "so",
 274         "spacewidth",   "special",      "spreadwarn",   "ss",
 275         "sty",          "substring",    "sv",           "sy",
 276         "T&",           "tc",           "TE",
 277         "TH",           "tkf",          "tl",
 278         "tm",           "tm1",          "tmc",          "tr",
 279         "track",        "transchar",    "trf",          "trimat",
 280         "trin",         "trnt",         "troff",        "TS",
 281         "uf",           "ul",           "unformat",     "unwatch",
 282         "unwatchn",     "vpt",          "vs",           "warn",
 283         "warnscale",    "watch",        "watchlength",  "watchn",
 284         "wh",           "while",        "write",        "writec",
 285         "writem",       "xflag",        ".",            NULL,
 286         NULL,           "text",
 287         "Dd",           "Dt",           "Os",           "Sh",
 288         "Ss",           "Pp",           "D1",           "Dl",
 289         "Bd",           "Ed",           "Bl",           "El",
 290         "It",           "Ad",           "An",           "Ap",
 291         "Ar",           "Cd",           "Cm",           "Dv",
 292         "Er",           "Ev",           "Ex",           "Fa",
 293         "Fd",           "Fl",           "Fn",           "Ft",
 294         "Ic",           "In",           "Li",           "Nd",
 295         "Nm",           "Op",           "Ot",           "Pa",
 296         "Rv",           "St",           "Va",           "Vt",
 297         "Xr",           "%A",           "%B",           "%D",
 298         "%I",           "%J",           "%N",           "%O",
 299         "%P",           "%R",           "%T",           "%V",
 300         "Ac",           "Ao",           "Aq",           "At",
 301         "Bc",           "Bf",           "Bo",           "Bq",
 302         "Bsx",          "Bx",           "Db",           "Dc",
 303         "Do",           "Dq",           "Ec",           "Ef",
 304         "Em",           "Eo",           "Fx",           "Ms",
 305         "No",           "Ns",           "Nx",           "Ox",
 306         "Pc",           "Pf",           "Po",           "Pq",
 307         "Qc",           "Ql",           "Qo",           "Qq",
 308         "Re",           "Rs",           "Sc",           "So",
 309         "Sq",           "Sm",           "Sx",           "Sy",
 310         "Tn",           "Ux",           "Xc",           "Xo",
 311         "Fo",           "Fc",           "Oo",           "Oc",
 312         "Bk",           "Ek",           "Bt",           "Hf",
 313         "Fr",           "Ud",           "Lb",           "Lp",
 314         "Lk",           "Mt",           "Brq",          "Bro",
 315         "Brc",          "%C",           "Es",           "En",
 316         "Dx",           "%Q",           "%U",           "Ta",
 317         NULL,
 318         "TH",           "SH",           "SS",           "TP",
 319         "LP",           "PP",           "P",            "IP",
 320         "HP",           "SM",           "SB",           "BI",
 321         "IB",           "BR",           "RB",           "R",
 322         "B",            "I",            "IR",           "RI",
 323         "nf",           "fi",
 324         "RE",           "RS",           "DT",           "UC",
 325         "PD",           "AT",           "in",
 326         "OP",           "EX",           "EE",           "UR",
 327         "UE",           NULL
 328 };
 329 const   char *const *roff_name = __roff_name;
 330
 331 static  struct roffmac   roffs[TOKEN_NONE] = {
 332         { roff_br, NULL, NULL, 0 },  /* br */
 333         { roff_onearg, NULL, NULL, 0 },  /* ce */
 334         { roff_onearg, NULL, NULL, 0 },  /* ft */
 335         { roff_onearg, NULL, NULL, 0 },  /* ll */
 336         { roff_onearg, NULL, NULL, 0 },  /* mc */
 337         { roff_onearg, NULL, NULL, 0 },  /* sp */
 338         { roff_manyarg, NULL, NULL, 0 },  /* ta */
 339         { roff_onearg, NULL, NULL, 0 },  /* ti */
 340         { NULL, NULL, NULL, 0 },  /* ROFF_MAX */
 341         { roff_unsupp, NULL, NULL, 0 },  /* ab */
 342         { roff_line_ignore, NULL, NULL, 0 },  /* ad */
 343         { roff_line_ignore, NULL, NULL, 0 },  /* af */
 344         { roff_unsupp, NULL, NULL, 0 },  /* aln */
 345         { roff_unsupp, NULL, NULL, 0 },  /* als */
 346         { roff_block, roff_block_text, roff_block_sub, 0 },  /* am */
 347         { roff_block, roff_block_text, roff_block_sub, 0 },  /* am1 */
 348         { roff_block, roff_block_text, roff_block_sub, 0 },  /* ami */
 349         { roff_block, roff_block_text, roff_block_sub, 0 },  /* ami1 */
 350         { roff_ds, NULL, NULL, 0 },  /* as */
 351         { roff_ds, NULL, NULL, 0 },  /* as1 */
 352         { roff_unsupp, NULL, NULL, 0 },  /* asciify */
 353         { roff_line_ignore, NULL, NULL, 0 },  /* backtrace */
 354         { roff_line_ignore, NULL, NULL, 0 },  /* bd */
 355         { roff_line_ignore, NULL, NULL, 0 },  /* bleedat */
 356         { roff_unsupp, NULL, NULL, 0 },  /* blm */
 357         { roff_unsupp, NULL, NULL, 0 },  /* box */
 358         { roff_unsupp, NULL, NULL, 0 },  /* boxa */
 359         { roff_line_ignore, NULL, NULL, 0 },  /* bp */
 360         { roff_unsupp, NULL, NULL, 0 },  /* BP */
 361         { roff_unsupp, NULL, NULL, 0 },  /* break */
 362         { roff_line_ignore, NULL, NULL, 0 },  /* breakchar */
 363         { roff_line_ignore, NULL, NULL, 0 },  /* brnl */
 364         { roff_br, NULL, NULL, 0 },  /* brp */
 365         { roff_line_ignore, NULL, NULL, 0 },  /* brpnl */
 366         { roff_unsupp, NULL, NULL, 0 },  /* c2 */
 367         { roff_cc, NULL, NULL, 0 },  /* cc */
 368         { roff_insec, NULL, NULL, 0 },  /* cf */
 369         { roff_line_ignore, NULL, NULL, 0 },  /* cflags */
 370         { roff_line_ignore, NULL, NULL, 0 },  /* ch */
 371         { roff_unsupp, NULL, NULL, 0 },  /* char */
 372         { roff_unsupp, NULL, NULL, 0 },  /* chop */
 373         { roff_line_ignore, NULL, NULL, 0 },  /* class */
 374         { roff_insec, NULL, NULL, 0 },  /* close */
 375         { roff_unsupp, NULL, NULL, 0 },  /* CL */
 376         { roff_line_ignore, NULL, NULL, 0 },  /* color */
 377         { roff_unsupp, NULL, NULL, 0 },  /* composite */
 378         { roff_unsupp, NULL, NULL, 0 },  /* continue */
 379         { roff_line_ignore, NULL, NULL, 0 },  /* cp */
 380         { roff_line_ignore, NULL, NULL, 0 },  /* cropat */
 381         { roff_line_ignore, NULL, NULL, 0 },  /* cs */
 382         { roff_line_ignore, NULL, NULL, 0 },  /* cu */
 383         { roff_unsupp, NULL, NULL, 0 },  /* da */
 384         { roff_unsupp, NULL, NULL, 0 },  /* dch */
 385         { roff_Dd, NULL, NULL, 0 },  /* Dd */
 386         { roff_block, roff_block_text, roff_block_sub, 0 },  /* de */
 387         { roff_block, roff_block_text, roff_block_sub, 0 },  /* de1 */
 388         { roff_line_ignore, NULL, NULL, 0 },  /* defcolor */
 389         { roff_block, roff_block_text, roff_block_sub, 0 },  /* dei */
 390         { roff_block, roff_block_text, roff_block_sub, 0 },  /* dei1 */
 391         { roff_unsupp, NULL, NULL, 0 },  /* device */
 392         { roff_unsupp, NULL, NULL, 0 },  /* devicem */
 393         { roff_unsupp, NULL, NULL, 0 },  /* di */
 394         { roff_unsupp, NULL, NULL, 0 },  /* do */
 395         { roff_ds, NULL, NULL, 0 },  /* ds */
 396         { roff_ds, NULL, NULL, 0 },  /* ds1 */
 397         { roff_unsupp, NULL, NULL, 0 },  /* dwh */
 398         { roff_unsupp, NULL, NULL, 0 },  /* dt */
 399         { roff_ec, NULL, NULL, 0 },  /* ec */
 400         { roff_unsupp, NULL, NULL, 0 },  /* ecr */
 401         { roff_unsupp, NULL, NULL, 0 },  /* ecs */
 402         { roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT },  /* el */
 403         { roff_unsupp, NULL, NULL, 0 },  /* em */
 404         { roff_EN, NULL, NULL, 0 },  /* EN */
 405         { roff_eo, NULL, NULL, 0 },  /* eo */
 406         { roff_unsupp, NULL, NULL, 0 },  /* EP */
 407         { roff_EQ, NULL, NULL, 0 },  /* EQ */
 408         { roff_line_ignore, NULL, NULL, 0 },  /* errprint */
 409         { roff_unsupp, NULL, NULL, 0 },  /* ev */
 410         { roff_unsupp, NULL, NULL, 0 },  /* evc */
 411         { roff_unsupp, NULL, NULL, 0 },  /* ex */
 412         { roff_line_ignore, NULL, NULL, 0 },  /* fallback */
 413         { roff_line_ignore, NULL, NULL, 0 },  /* fam */
 414         { roff_unsupp, NULL, NULL, 0 },  /* fc */
 415         { roff_unsupp, NULL, NULL, 0 },  /* fchar */
 416         { roff_line_ignore, NULL, NULL, 0 },  /* fcolor */
 417         { roff_line_ignore, NULL, NULL, 0 },  /* fdeferlig */
 418         { roff_line_ignore, NULL, NULL, 0 },  /* feature */
 419         { roff_line_ignore, NULL, NULL, 0 },  /* fkern */
 420         { roff_line_ignore, NULL, NULL, 0 },  /* fl */
 421         { roff_line_ignore, NULL, NULL, 0 },  /* flig */
 422         { roff_line_ignore, NULL, NULL, 0 },  /* fp */
 423         { roff_line_ignore, NULL, NULL, 0 },  /* fps */
 424         { roff_unsupp, NULL, NULL, 0 },  /* fschar */
 425         { roff_line_ignore, NULL, NULL, 0 },  /* fspacewidth */
 426         { roff_line_ignore, NULL, NULL, 0 },  /* fspecial */
 427         { roff_line_ignore, NULL, NULL, 0 },  /* ftr */
 428         { roff_line_ignore, NULL, NULL, 0 },  /* fzoom */
 429         { roff_line_ignore, NULL, NULL, 0 },  /* gcolor */
 430         { roff_line_ignore, NULL, NULL, 0 },  /* hc */
 431         { roff_line_ignore, NULL, NULL, 0 },  /* hcode */
 432         { roff_line_ignore, NULL, NULL, 0 },  /* hidechar */
 433         { roff_line_ignore, NULL, NULL, 0 },  /* hla */
 434         { roff_line_ignore, NULL, NULL, 0 },  /* hlm */
 435         { roff_line_ignore, NULL, NULL, 0 },  /* hpf */
 436         { roff_line_ignore, NULL, NULL, 0 },  /* hpfa */
 437         { roff_line_ignore, NULL, NULL, 0 },  /* hpfcode */
 438         { roff_line_ignore, NULL, NULL, 0 },  /* hw */
 439         { roff_line_ignore, NULL, NULL, 0 },  /* hy */
 440         { roff_line_ignore, NULL, NULL, 0 },  /* hylang */
 441         { roff_line_ignore, NULL, NULL, 0 },  /* hylen */
 442         { roff_line_ignore, NULL, NULL, 0 },  /* hym */
 443         { roff_line_ignore, NULL, NULL, 0 },  /* hypp */
 444         { roff_line_ignore, NULL, NULL, 0 },  /* hys */
 445         { roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT },  /* ie */
 446         { roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT },  /* if */
 447         { roff_block, roff_block_text, roff_block_sub, 0 },  /* ig */
 448         { roff_unsupp, NULL, NULL, 0 },  /* index */
 449         { roff_it, NULL, NULL, 0 },  /* it */
 450         { roff_unsupp, NULL, NULL, 0 },  /* itc */
 451         { roff_line_ignore, NULL, NULL, 0 },  /* IX */
 452         { roff_line_ignore, NULL, NULL, 0 },  /* kern */
 453         { roff_line_ignore, NULL, NULL, 0 },  /* kernafter */
 454         { roff_line_ignore, NULL, NULL, 0 },  /* kernbefore */
 455         { roff_line_ignore, NULL, NULL, 0 },  /* kernpair */
 456         { roff_unsupp, NULL, NULL, 0 },  /* lc */
 457         { roff_unsupp, NULL, NULL, 0 },  /* lc_ctype */
 458         { roff_unsupp, NULL, NULL, 0 },  /* lds */
 459         { roff_unsupp, NULL, NULL, 0 },  /* length */
 460         { roff_line_ignore, NULL, NULL, 0 },  /* letadj */
 461         { roff_insec, NULL, NULL, 0 },  /* lf */
 462         { roff_line_ignore, NULL, NULL, 0 },  /* lg */
 463         { roff_line_ignore, NULL, NULL, 0 },  /* lhang */
 464         { roff_unsupp, NULL, NULL, 0 },  /* linetabs */
 465         { roff_unsupp, NULL, NULL, 0 },  /* lnr */
 466         { roff_unsupp, NULL, NULL, 0 },  /* lnrf */
 467         { roff_unsupp, NULL, NULL, 0 },  /* lpfx */
 468         { roff_line_ignore, NULL, NULL, 0 },  /* ls */
 469         { roff_unsupp, NULL, NULL, 0 },  /* lsm */
 470         { roff_line_ignore, NULL, NULL, 0 },  /* lt */
 471         { roff_line_ignore, NULL, NULL, 0 },  /* mediasize */
 472         { roff_line_ignore, NULL, NULL, 0 },  /* minss */
 473         { roff_line_ignore, NULL, NULL, 0 },  /* mk */
 474         { roff_insec, NULL, NULL, 0 },  /* mso */
 475         { roff_line_ignore, NULL, NULL, 0 },  /* na */
 476         { roff_line_ignore, NULL, NULL, 0 },  /* ne */
 477         { roff_line_ignore, NULL, NULL, 0 },  /* nh */
 478         { roff_line_ignore, NULL, NULL, 0 },  /* nhychar */
 479         { roff_unsupp, NULL, NULL, 0 },  /* nm */
 480         { roff_unsupp, NULL, NULL, 0 },  /* nn */
 481         { roff_unsupp, NULL, NULL, 0 },  /* nop */
 482         { roff_nr, NULL, NULL, 0 },  /* nr */
 483         { roff_unsupp, NULL, NULL, 0 },  /* nrf */
 484         { roff_line_ignore, NULL, NULL, 0 },  /* nroff */
 485         { roff_line_ignore, NULL, NULL, 0 },  /* ns */
 486         { roff_insec, NULL, NULL, 0 },  /* nx */
 487         { roff_insec, NULL, NULL, 0 },  /* open */
 488         { roff_insec, NULL, NULL, 0 },  /* opena */
 489         { roff_line_ignore, NULL, NULL, 0 },  /* os */
 490         { roff_unsupp, NULL, NULL, 0 },  /* output */
 491         { roff_line_ignore, NULL, NULL, 0 },  /* padj */
 492         { roff_line_ignore, NULL, NULL, 0 },  /* papersize */
 493         { roff_line_ignore, NULL, NULL, 0 },  /* pc */
 494         { roff_line_ignore, NULL, NULL, 0 },  /* pev */
 495         { roff_insec, NULL, NULL, 0 },  /* pi */
 496         { roff_unsupp, NULL, NULL, 0 },  /* PI */
 497         { roff_line_ignore, NULL, NULL, 0 },  /* pl */
 498         { roff_line_ignore, NULL, NULL, 0 },  /* pm */
 499         { roff_line_ignore, NULL, NULL, 0 },  /* pn */
 500         { roff_line_ignore, NULL, NULL, 0 },  /* pnr */
 501         { roff_line_ignore, NULL, NULL, 0 },  /* po */
 502         { roff_line_ignore, NULL, NULL, 0 },  /* ps */
 503         { roff_unsupp, NULL, NULL, 0 },  /* psbb */
 504         { roff_unsupp, NULL, NULL, 0 },  /* pshape */
 505         { roff_insec, NULL, NULL, 0 },  /* pso */
 506         { roff_line_ignore, NULL, NULL, 0 },  /* ptr */
 507         { roff_line_ignore, NULL, NULL, 0 },  /* pvs */
 508         { roff_unsupp, NULL, NULL, 0 },  /* rchar */
 509         { roff_line_ignore, NULL, NULL, 0 },  /* rd */
 510         { roff_line_ignore, NULL, NULL, 0 },  /* recursionlimit */
 511         { roff_unsupp, NULL, NULL, 0 },  /* return */
 512         { roff_unsupp, NULL, NULL, 0 },  /* rfschar */
 513         { roff_line_ignore, NULL, NULL, 0 },  /* rhang */
 514         { roff_line_ignore, NULL, NULL, 0 },  /* rj */
 515         { roff_rm, NULL, NULL, 0 },  /* rm */
 516         { roff_rn, NULL, NULL, 0 },  /* rn */
 517         { roff_unsupp, NULL, NULL, 0 },  /* rnn */
 518         { roff_rr, NULL, NULL, 0 },  /* rr */
 519         { roff_line_ignore, NULL, NULL, 0 },  /* rs */
 520         { roff_line_ignore, NULL, NULL, 0 },  /* rt */
 521         { roff_unsupp, NULL, NULL, 0 },  /* schar */
 522         { roff_line_ignore, NULL, NULL, 0 },  /* sentchar */
 523         { roff_line_ignore, NULL, NULL, 0 },  /* shc */
 524         { roff_unsupp, NULL, NULL, 0 },  /* shift */
 525         { roff_line_ignore, NULL, NULL, 0 },  /* sizes */
 526         { roff_so, NULL, NULL, 0 },  /* so */
 527         { roff_line_ignore, NULL, NULL, 0 },  /* spacewidth */
 528         { roff_line_ignore, NULL, NULL, 0 },  /* special */
 529         { roff_line_ignore, NULL, NULL, 0 },  /* spreadwarn */
 530         { roff_line_ignore, NULL, NULL, 0 },  /* ss */
 531         { roff_line_ignore, NULL, NULL, 0 },  /* sty */
 532         { roff_unsupp, NULL, NULL, 0 },  /* substring */
 533         { roff_line_ignore, NULL, NULL, 0 },  /* sv */
 534         { roff_insec, NULL, NULL, 0 },  /* sy */
 535         { roff_T_, NULL, NULL, 0 },  /* T& */
 536         { roff_unsupp, NULL, NULL, 0 },  /* tc */
 537         { roff_TE, NULL, NULL, 0 },  /* TE */
 538         { roff_TH, NULL, NULL, 0 },  /* TH */
 539         { roff_line_ignore, NULL, NULL, 0 },  /* tkf */
 540         { roff_unsupp, NULL, NULL, 0 },  /* tl */
 541         { roff_line_ignore, NULL, NULL, 0 },  /* tm */
 542         { roff_line_ignore, NULL, NULL, 0 },  /* tm1 */
 543         { roff_line_ignore, NULL, NULL, 0 },  /* tmc */
 544         { roff_tr, NULL, NULL, 0 },  /* tr */
 545         { roff_line_ignore, NULL, NULL, 0 },  /* track */
 546         { roff_line_ignore, NULL, NULL, 0 },  /* transchar */
 547         { roff_insec, NULL, NULL, 0 },  /* trf */
 548         { roff_line_ignore, NULL, NULL, 0 },  /* trimat */
 549         { roff_unsupp, NULL, NULL, 0 },  /* trin */
 550         { roff_unsupp, NULL, NULL, 0 },  /* trnt */
 551         { roff_line_ignore, NULL, NULL, 0 },  /* troff */
 552         { roff_TS, NULL, NULL, 0 },  /* TS */
 553         { roff_line_ignore, NULL, NULL, 0 },  /* uf */
 554         { roff_line_ignore, NULL, NULL, 0 },  /* ul */
 555         { roff_unsupp, NULL, NULL, 0 },  /* unformat */
 556         { roff_line_ignore, NULL, NULL, 0 },  /* unwatch */
 557         { roff_line_ignore, NULL, NULL, 0 },  /* unwatchn */
 558         { roff_line_ignore, NULL, NULL, 0 },  /* vpt */
 559         { roff_line_ignore, NULL, NULL, 0 },  /* vs */
 560         { roff_line_ignore, NULL, NULL, 0 },  /* warn */
 561         { roff_line_ignore, NULL, NULL, 0 },  /* warnscale */
 562         { roff_line_ignore, NULL, NULL, 0 },  /* watch */
 563         { roff_line_ignore, NULL, NULL, 0 },  /* watchlength */
 564         { roff_line_ignore, NULL, NULL, 0 },  /* watchn */
 565         { roff_unsupp, NULL, NULL, 0 },  /* wh */
 566         { roff_unsupp, NULL, NULL, 0 },  /* while */
 567         { roff_insec, NULL, NULL, 0 },  /* write */
 568         { roff_insec, NULL, NULL, 0 },  /* writec */
 569         { roff_insec, NULL, NULL, 0 },  /* writem */
 570         { roff_line_ignore, NULL, NULL, 0 },  /* xflag */
 571         { roff_cblock, NULL, NULL, 0 },  /* . */
 572         { roff_renamed, NULL, NULL, 0 },
 573         { roff_userdef, NULL, NULL, 0 }
 574 };
 575
 576 /* not currently implemented: Ds em Eq LP Me PP pp Or Rd Sf SH */
 577 const   char *const __mdoc_reserved[] = {
 578         "Ac", "Ad", "An", "Ao", "Ap", "Aq", "Ar", "At",
 579         "Bc", "Bd", "Bf", "Bk", "Bl", "Bo", "Bq",
 580         "Brc", "Bro", "Brq", "Bsx", "Bt", "Bx",
 581         "Cd", "Cm", "Db", "Dc", "Dd", "Dl", "Do", "Dq",
 582         "Dt", "Dv", "Dx", "D1",
 583         "Ec", "Ed", "Ef", "Ek", "El", "Em",
 584         "En", "Eo", "Er", "Es", "Ev", "Ex",
 585         "Fa", "Fc", "Fd", "Fl", "Fn", "Fo", "Fr", "Ft", "Fx",
 586         "Hf", "Ic", "In", "It", "Lb", "Li", "Lk", "Lp",
 587         "Ms", "Mt", "Nd", "Nm", "No", "Ns", "Nx",
 588         "Oc", "Oo", "Op", "Os", "Ot", "Ox",
 589         "Pa", "Pc", "Pf", "Po", "Pp", "Pq",
 590         "Qc", "Ql", "Qo", "Qq", "Re", "Rs", "Rv",
 591         "Sc", "Sh", "Sm", "So", "Sq",
 592         "Ss", "St", "Sx", "Sy",
 593         "Ta", "Tn", "Ud", "Ux", "Va", "Vt", "Xc", "Xo", "Xr",
 594         "%A", "%B", "%C", "%D", "%I", "%J", "%N", "%O",
 595         "%P", "%Q", "%R", "%T", "%U", "%V",
 596         NULL
 597 };
 598
 599 /* not currently implemented: BT DE DS ME MT PT SY TQ YS */
 600 const   char *const __man_reserved[] = {
 601         "AT", "B", "BI", "BR", "DT",
 602         "EE", "EN", "EQ", "EX", "HP", "I", "IB", "IP", "IR",
 603         "LP", "OP", "P", "PD", "PP",
 604         "R", "RB", "RE", "RI", "RS", "SB", "SH", "SM", "SS",
 605         "TE", "TH", "TP", "TS", "T&", "UC", "UE", "UR",
 606         NULL
 607 };
 608
 609 /* Array of injected predefined strings. */
 610 #define PREDEFS_MAX      38
 611 static  const struct predef predefs[PREDEFS_MAX] = {
 612 #include "predefs.in"
 613 };
 614
 615 static  int      roffce_lines;  /* number of input lines to center */
 616 static  struct roff_node *roffce_node;  /* active request */
 617 static  int      roffit_lines;  /* number of lines to delay */
 618 static  char    *roffit_macro;  /* nil-terminated macro line */
 619
 620
 621 /* --- request table ------------------------------------------------------ */
 622
 623 struct ohash *
 624 roffhash_alloc(enum roff_tok mintok, enum roff_tok maxtok)
 625 {
 626         struct ohash    *htab;
 627         struct roffreq  *req;
 628         enum roff_tok    tok;
 629         size_t           sz;
 630         unsigned int     slot;
 631
 632         htab = mandoc_malloc(sizeof(*htab));
 633         mandoc_ohash_init(htab, 8, offsetof(struct roffreq, name));
 634
 635         for (tok = mintok; tok < maxtok; tok++) {
 636                 if (roff_name[tok] == NULL)
 637                         continue;
 638                 sz = strlen(roff_name[tok]);
 639                 req = mandoc_malloc(sizeof(*req) + sz + 1);
 640                 req->tok = tok;
 641                 memcpy(req->name, roff_name[tok], sz + 1);
 642                 slot = ohash_qlookup(htab, req->name);
 643                 ohash_insert(htab, slot, req);
 644         }
 645         return htab;
 646 }
 647
 648 void
 649 roffhash_free(struct ohash *htab)
 650 {
 651         struct roffreq  *req;
 652         unsigned int     slot;
 653
 654         if (htab == NULL)
 655                 return;
 656         for (req = ohash_first(htab, &slot); req != NULL;
 657              req = ohash_next(htab, &slot))
 658                 free(req);
 659         ohash_delete(htab);
 660         free(htab);
 661 }
 662
 663 enum roff_tok
 664 roffhash_find(struct ohash *htab, const char *name, size_t sz)
 665 {
 666         struct roffreq  *req;
 667         const char      *end;
 668
 669         if (sz) {
 670                 end = name + sz;
 671                 req = ohash_find(htab, ohash_qlookupi(htab, name, &end));
 672         } else
 673                 req = ohash_find(htab, ohash_qlookup(htab, name));
 674         return req == NULL ? TOKEN_NONE : req->tok;
 675 }
 676
 677 /* --- stack of request blocks -------------------------------------------- */
 678
 679 /*
 680  * Pop the current node off of the stack of roff instructions currently
 681  * pending.
 682  */
 683 static void
 684 roffnode_pop(struct roff *r)
 685 {
 686         struct roffnode *p;
 687
 688         assert(r->last);
 689         p = r->last;
 690
 691         r->last = r->last->parent;
 692         free(p->name);
 693         free(p->end);
 694         free(p);
 695 }
 696
 697 /*
 698  * Push a roff node onto the instruction stack.  This must later be
 699  * removed with roffnode_pop().
 700  */
 701 static void
 702 roffnode_push(struct roff *r, enum roff_tok tok, const char *name,
 703                 int line, int col)
 704 {
 705         struct roffnode *p;
 706
 707         p = mandoc_calloc(1, sizeof(struct roffnode));
 708         p->tok = tok;
 709         if (name)
 710                 p->name = mandoc_strdup(name);
 711         p->parent = r->last;
 712         p->line = line;
 713         p->col = col;
 714         p->rule = p->parent ? p->parent->rule : 0;
 715
 716         r->last = p;
 717 }
 718
 719 /* --- roff parser state data management ---------------------------------- */
 720
 721 static void
 722 roff_free1(struct roff *r)
 723 {
 724         struct tbl_node *tbl;
 725         struct eqn_node *e;
 726         int              i;
 727
 728         while (NULL != (tbl = r->first_tbl)) {
 729                 r->first_tbl = tbl->next;
 730                 tbl_free(tbl);
 731         }
 732         r->first_tbl = r->last_tbl = r->tbl = NULL;
 733
 734         while (NULL != (e = r->first_eqn)) {
 735                 r->first_eqn = e->next;
 736                 eqn_free(e);
 737         }
 738         r->first_eqn = r->last_eqn = r->eqn = NULL;
 739
 740         while (r->last)
 741                 roffnode_pop(r);
 742
 743         free (r->rstack);
 744         r->rstack = NULL;
 745         r->rstacksz = 0;
 746         r->rstackpos = -1;
 747
 748         roff_freereg(r->regtab);
 749         r->regtab = NULL;
 750
 751         roff_freestr(r->strtab);
 752         roff_freestr(r->rentab);
 753         roff_freestr(r->xmbtab);
 754         r->strtab = r->rentab = r->xmbtab = NULL;
 755
 756         if (r->xtab)
 757                 for (i = 0; i < 128; i++)
 758                         free(r->xtab[i].p);
 759         free(r->xtab);
 760         r->xtab = NULL;
 761 }
 762
 763 void
 764 roff_reset(struct roff *r)
 765 {
 766         roff_free1(r);
 767         r->format = r->options & (MPARSE_MDOC | MPARSE_MAN);
 768         r->control = '\0';
 769         r->escape = '\\';
 770 }
 771
 772 void
 773 roff_free(struct roff *r)
 774 {
 775         roff_free1(r);
 776         roffhash_free(r->reqtab);
 777         free(r);
 778 }
 779
 780 struct roff *
 781 roff_alloc(struct mparse *parse, int options)
 782 {
 783         struct roff     *r;
 784
 785         r = mandoc_calloc(1, sizeof(struct roff));
 786         r->parse = parse;
 787         r->reqtab = roffhash_alloc(0, ROFF_USERDEF);
 788         r->options = options;
 789         r->format = options & (MPARSE_MDOC | MPARSE_MAN);
 790         r->rstackpos = -1;
 791         r->escape = '\\';
 792         return r;
 793 }
 794
 795 /* --- syntax tree state data management ---------------------------------- */
 796
 797 static void
 798 roff_man_free1(struct roff_man *man)
 799 {
 800
 801         if (man->first != NULL)
 802                 roff_node_delete(man, man->first);
 803         free(man->meta.msec);
 804         free(man->meta.vol);
 805         free(man->meta.os);
 806         free(man->meta.arch);
 807         free(man->meta.title);
 808         free(man->meta.name);
 809         free(man->meta.date);
 810 }
 811
 812 static void
 813 roff_man_alloc1(struct roff_man *man)
 814 {
 815
 816         memset(&man->meta, 0, sizeof(man->meta));
 817         man->first = mandoc_calloc(1, sizeof(*man->first));
 818         man->first->type = ROFFT_ROOT;
 819         man->last = man->first;
 820         man->last_es = NULL;
 821         man->flags = 0;
 822         man->macroset = MACROSET_NONE;
 823         man->lastsec = man->lastnamed = SEC_NONE;
 824         man->next = ROFF_NEXT_CHILD;
 825 }
 826
 827 void
 828 roff_man_reset(struct roff_man *man)
 829 {
 830
 831         roff_man_free1(man);
 832         roff_man_alloc1(man);
 833 }
 834
 835 void
 836 roff_man_free(struct roff_man *man)
 837 {
 838
 839         roff_man_free1(man);
 840         free(man);
 841 }
 842
 843 struct roff_man *
 844 roff_man_alloc(struct roff *roff, struct mparse *parse,
 845         const char *defos, int quick)
 846 {
 847         struct roff_man *man;
 848
 849         man = mandoc_calloc(1, sizeof(*man));
 850         man->parse = parse;
 851         man->roff = roff;
 852         man->defos = defos;
 853         man->quick = quick;
 854         roff_man_alloc1(man);
 855         roff->man = man;
 856         return man;
 857 }
 858
 859 /* --- syntax tree handling ----------------------------------------------- */
 860
 861 struct roff_node *
 862 roff_node_alloc(struct roff_man *man, int line, int pos,
 863         enum roff_type type, int tok)
 864 {
 865         struct roff_node        *n;
 866
 867         n = mandoc_calloc(1, sizeof(*n));
 868         n->line = line;
 869         n->pos = pos;
 870         n->tok = tok;
 871         n->type = type;
 872         n->sec = man->lastsec;
 873
 874         if (man->flags & MDOC_SYNOPSIS)
 875                 n->flags |= NODE_SYNPRETTY;
 876         else
 877                 n->flags &= ~NODE_SYNPRETTY;
 878         if (man->flags & MDOC_NEWLINE)
 879                 n->flags |= NODE_LINE;
 880         man->flags &= ~MDOC_NEWLINE;
 881
 882         return n;
 883 }
 884
 885 void
 886 roff_node_append(struct roff_man *man, struct roff_node *n)
 887 {
 888
 889         switch (man->next) {
 890         case ROFF_NEXT_SIBLING:
 891                 if (man->last->next != NULL) {
 892                         n->next = man->last->next;
 893                         man->last->next->prev = n;
 894                 } else
 895                         man->last->parent->last = n;
 896                 man->last->next = n;
 897                 n->prev = man->last;
 898                 n->parent = man->last->parent;
 899                 break;
 900         case ROFF_NEXT_CHILD:
 901                 if (man->last->child != NULL) {
 902                         n->next = man->last->child;
 903                         man->last->child->prev = n;
 904                 } else
 905                         man->last->last = n;
 906                 man->last->child = n;
 907                 n->parent = man->last;
 908                 break;
 909         default:
 910                 abort();
 911         }
 912         man->last = n;
 913
 914         switch (n->type) {
 915         case ROFFT_HEAD:
 916                 n->parent->head = n;
 917                 break;
 918         case ROFFT_BODY:
 919                 if (n->end != ENDBODY_NOT)
 920                         return;
 921                 n->parent->body = n;
 922                 break;
 923         case ROFFT_TAIL:
 924                 n->parent->tail = n;
 925                 break;
 926         default:
 927                 return;
 928         }
 929
 930         /*
 931          * Copy over the normalised-data pointer of our parent.  Not
 932          * everybody has one, but copying a null pointer is fine.
 933          */
 934
 935         n->norm = n->parent->norm;
 936         assert(n->parent->type == ROFFT_BLOCK);
 937 }
 938
 939 void
 940 roff_word_alloc(struct roff_man *man, int line, int pos, const char *word)
 941 {
 942         struct roff_node        *n;
 943
 944         n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE);
 945         n->string = roff_strdup(man->roff, word);
 946         roff_node_append(man, n);
 947         n->flags |= NODE_VALID | NODE_ENDED;
 948         man->next = ROFF_NEXT_SIBLING;
 949 }
 950
 951 void
 952 roff_word_append(struct roff_man *man, const char *word)
 953 {
 954         struct roff_node        *n;
 955         char                    *addstr, *newstr;
 956
 957         n = man->last;
 958         addstr = roff_strdup(man->roff, word);
 959         mandoc_asprintf(&newstr, "%s %s", n->string, addstr);
 960         free(addstr);
 961         free(n->string);
 962         n->string = newstr;
 963         man->next = ROFF_NEXT_SIBLING;
 964 }
 965
 966 void
 967 roff_elem_alloc(struct roff_man *man, int line, int pos, int tok)
 968 {
 969         struct roff_node        *n;
 970
 971         n = roff_node_alloc(man, line, pos, ROFFT_ELEM, tok);
 972         roff_node_append(man, n);
 973         man->next = ROFF_NEXT_CHILD;
 974 }
 975
 976 struct roff_node *
 977 roff_block_alloc(struct roff_man *man, int line, int pos, int tok)
 978 {
 979         struct roff_node        *n;
 980
 981         n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok);
 982         roff_node_append(man, n);
 983         man->next = ROFF_NEXT_CHILD;
 984         return n;
 985 }
 986
 987 struct roff_node *
 988 roff_head_alloc(struct roff_man *man, int line, int pos, int tok)
 989 {
 990         struct roff_node        *n;
 991
 992         n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok);
 993         roff_node_append(man, n);
 994         man->next = ROFF_NEXT_CHILD;
 995         return n;
 996 }
 997
 998 struct roff_node *
 999 roff_body_alloc(struct roff_man *man, int line, int pos, int tok)
1000 {
1001         struct roff_node        *n;
1002
1003         n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok);
1004         roff_node_append(man, n);
1005         man->next = ROFF_NEXT_CHILD;
1006         return n;
1007 }
1008
1009 void
1010 roff_addeqn(struct roff_man *man, const struct eqn *eqn)
1011 {
1012         struct roff_node        *n;
1013
1014         n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE);
1015         n->eqn = eqn;
1016         if (eqn->ln > man->last->line)
1017                 n->flags |= NODE_LINE;
1018         roff_node_append(man, n);
1019         man->next = ROFF_NEXT_SIBLING;
1020 }
1021
1022 void
1023 roff_addtbl(struct roff_man *man, const struct tbl_span *tbl)
1024 {
1025         struct roff_node        *n;
1026
1027         if (man->macroset == MACROSET_MAN)
1028                 man_breakscope(man, ROFF_TS);
1029         n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE);
1030         n->span = tbl;
1031         roff_node_append(man, n);
1032         n->flags |= NODE_VALID | NODE_ENDED;
1033         man->next = ROFF_NEXT_SIBLING;
1034 }
1035
1036 void
1037 roff_node_unlink(struct roff_man *man, struct roff_node *n)
1038 {
1039
1040         /* Adjust siblings. */
1041
1042         if (n->prev)
1043                 n->prev->next = n->next;
1044         if (n->next)
1045                 n->next->prev = n->prev;
1046
1047         /* Adjust parent. */
1048
1049         if (n->parent != NULL) {
1050                 if (n->parent->child == n)
1051                         n->parent->child = n->next;
1052                 if (n->parent->last == n)
1053                         n->parent->last = n->prev;
1054         }
1055
1056         /* Adjust parse point. */
1057
1058         if (man == NULL)
1059                 return;
1060         if (man->last == n) {
1061                 if (n->prev == NULL) {
1062                         man->last = n->parent;
1063                         man->next = ROFF_NEXT_CHILD;
1064                 } else {
1065                         man->last = n->prev;
1066                         man->next = ROFF_NEXT_SIBLING;
1067                 }
1068         }
1069         if (man->first == n)
1070                 man->first = NULL;
1071 }
1072
1073 void
1074 roff_node_free(struct roff_node *n)
1075 {
1076
1077         if (n->args != NULL)
1078                 mdoc_argv_free(n->args);
1079         if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM)
1080                 free(n->norm);
1081         free(n->string);
1082         free(n);
1083 }
1084
1085 void
1086 roff_node_delete(struct roff_man *man, struct roff_node *n)
1087 {
1088
1089         while (n->child != NULL)
1090                 roff_node_delete(man, n->child);
1091         roff_node_unlink(man, n);
1092         roff_node_free(n);
1093 }
1094
1095 void
1096 deroff(char **dest, const struct roff_node *n)
1097 {
1098         char    *cp;
1099         size_t   sz;
1100
1101         if (n->type != ROFFT_TEXT) {
1102                 for (n = n->child; n != NULL; n = n->next)
1103                         deroff(dest, n);
1104                 return;
1105         }
1106
1107         /* Skip leading whitespace. */
1108
1109         for (cp = n->string; *cp != '\0'; cp++) {
1110                 if (cp[0] == '\\' && cp[1] != '\0' &&
1111                     strchr(" %&0^|~", cp[1]) != NULL)
1112                         cp++;
1113                 else if ( ! isspace((unsigned char)*cp))
1114                         break;
1115         }
1116
1117         /* Skip trailing backslash. */
1118
1119         sz = strlen(cp);
1120         if (sz > 0 && cp[sz - 1] == '\\')
1121                 sz--;
1122
1123         /* Skip trailing whitespace. */
1124
1125         for (; sz; sz--)
1126                 if ( ! isspace((unsigned char)cp[sz-1]))
1127                         break;
1128
1129         /* Skip empty strings. */
1130
1131         if (sz == 0)
1132                 return;
1133
1134         if (*dest == NULL) {
1135                 *dest = mandoc_strndup(cp, sz);
1136                 return;
1137         }
1138
1139         mandoc_asprintf(&cp, "%s %*s", *dest, (int)sz, cp);
1140         free(*dest);
1141         *dest = cp;
1142 }
1143
1144 /* --- main functions of the roff parser ---------------------------------- */
1145
1146 /*
1147  * In the current line, expand escape sequences that tend to get
1148  * used in numerical expressions and conditional requests.
1149  * Also check the syntax of the remaining escape sequences.
1150  */
1151 static enum rofferr
1152 roff_res(struct roff *r, struct buf *buf, int ln, int pos)
1153 {
1154         char             ubuf[24]; /* buffer to print the number */
1155         const char      *start; /* start of the string to process */
1156         char            *stesc; /* start of an escape sequence ('\\') */
1157         const char      *stnam; /* start of the name, after "[(*" */
1158         const char      *cp;    /* end of the name, e.g. before ']' */
1159         const char      *res;   /* the string to be substituted */
1160         char            *nbuf;  /* new buffer to copy buf->buf to */
1161         size_t           maxl;  /* expected length of the escape name */
1162         size_t           naml;  /* actual length of the escape name */
1163         enum mandoc_esc  esc;   /* type of the escape sequence */
1164         int              inaml; /* length returned from mandoc_escape() */
1165         int              expand_count;  /* to avoid infinite loops */
1166         int              npos;  /* position in numeric expression */
1167         int              arg_complete; /* argument not interrupted by eol */
1168         int              done;  /* no more input available */
1169         char             term;  /* character terminating the escape */
1170
1171         /* Search forward for comments. */
1172
1173         done = 0;
1174         start = buf->buf + pos;
1175         for (stesc = buf->buf + pos; *stesc != '\0'; stesc++) {
1176                 if (stesc[0] != r->escape || stesc[1] == '\0')
1177                         continue;
1178                 stesc++;
1179                 if (*stesc != '"' && *stesc != '#')
1180                         continue;
1181                 cp = strchr(stesc--, '\0') - 1;
1182                 if (*cp == '\n') {
1183                         done = 1;
1184                         cp--;
1185                 }
1186                 if (*cp == ' ' || *cp == '\t')
1187                         mandoc_msg(MANDOCERR_SPACE_EOL, r->parse,
1188                             ln, cp - buf->buf, NULL);
1189                 while (stesc > start && stesc[-1] == ' ')
1190                         stesc--;
1191                 *stesc = '\0';
1192                 break;
1193         }
1194         if (stesc == start)
1195                 return ROFF_CONT;
1196         stesc--;
1197
1198         /* Notice the end of the input. */
1199
1200         if (*stesc == '\n') {
1201                 *stesc-- = '\0';
1202                 done = 1;
1203         }
1204
1205         expand_count = 0;
1206         while (stesc >= start) {
1207
1208                 /* Search backwards for the next backslash. */
1209
1210                 if (*stesc != r->escape) {
1211                         if (*stesc == '\\') {
1212                                 *stesc = '\0';
1213                                 buf->sz = mandoc_asprintf(&nbuf, "%s\\e%s",
1214                                     buf->buf, stesc + 1) + 1;
1215                                 start = nbuf + pos;
1216                                 stesc = nbuf + (stesc - buf->buf);
1217                                 free(buf->buf);
1218                                 buf->buf = nbuf;
1219                         }
1220                         stesc--;
1221                         continue;
1222                 }
1223
1224                 /* If it is escaped, skip it. */
1225
1226                 for (cp = stesc - 1; cp >= start; cp--)
1227                         if (*cp != r->escape)
1228                                 break;
1229
1230                 if ((stesc - cp) % 2 == 0) {
1231                         while (stesc > cp)
1232                                 *stesc-- = '\\';
1233                         continue;
1234                 } else if (stesc[1] != '\0') {
1235                         *stesc = '\\';
1236                 } else {
1237                         *stesc-- = '\0';
1238                         if (done)
1239                                 continue;
1240                         else
1241                                 return ROFF_APPEND;
1242                 }
1243
1244                 /* Decide whether to expand or to check only. */
1245
1246                 term = '\0';
1247                 cp = stesc + 1;
1248                 switch (*cp) {
1249                 case '*':
1250                         res = NULL;
1251                         break;
1252                 case 'B':
1253                 case 'w':
1254                         term = cp[1];
1255                         /* FALLTHROUGH */
1256                 case 'n':
1257                         res = ubuf;
1258                         break;
1259                 default:
1260                         esc = mandoc_escape(&cp, &stnam, &inaml);
1261                         if (esc == ESCAPE_ERROR ||
1262                             (esc == ESCAPE_SPECIAL &&
1263                              mchars_spec2cp(stnam, inaml) < 0))
1264                                 mandoc_vmsg(MANDOCERR_ESC_BAD,
1265                                     r->parse, ln, (int)(stesc - buf->buf),
1266                                     "%.*s", (int)(cp - stesc), stesc);
1267                         stesc--;
1268                         continue;
1269                 }
1270
1271                 if (EXPAND_LIMIT < ++expand_count) {
1272                         mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
1273                             ln, (int)(stesc - buf->buf), NULL);
1274                         return ROFF_IGN;
1275                 }
1276
1277                 /*
1278                  * The third character decides the length
1279                  * of the name of the string or register.
1280                  * Save a pointer to the name.
1281                  */
1282
1283                 if (term == '\0') {
1284                         switch (*++cp) {
1285                         case '\0':
1286                                 maxl = 0;
1287                                 break;
1288                         case '(':
1289                                 cp++;
1290                                 maxl = 2;
1291                                 break;
1292                         case '[':
1293                                 cp++;
1294                                 term = ']';
1295                                 maxl = 0;
1296                                 break;
1297                         default:
1298                                 maxl = 1;
1299                                 break;
1300                         }
1301                 } else {
1302                         cp += 2;
1303                         maxl = 0;
1304                 }
1305                 stnam = cp;
1306
1307                 /* Advance to the end of the name. */
1308
1309                 naml = 0;
1310                 arg_complete = 1;
1311                 while (maxl == 0 || naml < maxl) {
1312                         if (*cp == '\0') {
1313                                 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
1314                                     ln, (int)(stesc - buf->buf), stesc);
1315                                 arg_complete = 0;
1316                                 break;
1317                         }
1318                         if (maxl == 0 && *cp == term) {
1319                                 cp++;
1320                                 break;
1321                         }
1322                         if (*cp++ != '\\' || stesc[1] != 'w') {
1323                                 naml++;
1324                                 continue;
1325                         }
1326                         switch (mandoc_escape(&cp, NULL, NULL)) {
1327                         case ESCAPE_SPECIAL:
1328                         case ESCAPE_UNICODE:
1329                         case ESCAPE_NUMBERED:
1330                         case ESCAPE_OVERSTRIKE:
1331                                 naml++;
1332                                 break;
1333                         default:
1334                                 break;
1335                         }
1336                 }
1337
1338                 /*
1339                  * Retrieve the replacement string; if it is
1340                  * undefined, resume searching for escapes.
1341                  */
1342
1343                 switch (stesc[1]) {
1344                 case '*':
1345                         if (arg_complete)
1346                                 res = roff_getstrn(r, stnam, naml);
1347                         break;
1348                 case 'B':
1349                         npos = 0;
1350                         ubuf[0] = arg_complete &&
1351                             roff_evalnum(r, ln, stnam, &npos,
1352                               NULL, ROFFNUM_SCALE) &&
1353                             stnam + npos + 1 == cp ? '1' : '0';
1354                         ubuf[1] = '\0';
1355                         break;
1356                 case 'n':
1357                         if (arg_complete)
1358                                 (void)snprintf(ubuf, sizeof(ubuf), "%d",
1359                                     roff_getregn(r, stnam, naml));
1360                         else
1361                                 ubuf[0] = '\0';
1362                         break;
1363                 case 'w':
1364                         /* use even incomplete args */
1365                         (void)snprintf(ubuf, sizeof(ubuf), "%d",
1366                             24 * (int)naml);
1367                         break;
1368                 }
1369
1370                 if (res == NULL) {
1371                         mandoc_vmsg(MANDOCERR_STR_UNDEF,
1372                             r->parse, ln, (int)(stesc - buf->buf),
1373                             "%.*s", (int)naml, stnam);
1374                         res = "";
1375                 } else if (buf->sz + strlen(res) > SHRT_MAX) {
1376                         mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
1377                             ln, (int)(stesc - buf->buf), NULL);
1378                         return ROFF_IGN;
1379                 }
1380
1381                 /* Replace the escape sequence by the string. */
1382
1383                 *stesc = '\0';
1384                 buf->sz = mandoc_asprintf(&nbuf, "%s%s%s",
1385                     buf->buf, res, cp) + 1;
1386
1387                 /* Prepare for the next replacement. */
1388
1389                 start = nbuf + pos;
1390                 stesc = nbuf + (stesc - buf->buf) + strlen(res);
1391                 free(buf->buf);
1392                 buf->buf = nbuf;
1393         }
1394         return ROFF_CONT;
1395 }
1396
1397 /*
1398  * Process text streams.
1399  */
1400 static enum rofferr
1401 roff_parsetext(struct roff *r, struct buf *buf, int pos, int *offs)
1402 {
1403         size_t           sz;
1404         const char      *start;
1405         char            *p;
1406         int              isz;
1407         enum mandoc_esc  esc;
1408
1409         /* Spring the input line trap. */
1410
1411         if (roffit_lines == 1) {
1412                 isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro);
1413                 free(buf->buf);
1414                 buf->buf = p;
1415                 buf->sz = isz + 1;
1416                 *offs = 0;
1417                 free(roffit_macro);
1418                 roffit_lines = 0;
1419                 return ROFF_REPARSE;
1420         } else if (roffit_lines > 1)
1421                 --roffit_lines;
1422
1423         if (roffce_node != NULL && buf->buf[pos] != '\0') {
1424                 if (roffce_lines < 1) {
1425                         r->man->last = roffce_node;
1426                         r->man->next = ROFF_NEXT_SIBLING;
1427                         roffce_lines = 0;
1428                         roffce_node = NULL;
1429                 } else
1430                         roffce_lines--;
1431         }
1432
1433         /* Convert all breakable hyphens into ASCII_HYPH. */
1434
1435         start = p = buf->buf + pos;
1436
1437         while (*p != '\0') {
1438                 sz = strcspn(p, "-\\");
1439                 p += sz;
1440
1441                 if (*p == '\0')
1442                         break;
1443
1444                 if (*p == '\\') {
1445                         /* Skip over escapes. */
1446                         p++;
1447                         esc = mandoc_escape((const char **)&p, NULL, NULL);
1448                         if (esc == ESCAPE_ERROR)
1449                                 break;
1450                         while (*p == '-')
1451                                 p++;
1452                         continue;
1453                 } else if (p == start) {
1454                         p++;
1455                         continue;
1456                 }
1457
1458                 if (isalpha((unsigned char)p[-1]) &&
1459                     isalpha((unsigned char)p[1]))
1460                         *p = ASCII_HYPH;
1461                 p++;
1462         }
1463         return ROFF_CONT;
1464 }
1465
1466 enum rofferr
1467 roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs)
1468 {
1469         enum roff_tok    t;
1470         enum rofferr     e;
1471         int              pos;   /* parse point */
1472         int              spos;  /* saved parse point for messages */
1473         int              ppos;  /* original offset in buf->buf */
1474         int              ctl;   /* macro line (boolean) */
1475
1476         ppos = pos = *offs;
1477
1478         /* Handle in-line equation delimiters. */
1479
1480         if (r->tbl == NULL &&
1481             r->last_eqn != NULL && r->last_eqn->delim &&
1482             (r->eqn == NULL || r->eqn_inline)) {
1483                 e = roff_eqndelim(r, buf, pos);
1484                 if (e == ROFF_REPARSE)
1485                         return e;
1486                 assert(e == ROFF_CONT);
1487         }
1488
1489         /* Expand some escape sequences. */
1490
1491         e = roff_res(r, buf, ln, pos);
1492         if (e == ROFF_IGN || e == ROFF_APPEND)
1493                 return e;
1494         assert(e == ROFF_CONT);
1495
1496         ctl = roff_getcontrol(r, buf->buf, &pos);
1497
1498         /*
1499          * First, if a scope is open and we're not a macro, pass the
1500          * text through the macro's filter.
1501          * Equations process all content themselves.
1502          * Tables process almost all content themselves, but we want
1503          * to warn about macros before passing it there.
1504          */
1505
1506         if (r->last != NULL && ! ctl) {
1507                 t = r->last->tok;
1508                 e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs);
1509                 if (e == ROFF_IGN)
1510                         return e;
1511                 assert(e == ROFF_CONT);
1512         }
1513         if (r->eqn != NULL)
1514                 return eqn_read(&r->eqn, ln, buf->buf, ppos, offs);
1515         if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0'))
1516                 return tbl_read(r->tbl, ln, buf->buf, ppos);
1517         if ( ! ctl)
1518                 return roff_parsetext(r, buf, pos, offs);
1519
1520         /* Skip empty request lines. */
1521
1522         if (buf->buf[pos] == '"') {
1523                 mandoc_msg(MANDOCERR_COMMENT_BAD, r->parse,
1524                     ln, pos, NULL);
1525                 return ROFF_IGN;
1526         } else if (buf->buf[pos] == '\0')
1527                 return ROFF_IGN;
1528
1529         /*
1530          * If a scope is open, go to the child handler for that macro,
1531          * as it may want to preprocess before doing anything with it.
1532          * Don't do so if an equation is open.
1533          */
1534
1535         if (r->last) {
1536                 t = r->last->tok;
1537                 return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs);
1538         }
1539
1540         /* No scope is open.  This is a new request or macro. */
1541
1542         spos = pos;
1543         t = roff_parse(r, buf->buf, &pos, ln, ppos);
1544
1545         /* Tables ignore most macros. */
1546
1547         if (r->tbl != NULL && (t == TOKEN_NONE || t == ROFF_TS)) {
1548                 mandoc_msg(MANDOCERR_TBLMACRO, r->parse,
1549                     ln, pos, buf->buf + spos);
1550                 if (t == ROFF_TS)
1551                         return ROFF_IGN;
1552                 while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ')
1553                         pos++;
1554                 while (buf->buf[pos] == ' ')
1555                         pos++;
1556                 return tbl_read(r->tbl, ln, buf->buf, pos);
1557         }
1558
1559         /* For now, let high level macros abort .ce mode. */
1560
1561         if (ctl && roffce_node != NULL &&
1562             (t == TOKEN_NONE || t == ROFF_EQ || t == ROFF_TS)) {
1563                 r->man->last = roffce_node;
1564                 r->man->next = ROFF_NEXT_SIBLING;
1565                 roffce_lines = 0;
1566                 roffce_node = NULL;
1567         }
1568
1569         /*
1570          * This is neither a roff request nor a user-defined macro.
1571          * Let the standard macro set parsers handle it.
1572          */
1573
1574         if (t == TOKEN_NONE)
1575                 return ROFF_CONT;
1576
1577         /* Execute a roff request or a user defined macro. */
1578
1579         return (*roffs[t].proc)(r, t, buf, ln, spos, pos, offs);
1580 }
1581
1582 void
1583 roff_endparse(struct roff *r)
1584 {
1585
1586         if (r->last)
1587                 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1588                     r->last->line, r->last->col,
1589                     roff_name[r->last->tok]);
1590
1591         if (r->eqn) {
1592                 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1593                     r->eqn->eqn.ln, r->eqn->eqn.pos, "EQ");
1594                 eqn_end(&r->eqn);
1595         }
1596
1597         if (r->tbl) {
1598                 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1599                     r->tbl->line, r->tbl->pos, "TS");
1600                 tbl_end(&r->tbl);
1601         }
1602 }
1603
1604 /*
1605  * Parse a roff node's type from the input buffer.  This must be in the
1606  * form of ".foo xxx" in the usual way.
1607  */
1608 static enum roff_tok
1609 roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos)
1610 {
1611         char            *cp;
1612         const char      *mac;
1613         size_t           maclen;
1614         enum roff_tok    t;
1615
1616         cp = buf + *pos;
1617
1618         if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp)
1619                 return TOKEN_NONE;
1620
1621         mac = cp;
1622         maclen = roff_getname(r, &cp, ln, ppos);
1623
1624         t = (r->current_string = roff_getstrn(r, mac, maclen)) ?
1625             ROFF_USERDEF :
1626             (r->current_string = roff_getrenn(r, mac, maclen)) ?
1627             ROFF_RENAMED : roffhash_find(r->reqtab, mac, maclen);
1628
1629         if (t != TOKEN_NONE)
1630                 *pos = cp - buf;
1631
1632         return t;
1633 }
1634
1635 /* --- handling of request blocks ----------------------------------------- */
1636
1637 static enum rofferr
1638 roff_cblock(ROFF_ARGS)
1639 {
1640
1641         /*
1642          * A block-close `..' should only be invoked as a child of an
1643          * ignore macro, otherwise raise a warning and just ignore it.
1644          */
1645
1646         if (r->last == NULL) {
1647                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1648                     ln, ppos, "..");
1649                 return ROFF_IGN;
1650         }
1651
1652         switch (r->last->tok) {
1653         case ROFF_am:
1654                 /* ROFF_am1 is remapped to ROFF_am in roff_block(). */
1655         case ROFF_ami:
1656         case ROFF_de:
1657                 /* ROFF_de1 is remapped to ROFF_de in roff_block(). */
1658         case ROFF_dei:
1659         case ROFF_ig:
1660                 break;
1661         default:
1662                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1663                     ln, ppos, "..");
1664                 return ROFF_IGN;
1665         }
1666
1667         if (buf->buf[pos] != '\0')
1668                 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
1669                     ".. %s", buf->buf + pos);
1670
1671         roffnode_pop(r);
1672         roffnode_cleanscope(r);
1673         return ROFF_IGN;
1674
1675 }
1676
1677 static void
1678 roffnode_cleanscope(struct roff *r)
1679 {
1680
1681         while (r->last) {
1682                 if (--r->last->endspan != 0)
1683                         break;
1684                 roffnode_pop(r);
1685         }
1686 }
1687
1688 static void
1689 roff_ccond(struct roff *r, int ln, int ppos)
1690 {
1691
1692         if (NULL == r->last) {
1693                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1694                     ln, ppos, "\\}");
1695                 return;
1696         }
1697
1698         switch (r->last->tok) {
1699         case ROFF_el:
1700         case ROFF_ie:
1701         case ROFF_if:
1702                 break;
1703         default:
1704                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1705                     ln, ppos, "\\}");
1706                 return;
1707         }
1708
1709         if (r->last->endspan > -1) {
1710                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1711                     ln, ppos, "\\}");
1712                 return;
1713         }
1714
1715         roffnode_pop(r);
1716         roffnode_cleanscope(r);
1717         return;
1718 }
1719
1720 static enum rofferr
1721 roff_block(ROFF_ARGS)
1722 {
1723         const char      *name;
1724         char            *iname, *cp;
1725         size_t           namesz;
1726
1727         /* Ignore groff compatibility mode for now. */
1728
1729         if (tok == ROFF_de1)
1730                 tok = ROFF_de;
1731         else if (tok == ROFF_dei1)
1732                 tok = ROFF_dei;
1733         else if (tok == ROFF_am1)
1734                 tok = ROFF_am;
1735         else if (tok == ROFF_ami1)
1736                 tok = ROFF_ami;
1737
1738         /* Parse the macro name argument. */
1739
1740         cp = buf->buf + pos;
1741         if (tok == ROFF_ig) {
1742                 iname = NULL;
1743                 namesz = 0;
1744         } else {
1745                 iname = cp;
1746                 namesz = roff_getname(r, &cp, ln, ppos);
1747                 iname[namesz] = '\0';
1748         }
1749
1750         /* Resolve the macro name argument if it is indirect. */
1751
1752         if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) {
1753                 if ((name = roff_getstrn(r, iname, namesz)) == NULL) {
1754                         mandoc_vmsg(MANDOCERR_STR_UNDEF,
1755                             r->parse, ln, (int)(iname - buf->buf),
1756                             "%.*s", (int)namesz, iname);
1757                         namesz = 0;
1758                 } else
1759                         namesz = strlen(name);
1760         } else
1761                 name = iname;
1762
1763         if (namesz == 0 && tok != ROFF_ig) {
1764                 mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse,
1765                     ln, ppos, roff_name[tok]);
1766                 return ROFF_IGN;
1767         }
1768
1769         roffnode_push(r, tok, name, ln, ppos);
1770
1771         /*
1772          * At the beginning of a `de' macro, clear the existing string
1773          * with the same name, if there is one.  New content will be
1774          * appended from roff_block_text() in multiline mode.
1775          */
1776
1777         if (tok == ROFF_de || tok == ROFF_dei)
1778                 roff_setstrn(&r->strtab, name, namesz, "", 0, 0);
1779
1780         if (*cp == '\0')
1781                 return ROFF_IGN;
1782
1783         /* Get the custom end marker. */
1784
1785         iname = cp;
1786         namesz = roff_getname(r, &cp, ln, ppos);
1787
1788         /* Resolve the end marker if it is indirect. */
1789
1790         if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) {
1791                 if ((name = roff_getstrn(r, iname, namesz)) == NULL) {
1792                         mandoc_vmsg(MANDOCERR_STR_UNDEF,
1793                             r->parse, ln, (int)(iname - buf->buf),
1794                             "%.*s", (int)namesz, iname);
1795                         namesz = 0;
1796                 } else
1797                         namesz = strlen(name);
1798         } else
1799                 name = iname;
1800
1801         if (namesz)
1802                 r->last->end = mandoc_strndup(name, namesz);
1803
1804         if (*cp != '\0')
1805                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
1806                     ln, pos, ".%s ... %s", roff_name[tok], cp);
1807
1808         return ROFF_IGN;
1809 }
1810
1811 static enum rofferr
1812 roff_block_sub(ROFF_ARGS)
1813 {
1814         enum roff_tok   t;
1815         int             i, j;
1816
1817         /*
1818          * First check whether a custom macro exists at this level.  If
1819          * it does, then check against it.  This is some of groff's
1820          * stranger behaviours.  If we encountered a custom end-scope
1821          * tag and that tag also happens to be a "real" macro, then we
1822          * need to try interpreting it again as a real macro.  If it's
1823          * not, then return ignore.  Else continue.
1824          */
1825
1826         if (r->last->end) {
1827                 for (i = pos, j = 0; r->last->end[j]; j++, i++)
1828                         if (buf->buf[i] != r->last->end[j])
1829                                 break;
1830
1831                 if (r->last->end[j] == '\0' &&
1832                     (buf->buf[i] == '\0' ||
1833                      buf->buf[i] == ' ' ||
1834                      buf->buf[i] == '\t')) {
1835                         roffnode_pop(r);
1836                         roffnode_cleanscope(r);
1837
1838                         while (buf->buf[i] == ' ' || buf->buf[i] == '\t')
1839                                 i++;
1840
1841                         pos = i;
1842                         if (roff_parse(r, buf->buf, &pos, ln, ppos) !=
1843                             TOKEN_NONE)
1844                                 return ROFF_RERUN;
1845                         return ROFF_IGN;
1846                 }
1847         }
1848
1849         /*
1850          * If we have no custom end-query or lookup failed, then try
1851          * pulling it out of the hashtable.
1852          */
1853
1854         t = roff_parse(r, buf->buf, &pos, ln, ppos);
1855
1856         if (t != ROFF_cblock) {
1857                 if (tok != ROFF_ig)
1858                         roff_setstr(r, r->last->name, buf->buf + ppos, 2);
1859                 return ROFF_IGN;
1860         }
1861
1862         return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
1863 }
1864
1865 static enum rofferr
1866 roff_block_text(ROFF_ARGS)
1867 {
1868
1869         if (tok != ROFF_ig)
1870                 roff_setstr(r, r->last->name, buf->buf + pos, 2);
1871
1872         return ROFF_IGN;
1873 }
1874
1875 static enum rofferr
1876 roff_cond_sub(ROFF_ARGS)
1877 {
1878         enum roff_tok    t;
1879         char            *ep;
1880         int              rr;
1881
1882         rr = r->last->rule;
1883         roffnode_cleanscope(r);
1884         t = roff_parse(r, buf->buf, &pos, ln, ppos);
1885
1886         /*
1887          * Fully handle known macros when they are structurally
1888          * required or when the conditional evaluated to true.
1889          */
1890
1891         if (t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT))
1892                 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
1893
1894         /*
1895          * If `\}' occurs on a macro line without a preceding macro,
1896          * drop the line completely.
1897          */
1898
1899         ep = buf->buf + pos;
1900         if (ep[0] == '\\' && ep[1] == '}')
1901                 rr = 0;
1902
1903         /* Always check for the closing delimiter `\}'. */
1904
1905         while ((ep = strchr(ep, '\\')) != NULL) {
1906                 if (*(++ep) == '}') {
1907                         *ep = '&';
1908                         roff_ccond(r, ln, ep - buf->buf - 1);
1909                 }
1910                 if (*ep != '\0')
1911                         ++ep;
1912         }
1913         return rr ? ROFF_CONT : ROFF_IGN;
1914 }
1915
1916 static enum rofferr
1917 roff_cond_text(ROFF_ARGS)
1918 {
1919         char            *ep;
1920         int              rr;
1921
1922         rr = r->last->rule;
1923         roffnode_cleanscope(r);
1924
1925         ep = buf->buf + pos;
1926         while ((ep = strchr(ep, '\\')) != NULL) {
1927                 if (*(++ep) == '}') {
1928                         *ep = '&';
1929                         roff_ccond(r, ln, ep - buf->buf - 1);
1930                 }
1931                 if (*ep != '\0')
1932                         ++ep;
1933         }
1934         return rr ? ROFF_CONT : ROFF_IGN;
1935 }
1936
1937 /* --- handling of numeric and conditional expressions -------------------- */
1938
1939 /*
1940  * Parse a single signed integer number.  Stop at the first non-digit.
1941  * If there is at least one digit, return success and advance the
1942  * parse point, else return failure and let the parse point unchanged.
1943  * Ignore overflows, treat them just like the C language.
1944  */
1945 static int
1946 roff_getnum(const char *v, int *pos, int *res, int flags)
1947 {
1948         int      myres, scaled, n, p;
1949
1950         if (NULL == res)
1951                 res = &myres;
1952
1953         p = *pos;
1954         n = v[p] == '-';
1955         if (n || v[p] == '+')
1956                 p++;
1957
1958         if (flags & ROFFNUM_WHITE)
1959                 while (isspace((unsigned char)v[p]))
1960                         p++;
1961
1962         for (*res = 0; isdigit((unsigned char)v[p]); p++)
1963                 *res = 10 * *res + v[p] - '0';
1964         if (p == *pos + n)
1965                 return 0;
1966
1967         if (n)
1968                 *res = -*res;
1969
1970         /* Each number may be followed by one optional scaling unit. */
1971
1972         switch (v[p]) {
1973         case 'f':
1974                 scaled = *res * 65536;
1975                 break;
1976         case 'i':
1977                 scaled = *res * 240;
1978                 break;
1979         case 'c':
1980                 scaled = *res * 240 / 2.54;
1981                 break;
1982         case 'v':
1983         case 'P':
1984                 scaled = *res * 40;
1985                 break;
1986         case 'm':
1987         case 'n':
1988                 scaled = *res * 24;
1989                 break;
1990         case 'p':
1991                 scaled = *res * 10 / 3;
1992                 break;
1993         case 'u':
1994                 scaled = *res;
1995                 break;
1996         case 'M':
1997                 scaled = *res * 6 / 25;
1998                 break;
1999         default:
2000                 scaled = *res;
2001                 p--;
2002                 break;
2003         }
2004         if (flags & ROFFNUM_SCALE)
2005                 *res = scaled;
2006
2007         *pos = p + 1;
2008         return 1;
2009 }
2010
2011 /*
2012  * Evaluate a string comparison condition.
2013  * The first character is the delimiter.
2014  * Succeed if the string up to its second occurrence
2015  * matches the string up to its third occurence.
2016  * Advance the cursor after the third occurrence
2017  * or lacking that, to the end of the line.
2018  */
2019 static int
2020 roff_evalstrcond(const char *v, int *pos)
2021 {
2022         const char      *s1, *s2, *s3;
2023         int              match;
2024
2025         match = 0;
2026         s1 = v + *pos;          /* initial delimiter */
2027         s2 = s1 + 1;            /* for scanning the first string */
2028         s3 = strchr(s2, *s1);   /* for scanning the second string */
2029
2030         if (NULL == s3)         /* found no middle delimiter */
2031                 goto out;
2032
2033         while ('\0' != *++s3) {
2034                 if (*s2 != *s3) {  /* mismatch */
2035                         s3 = strchr(s3, *s1);
2036                         break;
2037                 }
2038                 if (*s3 == *s1) {  /* found the final delimiter */
2039                         match = 1;
2040                         break;
2041                 }
2042                 s2++;
2043         }
2044
2045 out:
2046         if (NULL == s3)
2047                 s3 = strchr(s2, '\0');
2048         else if (*s3 != '\0')
2049                 s3++;
2050         *pos = s3 - v;
2051         return match;
2052 }
2053
2054 /*
2055  * Evaluate an optionally negated single character, numerical,
2056  * or string condition.
2057  */
2058 static int
2059 roff_evalcond(struct roff *r, int ln, char *v, int *pos)
2060 {
2061         char    *cp, *name;
2062         size_t   sz;
2063         int      number, savepos, wanttrue;
2064
2065         if ('!' == v[*pos]) {
2066                 wanttrue = 0;
2067                 (*pos)++;
2068         } else
2069                 wanttrue = 1;
2070
2071         switch (v[*pos]) {
2072         case '\0':
2073                 return 0;
2074         case 'n':
2075         case 'o':
2076                 (*pos)++;
2077                 return wanttrue;
2078         case 'c':
2079         case 'd':
2080         case 'e':
2081         case 't':
2082         case 'v':
2083                 (*pos)++;
2084                 return !wanttrue;
2085         case 'r':
2086                 cp = name = v + ++*pos;
2087                 sz = roff_getname(r, &cp, ln, *pos);
2088                 *pos = cp - v;
2089                 return (sz && roff_hasregn(r, name, sz)) == wanttrue;
2090         default:
2091                 break;
2092         }
2093
2094         savepos = *pos;
2095         if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE))
2096                 return (number > 0) == wanttrue;
2097         else if (*pos == savepos)
2098                 return roff_evalstrcond(v, pos) == wanttrue;
2099         else
2100                 return 0;
2101 }
2102
2103 static enum rofferr
2104 roff_line_ignore(ROFF_ARGS)
2105 {
2106
2107         return ROFF_IGN;
2108 }
2109
2110 static enum rofferr
2111 roff_insec(ROFF_ARGS)
2112 {
2113
2114         mandoc_msg(MANDOCERR_REQ_INSEC, r->parse,
2115             ln, ppos, roff_name[tok]);
2116         return ROFF_IGN;
2117 }
2118
2119 static enum rofferr
2120 roff_unsupp(ROFF_ARGS)
2121 {
2122
2123         mandoc_msg(MANDOCERR_REQ_UNSUPP, r->parse,
2124             ln, ppos, roff_name[tok]);
2125         return ROFF_IGN;
2126 }
2127
2128 static enum rofferr
2129 roff_cond(ROFF_ARGS)
2130 {
2131
2132         roffnode_push(r, tok, NULL, ln, ppos);
2133
2134         /*
2135          * An `.el' has no conditional body: it will consume the value
2136          * of the current rstack entry set in prior `ie' calls or
2137          * defaults to DENY.
2138          *
2139          * If we're not an `el', however, then evaluate the conditional.
2140          */
2141
2142         r->last->rule = tok == ROFF_el ?
2143             (r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) :
2144             roff_evalcond(r, ln, buf->buf, &pos);
2145
2146         /*
2147          * An if-else will put the NEGATION of the current evaluated
2148          * conditional into the stack of rules.
2149          */
2150
2151         if (tok == ROFF_ie) {
2152                 if (r->rstackpos + 1 == r->rstacksz) {
2153                         r->rstacksz += 16;
2154                         r->rstack = mandoc_reallocarray(r->rstack,
2155                             r->rstacksz, sizeof(int));
2156                 }
2157                 r->rstack[++r->rstackpos] = !r->last->rule;
2158         }
2159
2160         /* If the parent has false as its rule, then so do we. */
2161
2162         if (r->last->parent && !r->last->parent->rule)
2163                 r->last->rule = 0;
2164
2165         /*
2166          * Determine scope.
2167          * If there is nothing on the line after the conditional,
2168          * not even whitespace, use next-line scope.
2169          */
2170
2171         if (buf->buf[pos] == '\0') {
2172                 r->last->endspan = 2;
2173                 goto out;
2174         }
2175
2176         while (buf->buf[pos] == ' ')
2177                 pos++;
2178
2179         /* An opening brace requests multiline scope. */
2180
2181         if (buf->buf[pos] == '\\' && buf->buf[pos + 1] == '{') {
2182                 r->last->endspan = -1;
2183                 pos += 2;
2184                 while (buf->buf[pos] == ' ')
2185                         pos++;
2186                 goto out;
2187         }
2188
2189         /*
2190          * Anything else following the conditional causes
2191          * single-line scope.  Warn if the scope contains
2192          * nothing but trailing whitespace.
2193          */
2194
2195         if (buf->buf[pos] == '\0')
2196                 mandoc_msg(MANDOCERR_COND_EMPTY, r->parse,
2197                     ln, ppos, roff_name[tok]);
2198
2199         r->last->endspan = 1;
2200
2201 out:
2202         *offs = pos;
2203         return ROFF_RERUN;
2204 }
2205
2206 static enum rofferr
2207 roff_ds(ROFF_ARGS)
2208 {
2209         char            *string;
2210         const char      *name;
2211         size_t           namesz;
2212
2213         /* Ignore groff compatibility mode for now. */
2214
2215         if (tok == ROFF_ds1)
2216                 tok = ROFF_ds;
2217         else if (tok == ROFF_as1)
2218                 tok = ROFF_as;
2219
2220         /*
2221          * The first word is the name of the string.
2222          * If it is empty or terminated by an escape sequence,
2223          * abort the `ds' request without defining anything.
2224          */
2225
2226         name = string = buf->buf + pos;
2227         if (*name == '\0')
2228                 return ROFF_IGN;
2229
2230         namesz = roff_getname(r, &string, ln, pos);
2231         if (name[namesz] == '\\')
2232                 return ROFF_IGN;
2233
2234         /* Read past the initial double-quote, if any. */
2235         if (*string == '"')
2236                 string++;
2237
2238         /* The rest is the value. */
2239         roff_setstrn(&r->strtab, name, namesz, string, strlen(string),
2240             ROFF_as == tok);
2241         return ROFF_IGN;
2242 }
2243
2244 /*
2245  * Parse a single operator, one or two characters long.
2246  * If the operator is recognized, return success and advance the
2247  * parse point, else return failure and let the parse point unchanged.
2248  */
2249 static int
2250 roff_getop(const char *v, int *pos, char *res)
2251 {
2252
2253         *res = v[*pos];
2254
2255         switch (*res) {
2256         case '+':
2257         case '-':
2258         case '*':
2259         case '/':
2260         case '%':
2261         case '&':
2262         case ':':
2263                 break;
2264         case '<':
2265                 switch (v[*pos + 1]) {
2266                 case '=':
2267                         *res = 'l';
2268                         (*pos)++;
2269                         break;
2270                 case '>':
2271                         *res = '!';
2272                         (*pos)++;
2273                         break;
2274                 case '?':
2275                         *res = 'i';
2276                         (*pos)++;
2277                         break;
2278                 default:
2279                         break;
2280                 }
2281                 break;
2282         case '>':
2283                 switch (v[*pos + 1]) {
2284                 case '=':
2285                         *res = 'g';
2286                         (*pos)++;
2287                         break;
2288                 case '?':
2289                         *res = 'a';
2290                         (*pos)++;
2291                         break;
2292                 default:
2293                         break;
2294                 }
2295                 break;
2296         case '=':
2297                 if ('=' == v[*pos + 1])
2298                         (*pos)++;
2299                 break;
2300         default:
2301                 return 0;
2302         }
2303         (*pos)++;
2304
2305         return *res;
2306 }
2307
2308 /*
2309  * Evaluate either a parenthesized numeric expression
2310  * or a single signed integer number.
2311  */
2312 static int
2313 roff_evalpar(struct roff *r, int ln,
2314         const char *v, int *pos, int *res, int flags)
2315 {
2316
2317         if ('(' != v[*pos])
2318                 return roff_getnum(v, pos, res, flags);
2319
2320         (*pos)++;
2321         if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE))
2322                 return 0;
2323
2324         /*
2325          * Omission of the closing parenthesis
2326          * is an error in validation mode,
2327          * but ignored in evaluation mode.
2328          */
2329
2330         if (')' == v[*pos])
2331                 (*pos)++;
2332         else if (NULL == res)
2333                 return 0;
2334
2335         return 1;
2336 }
2337
2338 /*
2339  * Evaluate a complete numeric expression.
2340  * Proceed left to right, there is no concept of precedence.
2341  */
2342 static int
2343 roff_evalnum(struct roff *r, int ln, const char *v,
2344         int *pos, int *res, int flags)
2345 {
2346         int              mypos, operand2;
2347         char             operator;
2348
2349         if (NULL == pos) {
2350                 mypos = 0;
2351                 pos = &mypos;
2352         }
2353
2354         if (flags & ROFFNUM_WHITE)
2355                 while (isspace((unsigned char)v[*pos]))
2356                         (*pos)++;
2357
2358         if ( ! roff_evalpar(r, ln, v, pos, res, flags))
2359                 return 0;
2360
2361         while (1) {
2362                 if (flags & ROFFNUM_WHITE)
2363                         while (isspace((unsigned char)v[*pos]))
2364                                 (*pos)++;
2365
2366                 if ( ! roff_getop(v, pos, &operator))
2367                         break;
2368
2369                 if (flags & ROFFNUM_WHITE)
2370                         while (isspace((unsigned char)v[*pos]))
2371                                 (*pos)++;
2372
2373                 if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags))
2374                         return 0;
2375
2376                 if (flags & ROFFNUM_WHITE)
2377                         while (isspace((unsigned char)v[*pos]))
2378                                 (*pos)++;
2379
2380                 if (NULL == res)
2381                         continue;
2382
2383                 switch (operator) {
2384                 case '+':
2385                         *res += operand2;
2386                         break;
2387                 case '-':
2388                         *res -= operand2;
2389                         break;
2390                 case '*':
2391                         *res *= operand2;
2392                         break;
2393                 case '/':
2394                         if (operand2 == 0) {
2395                                 mandoc_msg(MANDOCERR_DIVZERO,
2396                                         r->parse, ln, *pos, v);
2397                                 *res = 0;
2398                                 break;
2399                         }
2400                         *res /= operand2;
2401                         break;
2402                 case '%':
2403                         if (operand2 == 0) {
2404                                 mandoc_msg(MANDOCERR_DIVZERO,
2405                                         r->parse, ln, *pos, v);
2406                                 *res = 0;
2407                                 break;
2408                         }
2409                         *res %= operand2;
2410                         break;
2411                 case '<':
2412                         *res = *res < operand2;
2413                         break;
2414                 case '>':
2415                         *res = *res > operand2;
2416                         break;
2417                 case 'l':
2418                         *res = *res <= operand2;
2419                         break;
2420                 case 'g':
2421                         *res = *res >= operand2;
2422                         break;
2423                 case '=':
2424                         *res = *res == operand2;
2425                         break;
2426                 case '!':
2427                         *res = *res != operand2;
2428                         break;
2429                 case '&':
2430                         *res = *res && operand2;
2431                         break;
2432                 case ':':
2433                         *res = *res || operand2;
2434                         break;
2435                 case 'i':
2436                         if (operand2 < *res)
2437                                 *res = operand2;
2438                         break;
2439                 case 'a':
2440                         if (operand2 > *res)
2441                                 *res = operand2;
2442                         break;
2443                 default:
2444                         abort();
2445                 }
2446         }
2447         return 1;
2448 }
2449
2450 /* --- register management ------------------------------------------------ */
2451
2452 void
2453 roff_setreg(struct roff *r, const char *name, int val, char sign)
2454 {
2455         struct roffreg  *reg;
2456
2457         /* Search for an existing register with the same name. */
2458         reg = r->regtab;
2459
2460         while (reg && strcmp(name, reg->key.p))
2461                 reg = reg->next;
2462
2463         if (NULL == reg) {
2464                 /* Create a new register. */
2465                 reg = mandoc_malloc(sizeof(struct roffreg));
2466                 reg->key.p = mandoc_strdup(name);
2467                 reg->key.sz = strlen(name);
2468                 reg->val = 0;
2469                 reg->next = r->regtab;
2470                 r->regtab = reg;
2471         }
2472
2473         if ('+' == sign)
2474                 reg->val += val;
2475         else if ('-' == sign)
2476                 reg->val -= val;
2477         else
2478                 reg->val = val;
2479 }
2480
2481 /*
2482  * Handle some predefined read-only number registers.
2483  * For now, return -1 if the requested register is not predefined;
2484  * in case a predefined read-only register having the value -1
2485  * were to turn up, another special value would have to be chosen.
2486  */
2487 static int
2488 roff_getregro(const struct roff *r, const char *name)
2489 {
2490
2491         switch (*name) {
2492         case '$':  /* Number of arguments of the last macro evaluated. */
2493                 return r->argc;
2494         case 'A':  /* ASCII approximation mode is always off. */
2495                 return 0;
2496         case 'g':  /* Groff compatibility mode is always on. */
2497                 return 1;
2498         case 'H':  /* Fixed horizontal resolution. */
2499                 return 24;
2500         case 'j':  /* Always adjust left margin only. */
2501                 return 0;
2502         case 'T':  /* Some output device is always defined. */
2503                 return 1;
2504         case 'V':  /* Fixed vertical resolution. */
2505                 return 40;
2506         default:
2507                 return -1;
2508         }
2509 }
2510
2511 int
2512 roff_getreg(const struct roff *r, const char *name)
2513 {
2514         struct roffreg  *reg;
2515         int              val;
2516
2517         if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) {
2518                 val = roff_getregro(r, name + 1);
2519                 if (-1 != val)
2520                         return val;
2521         }
2522
2523         for (reg = r->regtab; reg; reg = reg->next)
2524                 if (0 == strcmp(name, reg->key.p))
2525                         return reg->val;
2526
2527         return 0;
2528 }
2529
2530 static int
2531 roff_getregn(const struct roff *r, const char *name, size_t len)
2532 {
2533         struct roffreg  *reg;
2534         int              val;
2535
2536         if ('.' == name[0] && 2 == len) {
2537                 val = roff_getregro(r, name + 1);
2538                 if (-1 != val)
2539                         return val;
2540         }
2541
2542         for (reg = r->regtab; reg; reg = reg->next)
2543                 if (len == reg->key.sz &&
2544                     0 == strncmp(name, reg->key.p, len))
2545                         return reg->val;
2546
2547         return 0;
2548 }
2549
2550 static int
2551 roff_hasregn(const struct roff *r, const char *name, size_t len)
2552 {
2553         struct roffreg  *reg;
2554         int              val;
2555
2556         if ('.' == name[0] && 2 == len) {
2557                 val = roff_getregro(r, name + 1);
2558                 if (-1 != val)
2559                         return 1;
2560         }
2561
2562         for (reg = r->regtab; reg; reg = reg->next)
2563                 if (len == reg->key.sz &&
2564                     0 == strncmp(name, reg->key.p, len))
2565                         return 1;
2566
2567         return 0;
2568 }
2569
2570 static void
2571 roff_freereg(struct roffreg *reg)
2572 {
2573         struct roffreg  *old_reg;
2574
2575         while (NULL != reg) {
2576                 free(reg->key.p);
2577                 old_reg = reg;
2578                 reg = reg->next;
2579                 free(old_reg);
2580         }
2581 }
2582
2583 static enum rofferr
2584 roff_nr(ROFF_ARGS)
2585 {
2586         char            *key, *val;
2587         size_t           keysz;
2588         int              iv;
2589         char             sign;
2590
2591         key = val = buf->buf + pos;
2592         if (*key == '\0')
2593                 return ROFF_IGN;
2594
2595         keysz = roff_getname(r, &val, ln, pos);
2596         if (key[keysz] == '\\')
2597                 return ROFF_IGN;
2598         key[keysz] = '\0';
2599
2600         sign = *val;
2601         if (sign == '+' || sign == '-')
2602                 val++;
2603
2604         if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE))
2605                 roff_setreg(r, key, iv, sign);
2606
2607         return ROFF_IGN;
2608 }
2609
2610 static enum rofferr
2611 roff_rr(ROFF_ARGS)
2612 {
2613         struct roffreg  *reg, **prev;
2614         char            *name, *cp;
2615         size_t           namesz;
2616
2617         name = cp = buf->buf + pos;
2618         if (*name == '\0')
2619                 return ROFF_IGN;
2620         namesz = roff_getname(r, &cp, ln, pos);
2621         name[namesz] = '\0';
2622
2623         prev = &r->regtab;
2624         while (1) {
2625                 reg = *prev;
2626                 if (reg == NULL || !strcmp(name, reg->key.p))
2627                         break;
2628                 prev = &reg->next;
2629         }
2630         if (reg != NULL) {
2631                 *prev = reg->next;
2632                 free(reg->key.p);
2633                 free(reg);
2634         }
2635         return ROFF_IGN;
2636 }
2637
2638 /* --- handler functions for roff requests -------------------------------- */
2639
2640 static enum rofferr
2641 roff_rm(ROFF_ARGS)
2642 {
2643         const char       *name;
2644         char             *cp;
2645         size_t            namesz;
2646
2647         cp = buf->buf + pos;
2648         while (*cp != '\0') {
2649                 name = cp;
2650                 namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf));
2651                 roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0);
2652                 if (name[namesz] == '\\')
2653                         break;
2654         }
2655         return ROFF_IGN;
2656 }
2657
2658 static enum rofferr
2659 roff_it(ROFF_ARGS)
2660 {
2661         int              iv;
2662
2663         /* Parse the number of lines. */
2664
2665         if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) {
2666                 mandoc_msg(MANDOCERR_IT_NONUM, r->parse,
2667                     ln, ppos, buf->buf + 1);
2668                 return ROFF_IGN;
2669         }
2670
2671         while (isspace((unsigned char)buf->buf[pos]))
2672                 pos++;
2673
2674         /*
2675          * Arm the input line trap.
2676          * Special-casing "an-trap" is an ugly workaround to cope
2677          * with DocBook stupidly fiddling with man(7) internals.
2678          */
2679
2680         roffit_lines = iv;
2681         roffit_macro = mandoc_strdup(iv != 1 ||
2682             strcmp(buf->buf + pos, "an-trap") ?
2683             buf->buf + pos : "br");
2684         return ROFF_IGN;
2685 }
2686
2687 static enum rofferr
2688 roff_Dd(ROFF_ARGS)
2689 {
2690         const char *const       *cp;
2691
2692         if ((r->options & (MPARSE_MDOC | MPARSE_QUICK)) == 0)
2693                 for (cp = __mdoc_reserved; *cp; cp++)
2694                         roff_setstr(r, *cp, NULL, 0);
2695
2696         if (r->format == 0)
2697                 r->format = MPARSE_MDOC;
2698
2699         return ROFF_CONT;
2700 }
2701
2702 static enum rofferr
2703 roff_TH(ROFF_ARGS)
2704 {
2705         const char *const       *cp;
2706
2707         if ((r->options & MPARSE_QUICK) == 0)
2708                 for (cp = __man_reserved; *cp; cp++)
2709                         roff_setstr(r, *cp, NULL, 0);
2710
2711         if (r->format == 0)
2712                 r->format = MPARSE_MAN;
2713
2714         return ROFF_CONT;
2715 }
2716
2717 static enum rofferr
2718 roff_TE(ROFF_ARGS)
2719 {
2720
2721         if (NULL == r->tbl)
2722                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
2723                     ln, ppos, "TE");
2724         else if ( ! tbl_end(&r->tbl)) {
2725                 free(buf->buf);
2726                 buf->buf = mandoc_strdup(".sp");
2727                 buf->sz = 4;
2728                 return ROFF_REPARSE;
2729         }
2730         return ROFF_IGN;
2731 }
2732
2733 static enum rofferr
2734 roff_T_(ROFF_ARGS)
2735 {
2736
2737         if (NULL == r->tbl)
2738                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
2739                     ln, ppos, "T&");
2740         else
2741                 tbl_restart(ln, ppos, r->tbl);
2742
2743         return ROFF_IGN;
2744 }
2745
2746 /*
2747  * Handle in-line equation delimiters.
2748  */
2749 static enum rofferr
2750 roff_eqndelim(struct roff *r, struct buf *buf, int pos)
2751 {
2752         char            *cp1, *cp2;
2753         const char      *bef_pr, *bef_nl, *mac, *aft_nl, *aft_pr;
2754
2755         /*
2756          * Outside equations, look for an opening delimiter.
2757          * If we are inside an equation, we already know it is
2758          * in-line, or this function wouldn't have been called;
2759          * so look for a closing delimiter.
2760          */
2761
2762         cp1 = buf->buf + pos;
2763         cp2 = strchr(cp1, r->eqn == NULL ?
2764             r->last_eqn->odelim : r->last_eqn->cdelim);
2765         if (cp2 == NULL)
2766                 return ROFF_CONT;
2767
2768         *cp2++ = '\0';
2769         bef_pr = bef_nl = aft_nl = aft_pr = "";
2770
2771         /* Handle preceding text, protecting whitespace. */
2772
2773         if (*buf->buf != '\0') {
2774                 if (r->eqn == NULL)
2775                         bef_pr = "\\&";
2776                 bef_nl = "\n";
2777         }
2778
2779         /*
2780          * Prepare replacing the delimiter with an equation macro
2781          * and drop leading white space from the equation.
2782          */
2783
2784         if (r->eqn == NULL) {
2785                 while (*cp2 == ' ')
2786                         cp2++;
2787                 mac = ".EQ";
2788         } else
2789                 mac = ".EN";
2790
2791         /* Handle following text, protecting whitespace. */
2792
2793         if (*cp2 != '\0') {
2794                 aft_nl = "\n";
2795                 if (r->eqn != NULL)
2796                         aft_pr = "\\&";
2797         }
2798
2799         /* Do the actual replacement. */
2800
2801         buf->sz = mandoc_asprintf(&cp1, "%s%s%s%s%s%s%s", buf->buf,
2802             bef_pr, bef_nl, mac, aft_nl, aft_pr, cp2) + 1;
2803         free(buf->buf);
2804         buf->buf = cp1;
2805
2806         /* Toggle the in-line state of the eqn subsystem. */
2807
2808         r->eqn_inline = r->eqn == NULL;
2809         return ROFF_REPARSE;
2810 }
2811
2812 static enum rofferr
2813 roff_EQ(ROFF_ARGS)
2814 {
2815         struct eqn_node *e;
2816
2817         assert(r->eqn == NULL);
2818         e = eqn_alloc(ppos, ln, r->parse);
2819
2820         if (r->last_eqn) {
2821                 r->last_eqn->next = e;
2822                 e->delim = r->last_eqn->delim;
2823                 e->odelim = r->last_eqn->odelim;
2824                 e->cdelim = r->last_eqn->cdelim;
2825         } else
2826                 r->first_eqn = r->last_eqn = e;
2827
2828         r->eqn = r->last_eqn = e;
2829
2830         if (buf->buf[pos] != '\0')
2831                 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
2832                     ".EQ %s", buf->buf + pos);
2833
2834         return ROFF_IGN;
2835 }
2836
2837 static enum rofferr
2838 roff_EN(ROFF_ARGS)
2839 {
2840
2841         mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");
2842         return ROFF_IGN;
2843 }
2844
2845 static enum rofferr
2846 roff_TS(ROFF_ARGS)
2847 {
2848         struct tbl_node *tbl;
2849
2850         if (r->tbl) {
2851                 mandoc_msg(MANDOCERR_BLK_BROKEN, r->parse,
2852                     ln, ppos, "TS breaks TS");
2853                 tbl_end(&r->tbl);
2854         }
2855
2856         tbl = tbl_alloc(ppos, ln, r->parse);
2857
2858         if (r->last_tbl)
2859                 r->last_tbl->next = tbl;
2860         else
2861                 r->first_tbl = r->last_tbl = tbl;
2862
2863         r->tbl = r->last_tbl = tbl;
2864         return ROFF_IGN;
2865 }
2866
2867 static enum rofferr
2868 roff_onearg(ROFF_ARGS)
2869 {
2870         struct roff_node        *n;
2871         char                    *cp;
2872         int                      npos;
2873
2874         if (r->man->flags & (MAN_BLINE | MAN_ELINE) &&
2875             (tok == ROFF_sp || tok == ROFF_ti))
2876                 man_breakscope(r->man, tok);
2877
2878         if (tok == ROFF_ce && roffce_node != NULL) {
2879                 r->man->last = roffce_node;
2880                 r->man->next = ROFF_NEXT_SIBLING;
2881         }
2882
2883         roff_elem_alloc(r->man, ln, ppos, tok);
2884         n = r->man->last;
2885
2886         cp = buf->buf + pos;
2887         if (*cp != '\0') {
2888                 while (*cp != '\0' && *cp != ' ')
2889                         cp++;
2890                 while (*cp == ' ')
2891                         *cp++ = '\0';
2892                 if (*cp != '\0')
2893                         mandoc_vmsg(MANDOCERR_ARG_EXCESS,
2894                             r->parse, ln, cp - buf->buf,
2895                             "%s ... %s", roff_name[tok], cp);
2896                 roff_word_alloc(r->man, ln, pos, buf->buf + pos);
2897         }
2898
2899         if (tok == ROFF_ce) {
2900                 if (r->man->last->tok == ROFF_ce) {
2901                         roff_word_alloc(r->man, ln, pos, "1");
2902                         r->man->last->flags |= NODE_NOSRC;
2903                 }
2904                 npos = 0;
2905                 if (roff_evalnum(r, ln, r->man->last->string, &npos,
2906                     &roffce_lines, 0) == 0) {
2907                         mandoc_vmsg(MANDOCERR_CE_NONUM,
2908                             r->parse, ln, pos, "ce %s", buf->buf + pos);
2909                         roffce_lines = 1;
2910                 }
2911                 if (roffce_lines < 1) {
2912                         r->man->last = r->man->last->parent;
2913                         roffce_node = NULL;
2914                         roffce_lines = 0;
2915                 } else
2916                         roffce_node = r->man->last->parent;
2917         } else {
2918                 n->flags |= NODE_VALID | NODE_ENDED;
2919                 r->man->last = n;
2920         }
2921         n->flags |= NODE_LINE;
2922         r->man->next = ROFF_NEXT_SIBLING;
2923         return ROFF_IGN;
2924 }
2925
2926 static enum rofferr
2927 roff_manyarg(ROFF_ARGS)
2928 {
2929         struct roff_node        *n;
2930         char                    *sp, *ep;
2931
2932         roff_elem_alloc(r->man, ln, ppos, tok);
2933         n = r->man->last;
2934
2935         for (sp = ep = buf->buf + pos; *sp != '\0'; sp = ep) {
2936                 while (*ep != '\0' && *ep != ' ')
2937                         ep++;
2938                 while (*ep == ' ')
2939                         *ep++ = '\0';
2940                 roff_word_alloc(r->man, ln, sp - buf->buf, sp);
2941         }
2942
2943         n->flags |= NODE_LINE | NODE_VALID | NODE_ENDED;
2944         r->man->last = n;
2945         r->man->next = ROFF_NEXT_SIBLING;
2946         return ROFF_IGN;
2947 }
2948
2949 static enum rofferr
2950 roff_br(ROFF_ARGS)
2951 {
2952         if (r->man->flags & (MAN_BLINE | MAN_ELINE))
2953                 man_breakscope(r->man, ROFF_br);
2954         roff_elem_alloc(r->man, ln, ppos, ROFF_br);
2955         if (buf->buf[pos] != '\0')
2956                 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
2957                     "%s %s", roff_name[tok], buf->buf + pos);
2958         r->man->last->flags |= NODE_LINE | NODE_VALID | NODE_ENDED;
2959         r->man->next = ROFF_NEXT_SIBLING;
2960         return ROFF_IGN;
2961 }
2962
2963 static enum rofferr
2964 roff_cc(ROFF_ARGS)
2965 {
2966         const char      *p;
2967
2968         p = buf->buf + pos;
2969
2970         if (*p == '\0' || (r->control = *p++) == '.')
2971                 r->control = '\0';
2972
2973         if (*p != '\0')
2974                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
2975                     ln, p - buf->buf, "cc ... %s", p);
2976
2977         return ROFF_IGN;
2978 }
2979
2980 static enum rofferr
2981 roff_ec(ROFF_ARGS)
2982 {
2983         const char      *p;
2984
2985         p = buf->buf + pos;
2986         if (*p == '\0')
2987                 r->escape = '\\';
2988         else {
2989                 r->escape = *p;
2990                 if (*++p != '\0')
2991                         mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
2992                             ln, p - buf->buf, "ec ... %s", p);
2993         }
2994         return ROFF_IGN;
2995 }
2996
2997 static enum rofferr
2998 roff_eo(ROFF_ARGS)
2999 {
3000         r->escape = '\0';
3001         if (buf->buf[pos] != '\0')
3002                 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse,
3003                     ln, pos, "eo %s", buf->buf + pos);
3004         return ROFF_IGN;
3005 }
3006
3007 static enum rofferr
3008 roff_tr(ROFF_ARGS)
3009 {
3010         const char      *p, *first, *second;
3011         size_t           fsz, ssz;
3012         enum mandoc_esc  esc;
3013
3014         p = buf->buf + pos;
3015
3016         if (*p == '\0') {
3017                 mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr");
3018                 return ROFF_IGN;
3019         }
3020
3021         while (*p != '\0') {
3022                 fsz = ssz = 1;
3023
3024                 first = p++;
3025                 if (*first == '\\') {
3026                         esc = mandoc_escape(&p, NULL, NULL);
3027                         if (esc == ESCAPE_ERROR) {
3028                                 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
3029                                     ln, (int)(p - buf->buf), first);
3030                                 return ROFF_IGN;
3031                         }
3032                         fsz = (size_t)(p - first);
3033                 }
3034
3035                 second = p++;
3036                 if (*second == '\\') {
3037                         esc = mandoc_escape(&p, NULL, NULL);
3038                         if (esc == ESCAPE_ERROR) {
3039                                 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
3040                                     ln, (int)(p - buf->buf), second);
3041                                 return ROFF_IGN;
3042                         }
3043                         ssz = (size_t)(p - second);
3044                 } else if (*second == '\0') {
3045                         mandoc_vmsg(MANDOCERR_TR_ODD, r->parse,
3046                             ln, first - buf->buf, "tr %s", first);
3047                         second = " ";
3048                         p--;
3049                 }
3050
3051                 if (fsz > 1) {
3052                         roff_setstrn(&r->xmbtab, first, fsz,
3053                             second, ssz, 0);
3054                         continue;
3055                 }
3056
3057                 if (r->xtab == NULL)
3058                         r->xtab = mandoc_calloc(128,
3059                             sizeof(struct roffstr));
3060
3061                 free(r->xtab[(int)*first].p);
3062                 r->xtab[(int)*first].p = mandoc_strndup(second, ssz);
3063                 r->xtab[(int)*first].sz = ssz;
3064         }
3065
3066         return ROFF_IGN;
3067 }
3068
3069 static enum rofferr
3070 roff_rn(ROFF_ARGS)
3071 {
3072         const char      *value;
3073         char            *oldn, *newn, *end;
3074         size_t           oldsz, newsz;
3075
3076         oldn = newn = buf->buf + pos;
3077         if (*oldn == '\0')
3078                 return ROFF_IGN;
3079
3080         oldsz = roff_getname(r, &newn, ln, pos);
3081         if (oldn[oldsz] == '\\' || *newn == '\0')
3082                 return ROFF_IGN;
3083
3084         end = newn;
3085         newsz = roff_getname(r, &end, ln, newn - buf->buf);
3086         if (newsz == 0)
3087                 return ROFF_IGN;
3088
3089         /*
3090          * Rename a user-defined macro bearing the old name,
3091          * overriding an existing renamed high-level macro
3092          * bearing the new name, if that exists.
3093          */
3094
3095         if ((value = roff_getstrn(r, oldn, oldsz)) != NULL) {
3096                 roff_setstrn(&r->strtab, newn, newsz, value, strlen(value), 0);
3097                 roff_setstrn(&r->strtab, oldn, oldsz, NULL, 0, 0);
3098                 roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0);
3099                 return ROFF_IGN;
3100         }
3101
3102         /*
3103          * Rename a high-level macro bearing the old name,
3104          * either renaming it a second time if it was already
3105          * renamed before, or renaming it for the first time.
3106          * In both cases, override an existing user-defined
3107          * macro bearing the new name, if that exists.
3108          */
3109
3110         if ((value = roff_getrenn(r, oldn, oldsz)) != NULL) {
3111                 roff_setstrn(&r->rentab, newn, newsz, value, strlen(value), 0);
3112                 roff_setstrn(&r->rentab, oldn, oldsz, NULL, 0, 0);
3113         } else
3114                 roff_setstrn(&r->rentab, newn, newsz, oldn, oldsz, 0);
3115         roff_setstrn(&r->strtab, newn, newsz, NULL, 0, 0);
3116         return ROFF_IGN;
3117 }
3118
3119 static enum rofferr
3120 roff_so(ROFF_ARGS)
3121 {
3122         char *name, *cp;
3123
3124         name = buf->buf + pos;
3125         mandoc_vmsg(MANDOCERR_SO, r->parse, ln, ppos, "so %s", name);
3126
3127         /*
3128          * Handle `so'.  Be EXTREMELY careful, as we shouldn't be
3129          * opening anything that's not in our cwd or anything beneath
3130          * it.  Thus, explicitly disallow traversing up the file-system
3131          * or using absolute paths.
3132          */
3133
3134         if (*name == '/' || strstr(name, "../") || strstr(name, "/..")) {
3135                 mandoc_vmsg(MANDOCERR_SO_PATH, r->parse, ln, ppos,
3136                     ".so %s", name);
3137                 buf->sz = mandoc_asprintf(&cp,
3138                     ".sp\nSee the file %s.\n.sp", name) + 1;
3139                 free(buf->buf);
3140                 buf->buf = cp;
3141                 *offs = 0;
3142                 return ROFF_REPARSE;
3143         }
3144
3145         *offs = pos;
3146         return ROFF_SO;
3147 }
3148
3149 /* --- user defined strings and macros ------------------------------------ */
3150
3151 static enum rofferr
3152 roff_userdef(ROFF_ARGS)
3153 {
3154         const char       *arg[9], *ap;
3155         char             *cp, *n1, *n2;
3156         int               expand_count, i, ib, ie;
3157         size_t            asz, rsz;
3158
3159         /*
3160          * Collect pointers to macro argument strings
3161          * and NUL-terminate them.
3162          */
3163
3164         r->argc = 0;
3165         cp = buf->buf + pos;
3166         for (i = 0; i < 9; i++) {
3167                 if (*cp == '\0')
3168                         arg[i] = "";
3169                 else {
3170                         arg[i] = mandoc_getarg(r->parse, &cp, ln, &pos);
3171                         r->argc = i + 1;
3172                 }
3173         }
3174
3175         /*
3176          * Expand macro arguments.
3177          */
3178
3179         buf->sz = strlen(r->current_string) + 1;
3180         n1 = n2 = cp = mandoc_malloc(buf->sz);
3181         memcpy(n1, r->current_string, buf->sz);
3182         expand_count = 0;
3183         while (*cp != '\0') {
3184
3185                 /* Scan ahead for the next argument invocation. */
3186
3187                 if (*cp++ != '\\')
3188                         continue;
3189                 if (*cp++ != '$')
3190                         continue;
3191                 if (*cp == '*') {  /* \\$* inserts all arguments */
3192                         ib = 0;
3193                         ie = r->argc - 1;
3194                 } else {  /* \\$1 .. \\$9 insert one argument */
3195                         ib = ie = *cp - '1';
3196                         if (ib < 0 || ib > 8)
3197                                 continue;
3198                 }
3199                 cp -= 2;
3200
3201                 /*
3202                  * Prevent infinite recursion.
3203                  */
3204
3205                 if (cp >= n2)
3206                         expand_count = 1;
3207                 else if (++expand_count > EXPAND_LIMIT) {
3208                         mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
3209                             ln, (int)(cp - n1), NULL);
3210                         free(buf->buf);
3211                         buf->buf = n1;
3212                         return ROFF_IGN;
3213                 }
3214
3215                 /*
3216                  * Determine the size of the expanded argument,
3217                  * taking escaping of quotes into account.
3218                  */
3219
3220                 asz = ie > ib ? ie - ib : 0;  /* for blanks */
3221                 for (i = ib; i <= ie; i++) {
3222                         for (ap = arg[i]; *ap != '\0'; ap++) {
3223                                 asz++;
3224                                 if (*ap == '"')
3225                                         asz += 3;
3226                         }
3227                 }
3228                 if (asz != 3) {
3229
3230                         /*
3231                          * Determine the size of the rest of the
3232                          * unexpanded macro, including the NUL.
3233                          */
3234
3235                         rsz = buf->sz - (cp - n1) - 3;
3236
3237                         /*
3238                          * When shrinking, move before
3239                          * releasing the storage.
3240                          */
3241
3242                         if (asz < 3)
3243                                 memmove(cp + asz, cp + 3, rsz);
3244
3245                         /*
3246                          * Resize the storage for the macro
3247                          * and readjust the parse pointer.
3248                          */
3249
3250                         buf->sz += asz - 3;
3251                         n2 = mandoc_realloc(n1, buf->sz);
3252                         cp = n2 + (cp - n1);
3253                         n1 = n2;
3254
3255                         /*
3256                          * When growing, make room
3257                          * for the expanded argument.
3258                          */
3259
3260                         if (asz > 3)
3261                                 memmove(cp + asz, cp + 3, rsz);
3262                 }
3263
3264                 /* Copy the expanded argument, escaping quotes. */
3265
3266                 n2 = cp;
3267                 for (i = ib; i <= ie; i++) {
3268                         for (ap = arg[i]; *ap != '\0'; ap++) {
3269                                 if (*ap == '"') {
3270                                         memcpy(n2, "\\(dq", 4);
3271                                         n2 += 4;
3272                                 } else
3273                                         *n2++ = *ap;
3274                         }
3275                         if (i < ie)
3276                                 *n2++ = ' ';
3277                 }
3278         }
3279
3280         /*
3281          * Replace the macro invocation
3282          * by the expanded macro.
3283          */
3284
3285         free(buf->buf);
3286         buf->buf = n1;
3287         *offs = 0;
3288
3289         return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?
3290            ROFF_REPARSE : ROFF_APPEND;
3291 }
3292
3293 /*
3294  * Calling a high-level macro that was renamed with .rn.
3295  * r->current_string has already been set up by roff_parse().
3296  */
3297 static enum rofferr
3298 roff_renamed(ROFF_ARGS)
3299 {
3300         char    *nbuf;
3301
3302         buf->sz = mandoc_asprintf(&nbuf, ".%s %s", r->current_string,
3303             buf->buf + pos) + 1;
3304         free(buf->buf);
3305         buf->buf = nbuf;
3306         return ROFF_CONT;
3307 }
3308
3309 static size_t
3310 roff_getname(struct roff *r, char **cpp, int ln, int pos)
3311 {
3312         char     *name, *cp;
3313         size_t    namesz;
3314
3315         name = *cpp;
3316         if ('\0' == *name)
3317                 return 0;
3318
3319         /* Read until end of name and terminate it with NUL. */
3320         for (cp = name; 1; cp++) {
3321                 if ('\0' == *cp || ' ' == *cp) {
3322                         namesz = cp - name;
3323                         break;
3324                 }
3325                 if ('\\' != *cp)
3326                         continue;
3327                 namesz = cp - name;
3328                 if ('{' == cp[1] || '}' == cp[1])
3329                         break;
3330                 cp++;
3331                 if ('\\' == *cp)
3332                         continue;
3333                 mandoc_vmsg(MANDOCERR_NAMESC, r->parse, ln, pos,
3334                     "%.*s", (int)(cp - name + 1), name);
3335                 mandoc_escape((const char **)&cp, NULL, NULL);
3336                 break;
3337         }
3338
3339         /* Read past spaces. */
3340         while (' ' == *cp)
3341                 cp++;
3342
3343         *cpp = cp;
3344         return namesz;
3345 }
3346
3347 /*
3348  * Store *string into the user-defined string called *name.
3349  * To clear an existing entry, call with (*r, *name, NULL, 0).
3350  * append == 0: replace mode
3351  * append == 1: single-line append mode
3352  * append == 2: multiline append mode, append '\n' after each call
3353  */
3354 static void
3355 roff_setstr(struct roff *r, const char *name, const char *string,
3356         int append)
3357 {
3358
3359         roff_setstrn(&r->strtab, name, strlen(name), string,
3360             string ? strlen(string) : 0, append);
3361 }
3362
3363 static void
3364 roff_setstrn(struct roffkv **r, const char *name, size_t namesz,
3365                 const char *string, size_t stringsz, int append)
3366 {
3367         struct roffkv   *n;
3368         char            *c;
3369         int              i;
3370         size_t           oldch, newch;
3371
3372         /* Search for an existing string with the same name. */
3373         n = *r;
3374
3375         while (n && (namesz != n->key.sz ||
3376                         strncmp(n->key.p, name, namesz)))
3377                 n = n->next;
3378
3379         if (NULL == n) {
3380                 /* Create a new string table entry. */
3381                 n = mandoc_malloc(sizeof(struct roffkv));
3382                 n->key.p = mandoc_strndup(name, namesz);
3383                 n->key.sz = namesz;
3384                 n->val.p = NULL;
3385                 n->val.sz = 0;
3386                 n->next = *r;
3387                 *r = n;
3388         } else if (0 == append) {
3389                 free(n->val.p);
3390                 n->val.p = NULL;
3391                 n->val.sz = 0;
3392         }
3393
3394         if (NULL == string)
3395                 return;
3396
3397         /*
3398          * One additional byte for the '\n' in multiline mode,
3399          * and one for the terminating '\0'.
3400          */
3401         newch = stringsz + (1 < append ? 2u : 1u);
3402
3403         if (NULL == n->val.p) {
3404                 n->val.p = mandoc_malloc(newch);
3405                 *n->val.p = '\0';
3406                 oldch = 0;
3407         } else {
3408                 oldch = n->val.sz;
3409                 n->val.p = mandoc_realloc(n->val.p, oldch + newch);
3410         }
3411
3412         /* Skip existing content in the destination buffer. */
3413         c = n->val.p + (int)oldch;
3414
3415         /* Append new content to the destination buffer. */
3416         i = 0;
3417         while (i < (int)stringsz) {
3418                 /*
3419                  * Rudimentary roff copy mode:
3420                  * Handle escaped backslashes.
3421                  */
3422                 if ('\\' == string[i] && '\\' == string[i + 1])
3423                         i++;
3424                 *c++ = string[i++];
3425         }
3426
3427         /* Append terminating bytes. */
3428         if (1 < append)
3429                 *c++ = '\n';
3430
3431         *c = '\0';
3432         n->val.sz = (int)(c - n->val.p);
3433 }
3434
3435 static const char *
3436 roff_getstrn(const struct roff *r, const char *name, size_t len)
3437 {
3438         const struct roffkv *n;
3439         int i;
3440
3441         for (n = r->strtab; n; n = n->next)
3442                 if (0 == strncmp(name, n->key.p, len) &&
3443                     '\0' == n->key.p[(int)len])
3444                         return n->val.p;
3445
3446         for (i = 0; i < PREDEFS_MAX; i++)
3447                 if (0 == strncmp(name, predefs[i].name, len) &&
3448                                 '\0' == predefs[i].name[(int)len])
3449                         return predefs[i].str;
3450
3451         return NULL;
3452 }
3453
3454 /*
3455  * Check whether *name is the renamed name of a high-level macro.
3456  * Return the standard name, or NULL if it is not.
3457  */
3458 static const char *
3459 roff_getrenn(const struct roff *r, const char *name, size_t len)
3460 {
3461         const struct roffkv *n;
3462
3463         for (n = r->rentab; n; n = n->next)
3464                 if (0 == strncmp(name, n->key.p, len) &&
3465                     '\0' == n->key.p[(int)len])
3466                         return n->val.p;
3467
3468         return NULL;
3469 }
3470
3471 static void
3472 roff_freestr(struct roffkv *r)
3473 {
3474         struct roffkv    *n, *nn;
3475
3476         for (n = r; n; n = nn) {
3477                 free(n->key.p);
3478                 free(n->val.p);
3479                 nn = n->next;
3480                 free(n);
3481         }
3482 }
3483
3484 /* --- accessors and utility functions ------------------------------------ */
3485
3486 const struct tbl_span *
3487 roff_span(const struct roff *r)
3488 {
3489
3490         return r->tbl ? tbl_span(r->tbl) : NULL;
3491 }
3492
3493 const struct eqn *
3494 roff_eqn(const struct roff *r)
3495 {
3496
3497         return r->last_eqn ? &r->last_eqn->eqn : NULL;
3498 }
3499
3500 /*
3501  * Duplicate an input string, making the appropriate character
3502  * conversations (as stipulated by `tr') along the way.
3503  * Returns a heap-allocated string with all the replacements made.
3504  */
3505 char *
3506 roff_strdup(const struct roff *r, const char *p)
3507 {
3508         const struct roffkv *cp;
3509         char            *res;
3510         const char      *pp;
3511         size_t           ssz, sz;
3512         enum mandoc_esc  esc;
3513
3514         if (NULL == r->xmbtab && NULL == r->xtab)
3515                 return mandoc_strdup(p);
3516         else if ('\0' == *p)
3517                 return mandoc_strdup("");
3518
3519         /*
3520          * Step through each character looking for term matches
3521          * (remember that a `tr' can be invoked with an escape, which is
3522          * a glyph but the escape is multi-character).
3523          * We only do this if the character hash has been initialised
3524          * and the string is >0 length.
3525          */
3526
3527         res = NULL;
3528         ssz = 0;
3529
3530         while ('\0' != *p) {
3531                 assert((unsigned int)*p < 128);
3532                 if ('\\' != *p && r->xtab && r->xtab[(unsigned int)*p].p) {
3533                         sz = r->xtab[(int)*p].sz;
3534                         res = mandoc_realloc(res, ssz + sz + 1);
3535                         memcpy(res + ssz, r->xtab[(int)*p].p, sz);
3536                         ssz += sz;
3537                         p++;
3538                         continue;
3539                 } else if ('\\' != *p) {
3540                         res = mandoc_realloc(res, ssz + 2);
3541                         res[ssz++] = *p++;
3542                         continue;
3543                 }
3544
3545                 /* Search for term matches. */
3546                 for (cp = r->xmbtab; cp; cp = cp->next)
3547                         if (0 == strncmp(p, cp->key.p, cp->key.sz))
3548                                 break;
3549
3550                 if (NULL != cp) {
3551                         /*
3552                          * A match has been found.
3553                          * Append the match to the array and move
3554                          * forward by its keysize.
3555                          */
3556                         res = mandoc_realloc(res,
3557                             ssz + cp->val.sz + 1);
3558                         memcpy(res + ssz, cp->val.p, cp->val.sz);
3559                         ssz += cp->val.sz;
3560                         p += (int)cp->key.sz;
3561                         continue;
3562                 }
3563
3564                 /*
3565                  * Handle escapes carefully: we need to copy
3566                  * over just the escape itself, or else we might
3567                  * do replacements within the escape itself.
3568                  * Make sure to pass along the bogus string.
3569                  */
3570                 pp = p++;
3571                 esc = mandoc_escape(&p, NULL, NULL);
3572                 if (ESCAPE_ERROR == esc) {
3573                         sz = strlen(pp);
3574                         res = mandoc_realloc(res, ssz + sz + 1);
3575                         memcpy(res + ssz, pp, sz);
3576                         break;
3577                 }
3578                 /*
3579                  * We bail out on bad escapes.
3580                  * No need to warn: we already did so when
3581                  * roff_res() was called.
3582                  */
3583                 sz = (int)(p - pp);
3584                 res = mandoc_realloc(res, ssz + sz + 1);
3585                 memcpy(res + ssz, pp, sz);
3586                 ssz += sz;
3587         }
3588
3589         res[(int)ssz] = '\0';
3590         return res;
3591 }
3592
3593 int
3594 roff_getformat(const struct roff *r)
3595 {
3596
3597         return r->format;
3598 }
3599
3600 /*
3601  * Find out whether a line is a macro line or not.
3602  * If it is, adjust the current position and return one; if it isn't,
3603  * return zero and don't change the current position.
3604  * If the control character has been set with `.cc', then let that grain
3605  * precedence.
3606  * This is slighly contrary to groff, where using the non-breaking
3607  * control character when `cc' has been invoked will cause the
3608  * non-breaking macro contents to be printed verbatim.
3609  */
3610 int
3611 roff_getcontrol(const struct roff *r, const char *cp, int *ppos)
3612 {
3613         int             pos;
3614
3615         pos = *ppos;
3616
3617         if (r->control != '\0' && cp[pos] == r->control)
3618                 pos++;
3619         else if (r->control != '\0')
3620                 return 0;
3621         else if ('\\' == cp[pos] && '.' == cp[pos + 1])
3622                 pos += 2;
3623         else if ('.' == cp[pos] || '\'' == cp[pos])
3624                 pos++;
3625         else
3626                 return 0;
3627
3628         while (' ' == cp[pos] || '\t' == cp[pos])
3629                 pos++;
3630
3631         *ppos = pos;
3632         return 1;
3633 }