contrib/mandoc/roff.c

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