contrib/mdocml/roff.c

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