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 = ®->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 } 3471