contrib/mdocml/roff.c

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