contrib/mdocml/roff.c

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