contrib/mandoc/roff.c

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