contrib/mdocml/roff.c

   1 /*      $Id: roff.c,v 1.224 2014/08/01 17:27:44 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2010, 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010-2014 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 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include <assert.h>
  23 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "mandoc.h"
  29 #include "mandoc_aux.h"
  30 #include "libroff.h"
  31 #include "libmandoc.h"
  32
  33 /* Maximum number of nested if-else conditionals. */
  34 #define RSTACK_MAX      128
  35
  36 /* Maximum number of string expansions per line, to break infinite loops. */
  37 #define EXPAND_LIMIT    1000
  38
  39 enum    rofft {
  40         ROFF_ad,
  41         ROFF_am,
  42         ROFF_ami,
  43         ROFF_am1,
  44         ROFF_as,
  45         ROFF_cc,
  46         ROFF_ce,
  47         ROFF_de,
  48         ROFF_dei,
  49         ROFF_de1,
  50         ROFF_ds,
  51         ROFF_el,
  52         ROFF_fam,
  53         ROFF_hw,
  54         ROFF_hy,
  55         ROFF_ie,
  56         ROFF_if,
  57         ROFF_ig,
  58         ROFF_it,
  59         ROFF_ne,
  60         ROFF_nh,
  61         ROFF_nr,
  62         ROFF_ns,
  63         ROFF_ps,
  64         ROFF_rm,
  65         ROFF_rr,
  66         ROFF_so,
  67         ROFF_ta,
  68         ROFF_tr,
  69         ROFF_Dd,
  70         ROFF_TH,
  71         ROFF_TS,
  72         ROFF_TE,
  73         ROFF_T_,
  74         ROFF_EQ,
  75         ROFF_EN,
  76         ROFF_cblock,
  77         ROFF_USERDEF,
  78         ROFF_MAX
  79 };
  80
  81 /*
  82  * An incredibly-simple string buffer.
  83  */
  84 struct  roffstr {
  85         char            *p; /* nil-terminated buffer */
  86         size_t           sz; /* saved strlen(p) */
  87 };
  88
  89 /*
  90  * A key-value roffstr pair as part of a singly-linked list.
  91  */
  92 struct  roffkv {
  93         struct roffstr   key;
  94         struct roffstr   val;
  95         struct roffkv   *next; /* next in list */
  96 };
  97
  98 /*
  99  * A single number register as part of a singly-linked list.
 100  */
 101 struct  roffreg {
 102         struct roffstr   key;
 103         int              val;
 104         struct roffreg  *next;
 105 };
 106
 107 struct  roff {
 108         struct mparse   *parse; /* parse point */
 109         struct roffnode *last; /* leaf of stack */
 110         int             *rstack; /* stack of inverted `ie' values */
 111         struct roffreg  *regtab; /* number registers */
 112         struct roffkv   *strtab; /* user-defined strings & macros */
 113         struct roffkv   *xmbtab; /* multi-byte trans table (`tr') */
 114         struct roffstr  *xtab; /* single-byte trans table (`tr') */
 115         const char      *current_string; /* value of last called user macro */
 116         struct tbl_node *first_tbl; /* first table parsed */
 117         struct tbl_node *last_tbl; /* last table parsed */
 118         struct tbl_node *tbl; /* current table being parsed */
 119         struct eqn_node *last_eqn; /* last equation parsed */
 120         struct eqn_node *first_eqn; /* first equation parsed */
 121         struct eqn_node *eqn; /* current equation being parsed */
 122         int              options; /* parse options */
 123         int              rstacksz; /* current size limit of rstack */
 124         int              rstackpos; /* position in rstack */
 125         char             control; /* control character */
 126 };
 127
 128 struct  roffnode {
 129         enum rofft       tok; /* type of node */
 130         struct roffnode *parent; /* up one in stack */
 131         int              line; /* parse line */
 132         int              col; /* parse col */
 133         char            *name; /* node name, e.g. macro name */
 134         char            *end; /* end-rules: custom token */
 135         int              endspan; /* end-rules: next-line or infty */
 136         int              rule; /* current evaluation rule */
 137 };
 138
 139 #define ROFF_ARGS        struct roff *r, /* parse ctx */ \
 140                          enum rofft tok, /* tok of macro */ \
 141                          char **bufp, /* input buffer */ \
 142                          size_t *szp, /* size of input buffer */ \
 143                          int ln, /* parse line */ \
 144                          int ppos, /* original pos in buffer */ \
 145                          int pos, /* current pos in buffer */ \
 146                          int *offs /* reset offset of buffer data */
 147
 148 typedef enum rofferr (*roffproc)(ROFF_ARGS);
 149
 150 struct  roffmac {
 151         const char      *name; /* macro name */
 152         roffproc         proc; /* process new macro */
 153         roffproc         text; /* process as child text of macro */
 154         roffproc         sub; /* process as child of macro */
 155         int              flags;
 156 #define ROFFMAC_STRUCT  (1 << 0) /* always interpret */
 157         struct roffmac  *next;
 158 };
 159
 160 struct  predef {
 161         const char      *name; /* predefined input name */
 162         const char      *str; /* replacement symbol */
 163 };
 164
 165 #define PREDEF(__name, __str) \
 166         { (__name), (__str) },
 167
 168 static  enum rofft       roffhash_find(const char *, size_t);
 169 static  void             roffhash_init(void);
 170 static  void             roffnode_cleanscope(struct roff *);
 171 static  void             roffnode_pop(struct roff *);
 172 static  void             roffnode_push(struct roff *, enum rofft,
 173                                 const char *, int, int);
 174 static  enum rofferr     roff_block(ROFF_ARGS);
 175 static  enum rofferr     roff_block_text(ROFF_ARGS);
 176 static  enum rofferr     roff_block_sub(ROFF_ARGS);
 177 static  enum rofferr     roff_cblock(ROFF_ARGS);
 178 static  enum rofferr     roff_cc(ROFF_ARGS);
 179 static  void             roff_ccond(struct roff *, int, int);
 180 static  enum rofferr     roff_cond(ROFF_ARGS);
 181 static  enum rofferr     roff_cond_text(ROFF_ARGS);
 182 static  enum rofferr     roff_cond_sub(ROFF_ARGS);
 183 static  enum rofferr     roff_ds(ROFF_ARGS);
 184 static  int              roff_evalcond(const char *, int *);
 185 static  int              roff_evalnum(const char *, int *, int *, int);
 186 static  int              roff_evalpar(const char *, int *, int *);
 187 static  int              roff_evalstrcond(const char *, int *);
 188 static  void             roff_free1(struct roff *);
 189 static  void             roff_freereg(struct roffreg *);
 190 static  void             roff_freestr(struct roffkv *);
 191 static  size_t           roff_getname(struct roff *, char **, int, int);
 192 static  int              roff_getnum(const char *, int *, int *);
 193 static  int              roff_getop(const char *, int *, char *);
 194 static  int              roff_getregn(const struct roff *,
 195                                 const char *, size_t);
 196 static  int              roff_getregro(const char *name);
 197 static  const char      *roff_getstrn(const struct roff *,
 198                                 const char *, size_t);
 199 static  enum rofferr     roff_it(ROFF_ARGS);
 200 static  enum rofferr     roff_line_ignore(ROFF_ARGS);
 201 static  enum rofferr     roff_nr(ROFF_ARGS);
 202 static  void             roff_openeqn(struct roff *, const char *,
 203                                 int, int, const char *);
 204 static  enum rofft       roff_parse(struct roff *, char *, int *,
 205                                 int, int);
 206 static  enum rofferr     roff_parsetext(char **, size_t *, int, int *);
 207 static  enum rofferr     roff_res(struct roff *,
 208                                 char **, size_t *, int, int);
 209 static  enum rofferr     roff_rm(ROFF_ARGS);
 210 static  enum rofferr     roff_rr(ROFF_ARGS);
 211 static  void             roff_setstr(struct roff *,
 212                                 const char *, const char *, int);
 213 static  void             roff_setstrn(struct roffkv **, const char *,
 214                                 size_t, const char *, size_t, int);
 215 static  enum rofferr     roff_so(ROFF_ARGS);
 216 static  enum rofferr     roff_tr(ROFF_ARGS);
 217 static  enum rofferr     roff_Dd(ROFF_ARGS);
 218 static  enum rofferr     roff_TH(ROFF_ARGS);
 219 static  enum rofferr     roff_TE(ROFF_ARGS);
 220 static  enum rofferr     roff_TS(ROFF_ARGS);
 221 static  enum rofferr     roff_EQ(ROFF_ARGS);
 222 static  enum rofferr     roff_EN(ROFF_ARGS);
 223 static  enum rofferr     roff_T_(ROFF_ARGS);
 224 static  enum rofferr     roff_userdef(ROFF_ARGS);
 225
 226 /* See roffhash_find() */
 227
 228 #define ASCII_HI         126
 229 #define ASCII_LO         33
 230 #define HASHWIDTH       (ASCII_HI - ASCII_LO + 1)
 231
 232 static  struct roffmac  *hash[HASHWIDTH];
 233
 234 static  struct roffmac   roffs[ROFF_MAX] = {
 235         { "ad", roff_line_ignore, NULL, NULL, 0, NULL },
 236         { "am", roff_block, roff_block_text, roff_block_sub, 0, NULL },
 237         { "ami", roff_block, roff_block_text, roff_block_sub, 0, NULL },
 238         { "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
 239         { "as", roff_ds, NULL, NULL, 0, NULL },
 240         { "cc", roff_cc, NULL, NULL, 0, NULL },
 241         { "ce", roff_line_ignore, NULL, NULL, 0, NULL },
 242         { "de", roff_block, roff_block_text, roff_block_sub, 0, NULL },
 243         { "dei", roff_block, roff_block_text, roff_block_sub, 0, NULL },
 244         { "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
 245         { "ds", roff_ds, NULL, NULL, 0, NULL },
 246         { "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
 247         { "fam", roff_line_ignore, NULL, NULL, 0, NULL },
 248         { "hw", roff_line_ignore, NULL, NULL, 0, NULL },
 249         { "hy", roff_line_ignore, NULL, NULL, 0, NULL },
 250         { "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
 251         { "if", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
 252         { "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL },
 253         { "it", roff_it, NULL, NULL, 0, NULL },
 254         { "ne", roff_line_ignore, NULL, NULL, 0, NULL },
 255         { "nh", roff_line_ignore, NULL, NULL, 0, NULL },
 256         { "nr", roff_nr, NULL, NULL, 0, NULL },
 257         { "ns", roff_line_ignore, NULL, NULL, 0, NULL },
 258         { "ps", roff_line_ignore, NULL, NULL, 0, NULL },
 259         { "rm", roff_rm, NULL, NULL, 0, NULL },
 260         { "rr", roff_rr, NULL, NULL, 0, NULL },
 261         { "so", roff_so, NULL, NULL, 0, NULL },
 262         { "ta", roff_line_ignore, NULL, NULL, 0, NULL },
 263         { "tr", roff_tr, NULL, NULL, 0, NULL },
 264         { "Dd", roff_Dd, NULL, NULL, 0, NULL },
 265         { "TH", roff_TH, NULL, NULL, 0, NULL },
 266         { "TS", roff_TS, NULL, NULL, 0, NULL },
 267         { "TE", roff_TE, NULL, NULL, 0, NULL },
 268         { "T&", roff_T_, NULL, NULL, 0, NULL },
 269         { "EQ", roff_EQ, NULL, NULL, 0, NULL },
 270         { "EN", roff_EN, NULL, NULL, 0, NULL },
 271         { ".", roff_cblock, NULL, NULL, 0, NULL },
 272         { NULL, roff_userdef, NULL, NULL, 0, NULL },
 273 };
 274
 275 /* not currently implemented: Ds em Eq LP Me PP pp Or Rd Sf SH */
 276 const   char *const __mdoc_reserved[] = {
 277         "Ac", "Ad", "An", "Ao", "Ap", "Aq", "Ar", "At",
 278         "Bc", "Bd", "Bf", "Bk", "Bl", "Bo", "Bq",
 279         "Brc", "Bro", "Brq", "Bsx", "Bt", "Bx",
 280         "Cd", "Cm", "Db", "Dc", "Dd", "Dl", "Do", "Dq",
 281         "Dt", "Dv", "Dx", "D1",
 282         "Ec", "Ed", "Ef", "Ek", "El", "Em",
 283         "En", "Eo", "Er", "Es", "Ev", "Ex",
 284         "Fa", "Fc", "Fd", "Fl", "Fn", "Fo", "Fr", "Ft", "Fx",
 285         "Hf", "Ic", "In", "It", "Lb", "Li", "Lk", "Lp",
 286         "Ms", "Mt", "Nd", "Nm", "No", "Ns", "Nx",
 287         "Oc", "Oo", "Op", "Os", "Ot", "Ox",
 288         "Pa", "Pc", "Pf", "Po", "Pp", "Pq",
 289         "Qc", "Ql", "Qo", "Qq", "Re", "Rs", "Rv",
 290         "Sc", "Sh", "Sm", "So", "Sq",
 291         "Ss", "St", "Sx", "Sy",
 292         "Ta", "Tn", "Ud", "Ux", "Va", "Vt", "Xc", "Xo", "Xr",
 293         "%A", "%B", "%C", "%D", "%I", "%J", "%N", "%O",
 294         "%P", "%Q", "%R", "%T", "%U", "%V",
 295         NULL
 296 };
 297
 298 /* not currently implemented: BT DE DS ME MT PT SY TQ YS */
 299 const   char *const __man_reserved[] = {
 300         "AT", "B", "BI", "BR", "DT",
 301         "EE", "EN", "EQ", "EX", "HP", "I", "IB", "IP", "IR",
 302         "LP", "OP", "P", "PD", "PP",
 303         "R", "RB", "RE", "RI", "RS", "SB", "SH", "SM", "SS",
 304         "TE", "TH", "TP", "TS", "T&", "UC", "UE", "UR",
 305         NULL
 306 };
 307
 308 /* Array of injected predefined strings. */
 309 #define PREDEFS_MAX      38
 310 static  const struct predef predefs[PREDEFS_MAX] = {
 311 #include "predefs.in"
 312 };
 313
 314 /* See roffhash_find() */
 315 #define ROFF_HASH(p)    (p[0] - ASCII_LO)
 316
 317 static  int      roffit_lines;  /* number of lines to delay */
 318 static  char    *roffit_macro;  /* nil-terminated macro line */
 319
 320
 321 static void
 322 roffhash_init(void)
 323 {
 324         struct roffmac   *n;
 325         int               buc, i;
 326
 327         for (i = 0; i < (int)ROFF_USERDEF; i++) {
 328                 assert(roffs[i].name[0] >= ASCII_LO);
 329                 assert(roffs[i].name[0] <= ASCII_HI);
 330
 331                 buc = ROFF_HASH(roffs[i].name);
 332
 333                 if (NULL != (n = hash[buc])) {
 334                         for ( ; n->next; n = n->next)
 335                                 /* Do nothing. */ ;
 336                         n->next = &roffs[i];
 337                 } else
 338                         hash[buc] = &roffs[i];
 339         }
 340 }
 341
 342 /*
 343  * Look up a roff token by its name.  Returns ROFF_MAX if no macro by
 344  * the nil-terminated string name could be found.
 345  */
 346 static enum rofft
 347 roffhash_find(const char *p, size_t s)
 348 {
 349         int              buc;
 350         struct roffmac  *n;
 351
 352         /*
 353          * libroff has an extremely simple hashtable, for the time
 354          * being, which simply keys on the first character, which must
 355          * be printable, then walks a chain.  It works well enough until
 356          * optimised.
 357          */
 358
 359         if (p[0] < ASCII_LO || p[0] > ASCII_HI)
 360                 return(ROFF_MAX);
 361
 362         buc = ROFF_HASH(p);
 363
 364         if (NULL == (n = hash[buc]))
 365                 return(ROFF_MAX);
 366         for ( ; n; n = n->next)
 367                 if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s])
 368                         return((enum rofft)(n - roffs));
 369
 370         return(ROFF_MAX);
 371 }
 372
 373 /*
 374  * Pop the current node off of the stack of roff instructions currently
 375  * pending.
 376  */
 377 static void
 378 roffnode_pop(struct roff *r)
 379 {
 380         struct roffnode *p;
 381
 382         assert(r->last);
 383         p = r->last;
 384
 385         r->last = r->last->parent;
 386         free(p->name);
 387         free(p->end);
 388         free(p);
 389 }
 390
 391 /*
 392  * Push a roff node onto the instruction stack.  This must later be
 393  * removed with roffnode_pop().
 394  */
 395 static void
 396 roffnode_push(struct roff *r, enum rofft tok, const char *name,
 397                 int line, int col)
 398 {
 399         struct roffnode *p;
 400
 401         p = mandoc_calloc(1, sizeof(struct roffnode));
 402         p->tok = tok;
 403         if (name)
 404                 p->name = mandoc_strdup(name);
 405         p->parent = r->last;
 406         p->line = line;
 407         p->col = col;
 408         p->rule = p->parent ? p->parent->rule : 0;
 409
 410         r->last = p;
 411 }
 412
 413 static void
 414 roff_free1(struct roff *r)
 415 {
 416         struct tbl_node *tbl;
 417         struct eqn_node *e;
 418         int              i;
 419
 420         while (NULL != (tbl = r->first_tbl)) {
 421                 r->first_tbl = tbl->next;
 422                 tbl_free(tbl);
 423         }
 424         r->first_tbl = r->last_tbl = r->tbl = NULL;
 425
 426         while (NULL != (e = r->first_eqn)) {
 427                 r->first_eqn = e->next;
 428                 eqn_free(e);
 429         }
 430         r->first_eqn = r->last_eqn = r->eqn = NULL;
 431
 432         while (r->last)
 433                 roffnode_pop(r);
 434
 435         free (r->rstack);
 436         r->rstack = NULL;
 437         r->rstacksz = 0;
 438         r->rstackpos = -1;
 439
 440         roff_freereg(r->regtab);
 441         r->regtab = NULL;
 442
 443         roff_freestr(r->strtab);
 444         roff_freestr(r->xmbtab);
 445         r->strtab = r->xmbtab = NULL;
 446
 447         if (r->xtab)
 448                 for (i = 0; i < 128; i++)
 449                         free(r->xtab[i].p);
 450         free(r->xtab);
 451         r->xtab = NULL;
 452 }
 453
 454 void
 455 roff_reset(struct roff *r)
 456 {
 457
 458         roff_free1(r);
 459         r->control = 0;
 460 }
 461
 462 void
 463 roff_free(struct roff *r)
 464 {
 465
 466         roff_free1(r);
 467         free(r);
 468 }
 469
 470 struct roff *
 471 roff_alloc(struct mparse *parse, int options)
 472 {
 473         struct roff     *r;
 474
 475         r = mandoc_calloc(1, sizeof(struct roff));
 476         r->parse = parse;
 477         r->options = options;
 478         r->rstackpos = -1;
 479
 480         roffhash_init();
 481
 482         return(r);
 483 }
 484
 485 /*
 486  * In the current line, expand escape sequences that tend to get
 487  * used in numerical expressions and conditional requests.
 488  * Also check the syntax of the remaining escape sequences.
 489  */
 490 static enum rofferr
 491 roff_res(struct roff *r, char **bufp, size_t *szp, int ln, int pos)
 492 {
 493         char             ubuf[24]; /* buffer to print the number */
 494         const char      *start; /* start of the string to process */
 495         char            *stesc; /* start of an escape sequence ('\\') */
 496         const char      *stnam; /* start of the name, after "[(*" */
 497         const char      *cp;    /* end of the name, e.g. before ']' */
 498         const char      *res;   /* the string to be substituted */
 499         char            *nbuf;  /* new buffer to copy bufp to */
 500         size_t           maxl;  /* expected length of the escape name */
 501         size_t           naml;  /* actual length of the escape name */
 502         int              expand_count;  /* to avoid infinite loops */
 503         int              npos;  /* position in numeric expression */
 504         int              arg_complete; /* argument not interrupted by eol */
 505         char             term;  /* character terminating the escape */
 506
 507         expand_count = 0;
 508         start = *bufp + pos;
 509         stesc = strchr(start, '\0') - 1;
 510         while (stesc-- > start) {
 511
 512                 /* Search backwards for the next backslash. */
 513
 514                 if ('\\' != *stesc)
 515                         continue;
 516
 517                 /* If it is escaped, skip it. */
 518
 519                 for (cp = stesc - 1; cp >= start; cp--)
 520                         if ('\\' != *cp)
 521                                 break;
 522
 523                 if (0 == (stesc - cp) % 2) {
 524                         stesc = (char *)cp;
 525                         continue;
 526                 }
 527
 528                 /* Decide whether to expand or to check only. */
 529
 530                 term = '\0';
 531                 cp = stesc + 1;
 532                 switch (*cp) {
 533                 case '*':
 534                         res = NULL;
 535                         break;
 536                 case 'B':
 537                         /* FALLTHROUGH */
 538                 case 'w':
 539                         term = cp[1];
 540                         /* FALLTHROUGH */
 541                 case 'n':
 542                         res = ubuf;
 543                         break;
 544                 default:
 545                         if (ESCAPE_ERROR == mandoc_escape(&cp, NULL, NULL))
 546                                 mandoc_vmsg(MANDOCERR_ESC_BAD,
 547                                     r->parse, ln, (int)(stesc - *bufp),
 548                                     "%.*s", (int)(cp - stesc), stesc);
 549                         continue;
 550                 }
 551
 552                 if (EXPAND_LIMIT < ++expand_count) {
 553                         mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
 554                             ln, (int)(stesc - *bufp), NULL);
 555                         return(ROFF_IGN);
 556                 }
 557
 558                 /*
 559                  * The third character decides the length
 560                  * of the name of the string or register.
 561                  * Save a pointer to the name.
 562                  */
 563
 564                 if ('\0' == term) {
 565                         switch (*++cp) {
 566                         case '\0':
 567                                 maxl = 0;
 568                                 break;
 569                         case '(':
 570                                 cp++;
 571                                 maxl = 2;
 572                                 break;
 573                         case '[':
 574                                 cp++;
 575                                 term = ']';
 576                                 maxl = 0;
 577                                 break;
 578                         default:
 579                                 maxl = 1;
 580                                 break;
 581                         }
 582                 } else {
 583                         cp += 2;
 584                         maxl = 0;
 585                 }
 586                 stnam = cp;
 587
 588                 /* Advance to the end of the name. */
 589
 590                 arg_complete = 1;
 591                 for (naml = 0; 0 == maxl || naml < maxl; naml++, cp++) {
 592                         if ('\0' == *cp) {
 593                                 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
 594                                     ln, (int)(stesc - *bufp), stesc);
 595                                 arg_complete = 0;
 596                                 break;
 597                         }
 598                         if (0 == maxl && *cp == term) {
 599                                 cp++;
 600                                 break;
 601                         }
 602                 }
 603
 604                 /*
 605                  * Retrieve the replacement string; if it is
 606                  * undefined, resume searching for escapes.
 607                  */
 608
 609                 switch (stesc[1]) {
 610                 case '*':
 611                         if (arg_complete)
 612                                 res = roff_getstrn(r, stnam, naml);
 613                         break;
 614                 case 'B':
 615                         npos = 0;
 616                         ubuf[0] = arg_complete &&
 617                             roff_evalnum(stnam, &npos, NULL, 0) &&
 618                             stnam + npos + 1 == cp ? '1' : '0';
 619                         ubuf[1] = '\0';
 620                         break;
 621                 case 'n':
 622                         if (arg_complete)
 623                                 (void)snprintf(ubuf, sizeof(ubuf), "%d",
 624                                     roff_getregn(r, stnam, naml));
 625                         else
 626                                 ubuf[0] = '\0';
 627                         break;
 628                 case 'w':
 629                         /* use even incomplete args */
 630                         (void)snprintf(ubuf, sizeof(ubuf), "%d",
 631                             24 * (int)naml);
 632                         break;
 633                 }
 634
 635                 if (NULL == res) {
 636                         mandoc_vmsg(MANDOCERR_STR_UNDEF,
 637                             r->parse, ln, (int)(stesc - *bufp),
 638                             "%.*s", (int)naml, stnam);
 639                         res = "";
 640                 }
 641
 642                 /* Replace the escape sequence by the string. */
 643
 644                 *stesc = '\0';
 645                 *szp = mandoc_asprintf(&nbuf, "%s%s%s",
 646                     *bufp, res, cp) + 1;
 647
 648                 /* Prepare for the next replacement. */
 649
 650                 start = nbuf + pos;
 651                 stesc = nbuf + (stesc - *bufp) + strlen(res);
 652                 free(*bufp);
 653                 *bufp = nbuf;
 654         }
 655         return(ROFF_CONT);
 656 }
 657
 658 /*
 659  * Process text streams:
 660  * Convert all breakable hyphens into ASCII_HYPH.
 661  * Decrement and spring input line trap.
 662  */
 663 static enum rofferr
 664 roff_parsetext(char **bufp, size_t *szp, int pos, int *offs)
 665 {
 666         size_t           sz;
 667         const char      *start;
 668         char            *p;
 669         int              isz;
 670         enum mandoc_esc  esc;
 671
 672         start = p = *bufp + pos;
 673
 674         while ('\0' != *p) {
 675                 sz = strcspn(p, "-\\");
 676                 p += sz;
 677
 678                 if ('\0' == *p)
 679                         break;
 680
 681                 if ('\\' == *p) {
 682                         /* Skip over escapes. */
 683                         p++;
 684                         esc = mandoc_escape((const char **)&p, NULL, NULL);
 685                         if (ESCAPE_ERROR == esc)
 686                                 break;
 687                         continue;
 688                 } else if (p == start) {
 689                         p++;
 690                         continue;
 691                 }
 692
 693                 if (isalpha((unsigned char)p[-1]) &&
 694                     isalpha((unsigned char)p[1]))
 695                         *p = ASCII_HYPH;
 696                 p++;
 697         }
 698
 699         /* Spring the input line trap. */
 700         if (1 == roffit_lines) {
 701                 isz = mandoc_asprintf(&p, "%s\n.%s", *bufp, roffit_macro);
 702                 free(*bufp);
 703                 *bufp = p;
 704                 *szp = isz + 1;
 705                 *offs = 0;
 706                 free(roffit_macro);
 707                 roffit_lines = 0;
 708                 return(ROFF_REPARSE);
 709         } else if (1 < roffit_lines)
 710                 --roffit_lines;
 711         return(ROFF_CONT);
 712 }
 713
 714 enum rofferr
 715 roff_parseln(struct roff *r, int ln, char **bufp,
 716                 size_t *szp, int pos, int *offs)
 717 {
 718         enum rofft       t;
 719         enum rofferr     e;
 720         int              ppos, ctl;
 721
 722         /*
 723          * Run the reserved-word filter only if we have some reserved
 724          * words to fill in.
 725          */
 726
 727         e = roff_res(r, bufp, szp, ln, pos);
 728         if (ROFF_IGN == e)
 729                 return(e);
 730         assert(ROFF_CONT == e);
 731
 732         ppos = pos;
 733         ctl = roff_getcontrol(r, *bufp, &pos);
 734
 735         /*
 736          * First, if a scope is open and we're not a macro, pass the
 737          * text through the macro's filter.  If a scope isn't open and
 738          * we're not a macro, just let it through.
 739          * Finally, if there's an equation scope open, divert it into it
 740          * no matter our state.
 741          */
 742
 743         if (r->last && ! ctl) {
 744                 t = r->last->tok;
 745                 assert(roffs[t].text);
 746                 e = (*roffs[t].text)(r, t, bufp, szp, ln, pos, pos, offs);
 747                 assert(ROFF_IGN == e || ROFF_CONT == e);
 748                 if (ROFF_CONT != e)
 749                         return(e);
 750         }
 751         if (r->eqn)
 752                 return(eqn_read(&r->eqn, ln, *bufp, ppos, offs));
 753         if ( ! ctl) {
 754                 if (r->tbl)
 755                         return(tbl_read(r->tbl, ln, *bufp, pos));
 756                 return(roff_parsetext(bufp, szp, pos, offs));
 757         }
 758
 759         /*
 760          * If a scope is open, go to the child handler for that macro,
 761          * as it may want to preprocess before doing anything with it.
 762          * Don't do so if an equation is open.
 763          */
 764
 765         if (r->last) {
 766                 t = r->last->tok;
 767                 assert(roffs[t].sub);
 768                 return((*roffs[t].sub)(r, t, bufp, szp,
 769                     ln, ppos, pos, offs));
 770         }
 771
 772         /*
 773          * Lastly, as we've no scope open, try to look up and execute
 774          * the new macro.  If no macro is found, simply return and let
 775          * the compilers handle it.
 776          */
 777
 778         if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos, ln, ppos)))
 779                 return(ROFF_CONT);
 780
 781         assert(roffs[t].proc);
 782         return((*roffs[t].proc)(r, t, bufp, szp, ln, ppos, pos, offs));
 783 }
 784
 785 void
 786 roff_endparse(struct roff *r)
 787 {
 788
 789         if (r->last)
 790                 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
 791                     r->last->line, r->last->col,
 792                     roffs[r->last->tok].name);
 793
 794         if (r->eqn) {
 795                 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
 796                     r->eqn->eqn.ln, r->eqn->eqn.pos, "EQ");
 797                 eqn_end(&r->eqn);
 798         }
 799
 800         if (r->tbl) {
 801                 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
 802                     r->tbl->line, r->tbl->pos, "TS");
 803                 tbl_end(&r->tbl);
 804         }
 805 }
 806
 807 /*
 808  * Parse a roff node's type from the input buffer.  This must be in the
 809  * form of ".foo xxx" in the usual way.
 810  */
 811 static enum rofft
 812 roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos)
 813 {
 814         char            *cp;
 815         const char      *mac;
 816         size_t           maclen;
 817         enum rofft       t;
 818
 819         cp = buf + *pos;
 820
 821         if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp)
 822                 return(ROFF_MAX);
 823
 824         mac = cp;
 825         maclen = roff_getname(r, &cp, ln, ppos);
 826
 827         t = (r->current_string = roff_getstrn(r, mac, maclen))
 828             ? ROFF_USERDEF : roffhash_find(mac, maclen);
 829
 830         if (ROFF_MAX != t)
 831                 *pos = cp - buf;
 832
 833         return(t);
 834 }
 835
 836 static enum rofferr
 837 roff_cblock(ROFF_ARGS)
 838 {
 839
 840         /*
 841          * A block-close `..' should only be invoked as a child of an
 842          * ignore macro, otherwise raise a warning and just ignore it.
 843          */
 844
 845         if (NULL == r->last) {
 846                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
 847                     ln, ppos, "..");
 848                 return(ROFF_IGN);
 849         }
 850
 851         switch (r->last->tok) {
 852         case ROFF_am:
 853                 /* ROFF_am1 is remapped to ROFF_am in roff_block(). */
 854                 /* FALLTHROUGH */
 855         case ROFF_ami:
 856                 /* FALLTHROUGH */
 857         case ROFF_de:
 858                 /* ROFF_de1 is remapped to ROFF_de in roff_block(). */
 859                 /* FALLTHROUGH */
 860         case ROFF_dei:
 861                 /* FALLTHROUGH */
 862         case ROFF_ig:
 863                 break;
 864         default:
 865                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
 866                     ln, ppos, "..");
 867                 return(ROFF_IGN);
 868         }
 869
 870         if ((*bufp)[pos])
 871                 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
 872                     ".. %s", *bufp + pos);
 873
 874         roffnode_pop(r);
 875         roffnode_cleanscope(r);
 876         return(ROFF_IGN);
 877
 878 }
 879
 880 static void
 881 roffnode_cleanscope(struct roff *r)
 882 {
 883
 884         while (r->last) {
 885                 if (--r->last->endspan != 0)
 886                         break;
 887                 roffnode_pop(r);
 888         }
 889 }
 890
 891 static void
 892 roff_ccond(struct roff *r, int ln, int ppos)
 893 {
 894
 895         if (NULL == r->last) {
 896                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
 897                     ln, ppos, "\\}");
 898                 return;
 899         }
 900
 901         switch (r->last->tok) {
 902         case ROFF_el:
 903                 /* FALLTHROUGH */
 904         case ROFF_ie:
 905                 /* FALLTHROUGH */
 906         case ROFF_if:
 907                 break;
 908         default:
 909                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
 910                     ln, ppos, "\\}");
 911                 return;
 912         }
 913
 914         if (r->last->endspan > -1) {
 915                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
 916                     ln, ppos, "\\}");
 917                 return;
 918         }
 919
 920         roffnode_pop(r);
 921         roffnode_cleanscope(r);
 922         return;
 923 }
 924
 925 static enum rofferr
 926 roff_block(ROFF_ARGS)
 927 {
 928         const char      *name;
 929         char            *iname, *cp;
 930         size_t           namesz;
 931
 932         /* Ignore groff compatibility mode for now. */
 933
 934         if (ROFF_de1 == tok)
 935                 tok = ROFF_de;
 936         else if (ROFF_am1 == tok)
 937                 tok = ROFF_am;
 938
 939         /* Parse the macro name argument. */
 940
 941         cp = *bufp + pos;
 942         if (ROFF_ig == tok) {
 943                 iname = NULL;
 944                 namesz = 0;
 945         } else {
 946                 iname = cp;
 947                 namesz = roff_getname(r, &cp, ln, ppos);
 948                 iname[namesz] = '\0';
 949         }
 950
 951         /* Resolve the macro name argument if it is indirect. */
 952
 953         if (namesz && (ROFF_dei == tok || ROFF_ami == tok)) {
 954                 if (NULL == (name = roff_getstrn(r, iname, namesz))) {
 955                         mandoc_vmsg(MANDOCERR_STR_UNDEF,
 956                             r->parse, ln, (int)(iname - *bufp),
 957                             "%.*s", (int)namesz, iname);
 958                         namesz = 0;
 959                 } else
 960                         namesz = strlen(name);
 961         } else
 962                 name = iname;
 963
 964         if (0 == namesz && ROFF_ig != tok) {
 965                 mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse,
 966                     ln, ppos, roffs[tok].name);
 967                 return(ROFF_IGN);
 968         }
 969
 970         roffnode_push(r, tok, name, ln, ppos);
 971
 972         /*
 973          * At the beginning of a `de' macro, clear the existing string
 974          * with the same name, if there is one.  New content will be
 975          * appended from roff_block_text() in multiline mode.
 976          */
 977
 978         if (ROFF_de == tok || ROFF_dei == tok)
 979                 roff_setstrn(&r->strtab, name, namesz, "", 0, 0);
 980
 981         if ('\0' == *cp)
 982                 return(ROFF_IGN);
 983
 984         /* Get the custom end marker. */
 985
 986         iname = cp;
 987         namesz = roff_getname(r, &cp, ln, ppos);
 988
 989         /* Resolve the end marker if it is indirect. */
 990
 991         if (namesz && (ROFF_dei == tok || ROFF_ami == tok)) {
 992                 if (NULL == (name = roff_getstrn(r, iname, namesz))) {
 993                         mandoc_vmsg(MANDOCERR_STR_UNDEF,
 994                             r->parse, ln, (int)(iname - *bufp),
 995                             "%.*s", (int)namesz, iname);
 996                         namesz = 0;
 997                 } else
 998                         namesz = strlen(name);
 999         } else
1000                 name = iname;
1001
1002         if (namesz)
1003                 r->last->end = mandoc_strndup(name, namesz);
1004
1005         if ('\0' != *cp)
1006                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
1007                     ln, pos, ".%s ... %s", roffs[tok].name, cp);
1008
1009         return(ROFF_IGN);
1010 }
1011
1012 static enum rofferr
1013 roff_block_sub(ROFF_ARGS)
1014 {
1015         enum rofft      t;
1016         int             i, j;
1017
1018         /*
1019          * First check whether a custom macro exists at this level.  If
1020          * it does, then check against it.  This is some of groff's
1021          * stranger behaviours.  If we encountered a custom end-scope
1022          * tag and that tag also happens to be a "real" macro, then we
1023          * need to try interpreting it again as a real macro.  If it's
1024          * not, then return ignore.  Else continue.
1025          */
1026
1027         if (r->last->end) {
1028                 for (i = pos, j = 0; r->last->end[j]; j++, i++)
1029                         if ((*bufp)[i] != r->last->end[j])
1030                                 break;
1031
1032                 if ('\0' == r->last->end[j] &&
1033                     ('\0' == (*bufp)[i] ||
1034                      ' '  == (*bufp)[i] ||
1035                      '\t' == (*bufp)[i])) {
1036                         roffnode_pop(r);
1037                         roffnode_cleanscope(r);
1038
1039                         while (' ' == (*bufp)[i] || '\t' == (*bufp)[i])
1040                                 i++;
1041
1042                         pos = i;
1043                         if (ROFF_MAX != roff_parse(r, *bufp, &pos, ln, ppos))
1044                                 return(ROFF_RERUN);
1045                         return(ROFF_IGN);
1046                 }
1047         }
1048
1049         /*
1050          * If we have no custom end-query or lookup failed, then try
1051          * pulling it out of the hashtable.
1052          */
1053
1054         t = roff_parse(r, *bufp, &pos, ln, ppos);
1055
1056         if (ROFF_cblock != t) {
1057                 if (ROFF_ig != tok)
1058                         roff_setstr(r, r->last->name, *bufp + ppos, 2);
1059                 return(ROFF_IGN);
1060         }
1061
1062         assert(roffs[t].proc);
1063         return((*roffs[t].proc)(r, t, bufp, szp, ln, ppos, pos, offs));
1064 }
1065
1066 static enum rofferr
1067 roff_block_text(ROFF_ARGS)
1068 {
1069
1070         if (ROFF_ig != tok)
1071                 roff_setstr(r, r->last->name, *bufp + pos, 2);
1072
1073         return(ROFF_IGN);
1074 }
1075
1076 static enum rofferr
1077 roff_cond_sub(ROFF_ARGS)
1078 {
1079         enum rofft       t;
1080         char            *ep;
1081         int              rr;
1082
1083         rr = r->last->rule;
1084         roffnode_cleanscope(r);
1085         t = roff_parse(r, *bufp, &pos, ln, ppos);
1086
1087         /*
1088          * Fully handle known macros when they are structurally
1089          * required or when the conditional evaluated to true.
1090          */
1091
1092         if ((ROFF_MAX != t) &&
1093             (rr || ROFFMAC_STRUCT & roffs[t].flags)) {
1094                 assert(roffs[t].proc);
1095                 return((*roffs[t].proc)(r, t, bufp, szp,
1096                     ln, ppos, pos, offs));
1097         }
1098
1099         /*
1100          * If `\}' occurs on a macro line without a preceding macro,
1101          * drop the line completely.
1102          */
1103
1104         ep = *bufp + pos;
1105         if ('\\' == ep[0] && '}' == ep[1])
1106                 rr = 0;
1107
1108         /* Always check for the closing delimiter `\}'. */
1109
1110         while (NULL != (ep = strchr(ep, '\\'))) {
1111                 if ('}' == *(++ep)) {
1112                         *ep = '&';
1113                         roff_ccond(r, ln, ep - *bufp - 1);
1114                 }
1115                 ++ep;
1116         }
1117         return(rr ? ROFF_CONT : ROFF_IGN);
1118 }
1119
1120 static enum rofferr
1121 roff_cond_text(ROFF_ARGS)
1122 {
1123         char            *ep;
1124         int              rr;
1125
1126         rr = r->last->rule;
1127         roffnode_cleanscope(r);
1128
1129         ep = *bufp + pos;
1130         while (NULL != (ep = strchr(ep, '\\'))) {
1131                 if ('}' == *(++ep)) {
1132                         *ep = '&';
1133                         roff_ccond(r, ln, ep - *bufp - 1);
1134                 }
1135                 ++ep;
1136         }
1137         return(rr ? ROFF_CONT : ROFF_IGN);
1138 }
1139
1140 /*
1141  * Parse a single signed integer number.  Stop at the first non-digit.
1142  * If there is at least one digit, return success and advance the
1143  * parse point, else return failure and let the parse point unchanged.
1144  * Ignore overflows, treat them just like the C language.
1145  */
1146 static int
1147 roff_getnum(const char *v, int *pos, int *res)
1148 {
1149         int      myres, n, p;
1150
1151         if (NULL == res)
1152                 res = &myres;
1153
1154         p = *pos;
1155         n = v[p] == '-';
1156         if (n)
1157                 p++;
1158
1159         for (*res = 0; isdigit((unsigned char)v[p]); p++)
1160                 *res = 10 * *res + v[p] - '0';
1161         if (p == *pos + n)
1162                 return 0;
1163
1164         if (n)
1165                 *res = -*res;
1166
1167         *pos = p;
1168         return 1;
1169 }
1170
1171 /*
1172  * Evaluate a string comparison condition.
1173  * The first character is the delimiter.
1174  * Succeed if the string up to its second occurrence
1175  * matches the string up to its third occurence.
1176  * Advance the cursor after the third occurrence
1177  * or lacking that, to the end of the line.
1178  */
1179 static int
1180 roff_evalstrcond(const char *v, int *pos)
1181 {
1182         const char      *s1, *s2, *s3;
1183         int              match;
1184
1185         match = 0;
1186         s1 = v + *pos;          /* initial delimiter */
1187         s2 = s1 + 1;            /* for scanning the first string */
1188         s3 = strchr(s2, *s1);   /* for scanning the second string */
1189
1190         if (NULL == s3)         /* found no middle delimiter */
1191                 goto out;
1192
1193         while ('\0' != *++s3) {
1194                 if (*s2 != *s3) {  /* mismatch */
1195                         s3 = strchr(s3, *s1);
1196                         break;
1197                 }
1198                 if (*s3 == *s1) {  /* found the final delimiter */
1199                         match = 1;
1200                         break;
1201                 }
1202                 s2++;
1203         }
1204
1205 out:
1206         if (NULL == s3)
1207                 s3 = strchr(s2, '\0');
1208         else
1209                 s3++;
1210         *pos = s3 - v;
1211         return(match);
1212 }
1213
1214 /*
1215  * Evaluate an optionally negated single character, numerical,
1216  * or string condition.
1217  */
1218 static int
1219 roff_evalcond(const char *v, int *pos)
1220 {
1221         int      wanttrue, number;
1222
1223         if ('!' == v[*pos]) {
1224                 wanttrue = 0;
1225                 (*pos)++;
1226         } else
1227                 wanttrue = 1;
1228
1229         switch (v[*pos]) {
1230         case 'n':
1231                 /* FALLTHROUGH */
1232         case 'o':
1233                 (*pos)++;
1234                 return(wanttrue);
1235         case 'c':
1236                 /* FALLTHROUGH */
1237         case 'd':
1238                 /* FALLTHROUGH */
1239         case 'e':
1240                 /* FALLTHROUGH */
1241         case 'r':
1242                 /* FALLTHROUGH */
1243         case 't':
1244                 (*pos)++;
1245                 return(!wanttrue);
1246         default:
1247                 break;
1248         }
1249
1250         if (roff_evalnum(v, pos, &number, 0))
1251                 return((number > 0) == wanttrue);
1252         else
1253                 return(roff_evalstrcond(v, pos) == wanttrue);
1254 }
1255
1256 static enum rofferr
1257 roff_line_ignore(ROFF_ARGS)
1258 {
1259
1260         return(ROFF_IGN);
1261 }
1262
1263 static enum rofferr
1264 roff_cond(ROFF_ARGS)
1265 {
1266
1267         roffnode_push(r, tok, NULL, ln, ppos);
1268
1269         /*
1270          * An `.el' has no conditional body: it will consume the value
1271          * of the current rstack entry set in prior `ie' calls or
1272          * defaults to DENY.
1273          *
1274          * If we're not an `el', however, then evaluate the conditional.
1275          */
1276
1277         r->last->rule = ROFF_el == tok ?
1278             (r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) :
1279             roff_evalcond(*bufp, &pos);
1280
1281         /*
1282          * An if-else will put the NEGATION of the current evaluated
1283          * conditional into the stack of rules.
1284          */
1285
1286         if (ROFF_ie == tok) {
1287                 if (r->rstackpos + 1 == r->rstacksz) {
1288                         r->rstacksz += 16;
1289                         r->rstack = mandoc_reallocarray(r->rstack,
1290                             r->rstacksz, sizeof(int));
1291                 }
1292                 r->rstack[++r->rstackpos] = !r->last->rule;
1293         }
1294
1295         /* If the parent has false as its rule, then so do we. */
1296
1297         if (r->last->parent && !r->last->parent->rule)
1298                 r->last->rule = 0;
1299
1300         /*
1301          * Determine scope.
1302          * If there is nothing on the line after the conditional,
1303          * not even whitespace, use next-line scope.
1304          */
1305
1306         if ('\0' == (*bufp)[pos]) {
1307                 r->last->endspan = 2;
1308                 goto out;
1309         }
1310
1311         while (' ' == (*bufp)[pos])
1312                 pos++;
1313
1314         /* An opening brace requests multiline scope. */
1315
1316         if ('\\' == (*bufp)[pos] && '{' == (*bufp)[pos + 1]) {
1317                 r->last->endspan = -1;
1318                 pos += 2;
1319                 goto out;
1320         }
1321
1322         /*
1323          * Anything else following the conditional causes
1324          * single-line scope.  Warn if the scope contains
1325          * nothing but trailing whitespace.
1326          */
1327
1328         if ('\0' == (*bufp)[pos])
1329                 mandoc_msg(MANDOCERR_COND_EMPTY, r->parse,
1330                     ln, ppos, roffs[tok].name);
1331
1332         r->last->endspan = 1;
1333
1334 out:
1335         *offs = pos;
1336         return(ROFF_RERUN);
1337 }
1338
1339 static enum rofferr
1340 roff_ds(ROFF_ARGS)
1341 {
1342         char            *string;
1343         const char      *name;
1344         size_t           namesz;
1345
1346         /*
1347          * The first word is the name of the string.
1348          * If it is empty or terminated by an escape sequence,
1349          * abort the `ds' request without defining anything.
1350          */
1351
1352         name = string = *bufp + pos;
1353         if ('\0' == *name)
1354                 return(ROFF_IGN);
1355
1356         namesz = roff_getname(r, &string, ln, pos);
1357         if ('\\' == name[namesz])
1358                 return(ROFF_IGN);
1359
1360         /* Read past the initial double-quote, if any. */
1361         if ('"' == *string)
1362                 string++;
1363
1364         /* The rest is the value. */
1365         roff_setstrn(&r->strtab, name, namesz, string, strlen(string),
1366             ROFF_as == tok);
1367         return(ROFF_IGN);
1368 }
1369
1370 /*
1371  * Parse a single operator, one or two characters long.
1372  * If the operator is recognized, return success and advance the
1373  * parse point, else return failure and let the parse point unchanged.
1374  */
1375 static int
1376 roff_getop(const char *v, int *pos, char *res)
1377 {
1378
1379         *res = v[*pos];
1380
1381         switch (*res) {
1382         case '+':
1383                 /* FALLTHROUGH */
1384         case '-':
1385                 /* FALLTHROUGH */
1386         case '*':
1387                 /* FALLTHROUGH */
1388         case '/':
1389                 /* FALLTHROUGH */
1390         case '%':
1391                 /* FALLTHROUGH */
1392         case '&':
1393                 /* FALLTHROUGH */
1394         case ':':
1395                 break;
1396         case '<':
1397                 switch (v[*pos + 1]) {
1398                 case '=':
1399                         *res = 'l';
1400                         (*pos)++;
1401                         break;
1402                 case '>':
1403                         *res = '!';
1404                         (*pos)++;
1405                         break;
1406                 case '?':
1407                         *res = 'i';
1408                         (*pos)++;
1409                         break;
1410                 default:
1411                         break;
1412                 }
1413                 break;
1414         case '>':
1415                 switch (v[*pos + 1]) {
1416                 case '=':
1417                         *res = 'g';
1418                         (*pos)++;
1419                         break;
1420                 case '?':
1421                         *res = 'a';
1422                         (*pos)++;
1423                         break;
1424                 default:
1425                         break;
1426                 }
1427                 break;
1428         case '=':
1429                 if ('=' == v[*pos + 1])
1430                         (*pos)++;
1431                 break;
1432         default:
1433                 return(0);
1434         }
1435         (*pos)++;
1436
1437         return(*res);
1438 }
1439
1440 /*
1441  * Evaluate either a parenthesized numeric expression
1442  * or a single signed integer number.
1443  */
1444 static int
1445 roff_evalpar(const char *v, int *pos, int *res)
1446 {
1447
1448         if ('(' != v[*pos])
1449                 return(roff_getnum(v, pos, res));
1450
1451         (*pos)++;
1452         if ( ! roff_evalnum(v, pos, res, 1))
1453                 return(0);
1454
1455         /*
1456          * Omission of the closing parenthesis
1457          * is an error in validation mode,
1458          * but ignored in evaluation mode.
1459          */
1460
1461         if (')' == v[*pos])
1462                 (*pos)++;
1463         else if (NULL == res)
1464                 return(0);
1465
1466         return(1);
1467 }
1468
1469 /*
1470  * Evaluate a complete numeric expression.
1471  * Proceed left to right, there is no concept of precedence.
1472  */
1473 static int
1474 roff_evalnum(const char *v, int *pos, int *res, int skipwhite)
1475 {
1476         int              mypos, operand2;
1477         char             operator;
1478
1479         if (NULL == pos) {
1480                 mypos = 0;
1481                 pos = &mypos;
1482         }
1483
1484         if (skipwhite)
1485                 while (isspace((unsigned char)v[*pos]))
1486                         (*pos)++;
1487
1488         if ( ! roff_evalpar(v, pos, res))
1489                 return(0);
1490
1491         while (1) {
1492                 if (skipwhite)
1493                         while (isspace((unsigned char)v[*pos]))
1494                                 (*pos)++;
1495
1496                 if ( ! roff_getop(v, pos, &operator))
1497                         break;
1498
1499                 if (skipwhite)
1500                         while (isspace((unsigned char)v[*pos]))
1501                                 (*pos)++;
1502
1503                 if ( ! roff_evalpar(v, pos, &operand2))
1504                         return(0);
1505
1506                 if (skipwhite)
1507                         while (isspace((unsigned char)v[*pos]))
1508                                 (*pos)++;
1509
1510                 if (NULL == res)
1511                         continue;
1512
1513                 switch (operator) {
1514                 case '+':
1515                         *res += operand2;
1516                         break;
1517                 case '-':
1518                         *res -= operand2;
1519                         break;
1520                 case '*':
1521                         *res *= operand2;
1522                         break;
1523                 case '/':
1524                         *res /= operand2;
1525                         break;
1526                 case '%':
1527                         *res %= operand2;
1528                         break;
1529                 case '<':
1530                         *res = *res < operand2;
1531                         break;
1532                 case '>':
1533                         *res = *res > operand2;
1534                         break;
1535                 case 'l':
1536                         *res = *res <= operand2;
1537                         break;
1538                 case 'g':
1539                         *res = *res >= operand2;
1540                         break;
1541                 case '=':
1542                         *res = *res == operand2;
1543                         break;
1544                 case '!':
1545                         *res = *res != operand2;
1546                         break;
1547                 case '&':
1548                         *res = *res && operand2;
1549                         break;
1550                 case ':':
1551                         *res = *res || operand2;
1552                         break;
1553                 case 'i':
1554                         if (operand2 < *res)
1555                                 *res = operand2;
1556                         break;
1557                 case 'a':
1558                         if (operand2 > *res)
1559                                 *res = operand2;
1560                         break;
1561                 default:
1562                         abort();
1563                 }
1564         }
1565         return(1);
1566 }
1567
1568 void
1569 roff_setreg(struct roff *r, const char *name, int val, char sign)
1570 {
1571         struct roffreg  *reg;
1572
1573         /* Search for an existing register with the same name. */
1574         reg = r->regtab;
1575
1576         while (reg && strcmp(name, reg->key.p))
1577                 reg = reg->next;
1578
1579         if (NULL == reg) {
1580                 /* Create a new register. */
1581                 reg = mandoc_malloc(sizeof(struct roffreg));
1582                 reg->key.p = mandoc_strdup(name);
1583                 reg->key.sz = strlen(name);
1584                 reg->val = 0;
1585                 reg->next = r->regtab;
1586                 r->regtab = reg;
1587         }
1588
1589         if ('+' == sign)
1590                 reg->val += val;
1591         else if ('-' == sign)
1592                 reg->val -= val;
1593         else
1594                 reg->val = val;
1595 }
1596
1597 /*
1598  * Handle some predefined read-only number registers.
1599  * For now, return -1 if the requested register is not predefined;
1600  * in case a predefined read-only register having the value -1
1601  * were to turn up, another special value would have to be chosen.
1602  */
1603 static int
1604 roff_getregro(const char *name)
1605 {
1606
1607         switch (*name) {
1608         case 'A':  /* ASCII approximation mode is always off. */
1609                 return(0);
1610         case 'g':  /* Groff compatibility mode is always on. */
1611                 return(1);
1612         case 'H':  /* Fixed horizontal resolution. */
1613                 return (24);
1614         case 'j':  /* Always adjust left margin only. */
1615                 return(0);
1616         case 'T':  /* Some output device is always defined. */
1617                 return(1);
1618         case 'V':  /* Fixed vertical resolution. */
1619                 return (40);
1620         default:
1621                 return (-1);
1622         }
1623 }
1624
1625 int
1626 roff_getreg(const struct roff *r, const char *name)
1627 {
1628         struct roffreg  *reg;
1629         int              val;
1630
1631         if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) {
1632                 val = roff_getregro(name + 1);
1633                 if (-1 != val)
1634                         return (val);
1635         }
1636
1637         for (reg = r->regtab; reg; reg = reg->next)
1638                 if (0 == strcmp(name, reg->key.p))
1639                         return(reg->val);
1640
1641         return(0);
1642 }
1643
1644 static int
1645 roff_getregn(const struct roff *r, const char *name, size_t len)
1646 {
1647         struct roffreg  *reg;
1648         int              val;
1649
1650         if ('.' == name[0] && 2 == len) {
1651                 val = roff_getregro(name + 1);
1652                 if (-1 != val)
1653                         return (val);
1654         }
1655
1656         for (reg = r->regtab; reg; reg = reg->next)
1657                 if (len == reg->key.sz &&
1658                     0 == strncmp(name, reg->key.p, len))
1659                         return(reg->val);
1660
1661         return(0);
1662 }
1663
1664 static void
1665 roff_freereg(struct roffreg *reg)
1666 {
1667         struct roffreg  *old_reg;
1668
1669         while (NULL != reg) {
1670                 free(reg->key.p);
1671                 old_reg = reg;
1672                 reg = reg->next;
1673                 free(old_reg);
1674         }
1675 }
1676
1677 static enum rofferr
1678 roff_nr(ROFF_ARGS)
1679 {
1680         char            *key, *val;
1681         size_t           keysz;
1682         int              iv;
1683         char             sign;
1684
1685         key = val = *bufp + pos;
1686         if ('\0' == *key)
1687                 return(ROFF_IGN);
1688
1689         keysz = roff_getname(r, &val, ln, pos);
1690         if ('\\' == key[keysz])
1691                 return(ROFF_IGN);
1692         key[keysz] = '\0';
1693
1694         sign = *val;
1695         if ('+' == sign || '-' == sign)
1696                 val++;
1697
1698         if (roff_evalnum(val, NULL, &iv, 0))
1699                 roff_setreg(r, key, iv, sign);
1700
1701         return(ROFF_IGN);
1702 }
1703
1704 static enum rofferr
1705 roff_rr(ROFF_ARGS)
1706 {
1707         struct roffreg  *reg, **prev;
1708         char            *name, *cp;
1709         size_t           namesz;
1710
1711         name = cp = *bufp + pos;
1712         if ('\0' == *name)
1713                 return(ROFF_IGN);
1714         namesz = roff_getname(r, &cp, ln, pos);
1715         name[namesz] = '\0';
1716
1717         prev = &r->regtab;
1718         while (1) {
1719                 reg = *prev;
1720                 if (NULL == reg || !strcmp(name, reg->key.p))
1721                         break;
1722                 prev = &reg->next;
1723         }
1724         if (NULL != reg) {
1725                 *prev = reg->next;
1726                 free(reg->key.p);
1727                 free(reg);
1728         }
1729         return(ROFF_IGN);
1730 }
1731
1732 static enum rofferr
1733 roff_rm(ROFF_ARGS)
1734 {
1735         const char       *name;
1736         char             *cp;
1737         size_t            namesz;
1738
1739         cp = *bufp + pos;
1740         while ('\0' != *cp) {
1741                 name = cp;
1742                 namesz = roff_getname(r, &cp, ln, (int)(cp - *bufp));
1743                 roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0);
1744                 if ('\\' == name[namesz])
1745                         break;
1746         }
1747         return(ROFF_IGN);
1748 }
1749
1750 static enum rofferr
1751 roff_it(ROFF_ARGS)
1752 {
1753         char            *cp;
1754         size_t           len;
1755         int              iv;
1756
1757         /* Parse the number of lines. */
1758         cp = *bufp + pos;
1759         len = strcspn(cp, " \t");
1760         cp[len] = '\0';
1761         if ((iv = mandoc_strntoi(cp, len, 10)) <= 0) {
1762                 mandoc_msg(MANDOCERR_IT_NONUM, r->parse,
1763                     ln, ppos, *bufp + 1);
1764                 return(ROFF_IGN);
1765         }
1766         cp += len + 1;
1767
1768         /* Arm the input line trap. */
1769         roffit_lines = iv;
1770         roffit_macro = mandoc_strdup(cp);
1771         return(ROFF_IGN);
1772 }
1773
1774 static enum rofferr
1775 roff_Dd(ROFF_ARGS)
1776 {
1777         const char *const       *cp;
1778
1779         if (0 == ((MPARSE_MDOC | MPARSE_QUICK) & r->options))
1780                 for (cp = __mdoc_reserved; *cp; cp++)
1781                         roff_setstr(r, *cp, NULL, 0);
1782
1783         return(ROFF_CONT);
1784 }
1785
1786 static enum rofferr
1787 roff_TH(ROFF_ARGS)
1788 {
1789         const char *const       *cp;
1790
1791         if (0 == (MPARSE_QUICK & r->options))
1792                 for (cp = __man_reserved; *cp; cp++)
1793                         roff_setstr(r, *cp, NULL, 0);
1794
1795         return(ROFF_CONT);
1796 }
1797
1798 static enum rofferr
1799 roff_TE(ROFF_ARGS)
1800 {
1801
1802         if (NULL == r->tbl)
1803                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1804                     ln, ppos, "TE");
1805         else
1806                 tbl_end(&r->tbl);
1807
1808         return(ROFF_IGN);
1809 }
1810
1811 static enum rofferr
1812 roff_T_(ROFF_ARGS)
1813 {
1814
1815         if (NULL == r->tbl)
1816                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1817                     ln, ppos, "T&");
1818         else
1819                 tbl_restart(ppos, ln, r->tbl);
1820
1821         return(ROFF_IGN);
1822 }
1823
1824 #if 0
1825 static int
1826 roff_closeeqn(struct roff *r)
1827 {
1828
1829         return(r->eqn && ROFF_EQN == eqn_end(&r->eqn) ? 1 : 0);
1830 }
1831 #endif
1832
1833 static void
1834 roff_openeqn(struct roff *r, const char *name, int line,
1835                 int offs, const char *buf)
1836 {
1837         struct eqn_node *e;
1838         int              poff;
1839
1840         assert(NULL == r->eqn);
1841         e = eqn_alloc(name, offs, line, r->parse);
1842
1843         if (r->last_eqn)
1844                 r->last_eqn->next = e;
1845         else
1846                 r->first_eqn = r->last_eqn = e;
1847
1848         r->eqn = r->last_eqn = e;
1849
1850         if (buf) {
1851                 poff = 0;
1852                 eqn_read(&r->eqn, line, buf, offs, &poff);
1853         }
1854 }
1855
1856 static enum rofferr
1857 roff_EQ(ROFF_ARGS)
1858 {
1859
1860         roff_openeqn(r, *bufp + pos, ln, ppos, NULL);
1861         return(ROFF_IGN);
1862 }
1863
1864 static enum rofferr
1865 roff_EN(ROFF_ARGS)
1866 {
1867
1868         mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");
1869         return(ROFF_IGN);
1870 }
1871
1872 static enum rofferr
1873 roff_TS(ROFF_ARGS)
1874 {
1875         struct tbl_node *tbl;
1876
1877         if (r->tbl) {
1878                 mandoc_msg(MANDOCERR_BLK_BROKEN, r->parse,
1879                     ln, ppos, "TS breaks TS");
1880                 tbl_end(&r->tbl);
1881         }
1882
1883         tbl = tbl_alloc(ppos, ln, r->parse);
1884
1885         if (r->last_tbl)
1886                 r->last_tbl->next = tbl;
1887         else
1888                 r->first_tbl = r->last_tbl = tbl;
1889
1890         r->tbl = r->last_tbl = tbl;
1891         return(ROFF_IGN);
1892 }
1893
1894 static enum rofferr
1895 roff_cc(ROFF_ARGS)
1896 {
1897         const char      *p;
1898
1899         p = *bufp + pos;
1900
1901         if ('\0' == *p || '.' == (r->control = *p++))
1902                 r->control = 0;
1903
1904         if ('\0' != *p)
1905                 mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL);
1906
1907         return(ROFF_IGN);
1908 }
1909
1910 static enum rofferr
1911 roff_tr(ROFF_ARGS)
1912 {
1913         const char      *p, *first, *second;
1914         size_t           fsz, ssz;
1915         enum mandoc_esc  esc;
1916
1917         p = *bufp + pos;
1918
1919         if ('\0' == *p) {
1920                 mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL);
1921                 return(ROFF_IGN);
1922         }
1923
1924         while ('\0' != *p) {
1925                 fsz = ssz = 1;
1926
1927                 first = p++;
1928                 if ('\\' == *first) {
1929                         esc = mandoc_escape(&p, NULL, NULL);
1930                         if (ESCAPE_ERROR == esc) {
1931                                 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
1932                                     ln, (int)(p - *bufp), first);
1933                                 return(ROFF_IGN);
1934                         }
1935                         fsz = (size_t)(p - first);
1936                 }
1937
1938                 second = p++;
1939                 if ('\\' == *second) {
1940                         esc = mandoc_escape(&p, NULL, NULL);
1941                         if (ESCAPE_ERROR == esc) {
1942                                 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
1943                                     ln, (int)(p - *bufp), second);
1944                                 return(ROFF_IGN);
1945                         }
1946                         ssz = (size_t)(p - second);
1947                 } else if ('\0' == *second) {
1948                         mandoc_msg(MANDOCERR_ARGCOUNT, r->parse,
1949                             ln, (int)(p - *bufp), NULL);
1950                         second = " ";
1951                         p--;
1952                 }
1953
1954                 if (fsz > 1) {
1955                         roff_setstrn(&r->xmbtab, first, fsz,
1956                             second, ssz, 0);
1957                         continue;
1958                 }
1959
1960                 if (NULL == r->xtab)
1961                         r->xtab = mandoc_calloc(128,
1962                             sizeof(struct roffstr));
1963
1964                 free(r->xtab[(int)*first].p);
1965                 r->xtab[(int)*first].p = mandoc_strndup(second, ssz);
1966                 r->xtab[(int)*first].sz = ssz;
1967         }
1968
1969         return(ROFF_IGN);
1970 }
1971
1972 static enum rofferr
1973 roff_so(ROFF_ARGS)
1974 {
1975         char *name;
1976
1977         name = *bufp + pos;
1978         mandoc_vmsg(MANDOCERR_SO, r->parse, ln, ppos, "so %s", name);
1979
1980         /*
1981          * Handle `so'.  Be EXTREMELY careful, as we shouldn't be
1982          * opening anything that's not in our cwd or anything beneath
1983          * it.  Thus, explicitly disallow traversing up the file-system
1984          * or using absolute paths.
1985          */
1986
1987         if ('/' == *name || strstr(name, "../") || strstr(name, "/..")) {
1988                 mandoc_vmsg(MANDOCERR_SO_PATH, r->parse, ln, ppos,
1989                     ".so %s", name);
1990                 return(ROFF_ERR);
1991         }
1992
1993         *offs = pos;
1994         return(ROFF_SO);
1995 }
1996
1997 static enum rofferr
1998 roff_userdef(ROFF_ARGS)
1999 {
2000         const char       *arg[9];
2001         char             *cp, *n1, *n2;
2002         int               i;
2003
2004         /*
2005          * Collect pointers to macro argument strings
2006          * and NUL-terminate them.
2007          */
2008         cp = *bufp + pos;
2009         for (i = 0; i < 9; i++)
2010                 arg[i] = '\0' == *cp ? "" :
2011                     mandoc_getarg(r->parse, &cp, ln, &pos);
2012
2013         /*
2014          * Expand macro arguments.
2015          */
2016         *szp = 0;
2017         n1 = cp = mandoc_strdup(r->current_string);
2018         while (NULL != (cp = strstr(cp, "\\$"))) {
2019                 i = cp[2] - '1';
2020                 if (0 > i || 8 < i) {
2021                         /* Not an argument invocation. */
2022                         cp += 2;
2023                         continue;
2024                 }
2025                 *cp = '\0';
2026                 *szp = mandoc_asprintf(&n2, "%s%s%s",
2027                     n1, arg[i], cp + 3) + 1;
2028                 cp = n2 + (cp - n1);
2029                 free(n1);
2030                 n1 = n2;
2031         }
2032
2033         /*
2034          * Replace the macro invocation
2035          * by the expanded macro.
2036          */
2037         free(*bufp);
2038         *bufp = n1;
2039         if (0 == *szp)
2040                 *szp = strlen(*bufp) + 1;
2041
2042         return(*szp > 1 && '\n' == (*bufp)[(int)*szp - 2] ?
2043            ROFF_REPARSE : ROFF_APPEND);
2044 }
2045
2046 static size_t
2047 roff_getname(struct roff *r, char **cpp, int ln, int pos)
2048 {
2049         char     *name, *cp;
2050         size_t    namesz;
2051
2052         name = *cpp;
2053         if ('\0' == *name)
2054                 return(0);
2055
2056         /* Read until end of name and terminate it with NUL. */
2057         for (cp = name; 1; cp++) {
2058                 if ('\0' == *cp || ' ' == *cp) {
2059                         namesz = cp - name;
2060                         break;
2061                 }
2062                 if ('\\' != *cp)
2063                         continue;
2064                 namesz = cp - name;
2065                 if ('{' == cp[1] || '}' == cp[1])
2066                         break;
2067                 cp++;
2068                 if ('\\' == *cp)
2069                         continue;
2070                 mandoc_vmsg(MANDOCERR_NAMESC, r->parse, ln, pos,
2071                     "%.*s", (int)(cp - name + 1), name);
2072                 mandoc_escape((const char **)&cp, NULL, NULL);
2073                 break;
2074         }
2075
2076         /* Read past spaces. */
2077         while (' ' == *cp)
2078                 cp++;
2079
2080         *cpp = cp;
2081         return(namesz);
2082 }
2083
2084 /*
2085  * Store *string into the user-defined string called *name.
2086  * To clear an existing entry, call with (*r, *name, NULL, 0).
2087  * append == 0: replace mode
2088  * append == 1: single-line append mode
2089  * append == 2: multiline append mode, append '\n' after each call
2090  */
2091 static void
2092 roff_setstr(struct roff *r, const char *name, const char *string,
2093         int append)
2094 {
2095
2096         roff_setstrn(&r->strtab, name, strlen(name), string,
2097             string ? strlen(string) : 0, append);
2098 }
2099
2100 static void
2101 roff_setstrn(struct roffkv **r, const char *name, size_t namesz,
2102                 const char *string, size_t stringsz, int append)
2103 {
2104         struct roffkv   *n;
2105         char            *c;
2106         int              i;
2107         size_t           oldch, newch;
2108
2109         /* Search for an existing string with the same name. */
2110         n = *r;
2111
2112         while (n && (namesz != n->key.sz ||
2113                         strncmp(n->key.p, name, namesz)))
2114                 n = n->next;
2115
2116         if (NULL == n) {
2117                 /* Create a new string table entry. */
2118                 n = mandoc_malloc(sizeof(struct roffkv));
2119                 n->key.p = mandoc_strndup(name, namesz);
2120                 n->key.sz = namesz;
2121                 n->val.p = NULL;
2122                 n->val.sz = 0;
2123                 n->next = *r;
2124                 *r = n;
2125         } else if (0 == append) {
2126                 free(n->val.p);
2127                 n->val.p = NULL;
2128                 n->val.sz = 0;
2129         }
2130
2131         if (NULL == string)
2132                 return;
2133
2134         /*
2135          * One additional byte for the '\n' in multiline mode,
2136          * and one for the terminating '\0'.
2137          */
2138         newch = stringsz + (1 < append ? 2u : 1u);
2139
2140         if (NULL == n->val.p) {
2141                 n->val.p = mandoc_malloc(newch);
2142                 *n->val.p = '\0';
2143                 oldch = 0;
2144         } else {
2145                 oldch = n->val.sz;
2146                 n->val.p = mandoc_realloc(n->val.p, oldch + newch);
2147         }
2148
2149         /* Skip existing content in the destination buffer. */
2150         c = n->val.p + (int)oldch;
2151
2152         /* Append new content to the destination buffer. */
2153         i = 0;
2154         while (i < (int)stringsz) {
2155                 /*
2156                  * Rudimentary roff copy mode:
2157                  * Handle escaped backslashes.
2158                  */
2159                 if ('\\' == string[i] && '\\' == string[i + 1])
2160                         i++;
2161                 *c++ = string[i++];
2162         }
2163
2164         /* Append terminating bytes. */
2165         if (1 < append)
2166                 *c++ = '\n';
2167
2168         *c = '\0';
2169         n->val.sz = (int)(c - n->val.p);
2170 }
2171
2172 static const char *
2173 roff_getstrn(const struct roff *r, const char *name, size_t len)
2174 {
2175         const struct roffkv *n;
2176         int i;
2177
2178         for (n = r->strtab; n; n = n->next)
2179                 if (0 == strncmp(name, n->key.p, len) &&
2180                     '\0' == n->key.p[(int)len])
2181                         return(n->val.p);
2182
2183         for (i = 0; i < PREDEFS_MAX; i++)
2184                 if (0 == strncmp(name, predefs[i].name, len) &&
2185                                 '\0' == predefs[i].name[(int)len])
2186                         return(predefs[i].str);
2187
2188         return(NULL);
2189 }
2190
2191 static void
2192 roff_freestr(struct roffkv *r)
2193 {
2194         struct roffkv    *n, *nn;
2195
2196         for (n = r; n; n = nn) {
2197                 free(n->key.p);
2198                 free(n->val.p);
2199                 nn = n->next;
2200                 free(n);
2201         }
2202 }
2203
2204 const struct tbl_span *
2205 roff_span(const struct roff *r)
2206 {
2207
2208         return(r->tbl ? tbl_span(r->tbl) : NULL);
2209 }
2210
2211 const struct eqn *
2212 roff_eqn(const struct roff *r)
2213 {
2214
2215         return(r->last_eqn ? &r->last_eqn->eqn : NULL);
2216 }
2217
2218 /*
2219  * Duplicate an input string, making the appropriate character
2220  * conversations (as stipulated by `tr') along the way.
2221  * Returns a heap-allocated string with all the replacements made.
2222  */
2223 char *
2224 roff_strdup(const struct roff *r, const char *p)
2225 {
2226         const struct roffkv *cp;
2227         char            *res;
2228         const char      *pp;
2229         size_t           ssz, sz;
2230         enum mandoc_esc  esc;
2231
2232         if (NULL == r->xmbtab && NULL == r->xtab)
2233                 return(mandoc_strdup(p));
2234         else if ('\0' == *p)
2235                 return(mandoc_strdup(""));
2236
2237         /*
2238          * Step through each character looking for term matches
2239          * (remember that a `tr' can be invoked with an escape, which is
2240          * a glyph but the escape is multi-character).
2241          * We only do this if the character hash has been initialised
2242          * and the string is >0 length.
2243          */
2244
2245         res = NULL;
2246         ssz = 0;
2247
2248         while ('\0' != *p) {
2249                 if ('\\' != *p && r->xtab && r->xtab[(int)*p].p) {
2250                         sz = r->xtab[(int)*p].sz;
2251                         res = mandoc_realloc(res, ssz + sz + 1);
2252                         memcpy(res + ssz, r->xtab[(int)*p].p, sz);
2253                         ssz += sz;
2254                         p++;
2255                         continue;
2256                 } else if ('\\' != *p) {
2257                         res = mandoc_realloc(res, ssz + 2);
2258                         res[ssz++] = *p++;
2259                         continue;
2260                 }
2261
2262                 /* Search for term matches. */
2263                 for (cp = r->xmbtab; cp; cp = cp->next)
2264                         if (0 == strncmp(p, cp->key.p, cp->key.sz))
2265                                 break;
2266
2267                 if (NULL != cp) {
2268                         /*
2269                          * A match has been found.
2270                          * Append the match to the array and move
2271                          * forward by its keysize.
2272                          */
2273                         res = mandoc_realloc(res,
2274                             ssz + cp->val.sz + 1);
2275                         memcpy(res + ssz, cp->val.p, cp->val.sz);
2276                         ssz += cp->val.sz;
2277                         p += (int)cp->key.sz;
2278                         continue;
2279                 }
2280
2281                 /*
2282                  * Handle escapes carefully: we need to copy
2283                  * over just the escape itself, or else we might
2284                  * do replacements within the escape itself.
2285                  * Make sure to pass along the bogus string.
2286                  */
2287                 pp = p++;
2288                 esc = mandoc_escape(&p, NULL, NULL);
2289                 if (ESCAPE_ERROR == esc) {
2290                         sz = strlen(pp);
2291                         res = mandoc_realloc(res, ssz + sz + 1);
2292                         memcpy(res + ssz, pp, sz);
2293                         break;
2294                 }
2295                 /*
2296                  * We bail out on bad escapes.
2297                  * No need to warn: we already did so when
2298                  * roff_res() was called.
2299                  */
2300                 sz = (int)(p - pp);
2301                 res = mandoc_realloc(res, ssz + sz + 1);
2302                 memcpy(res + ssz, pp, sz);
2303                 ssz += sz;
2304         }
2305
2306         res[(int)ssz] = '\0';
2307         return(res);
2308 }
2309
2310 /*
2311  * Find out whether a line is a macro line or not.
2312  * If it is, adjust the current position and return one; if it isn't,
2313  * return zero and don't change the current position.
2314  * If the control character has been set with `.cc', then let that grain
2315  * precedence.
2316  * This is slighly contrary to groff, where using the non-breaking
2317  * control character when `cc' has been invoked will cause the
2318  * non-breaking macro contents to be printed verbatim.
2319  */
2320 int
2321 roff_getcontrol(const struct roff *r, const char *cp, int *ppos)
2322 {
2323         int             pos;
2324
2325         pos = *ppos;
2326
2327         if (0 != r->control && cp[pos] == r->control)
2328                 pos++;
2329         else if (0 != r->control)
2330                 return(0);
2331         else if ('\\' == cp[pos] && '.' == cp[pos + 1])
2332                 pos += 2;
2333         else if ('.' == cp[pos] || '\'' == cp[pos])
2334                 pos++;
2335         else
2336                 return(0);
2337
2338         while (' ' == cp[pos] || '\t' == cp[pos])
2339                 pos++;
2340
2341         *ppos = pos;
2342         return(1);
2343 }