1 /* $Id: read.c,v 1.192 2017/07/20 14:36:36 schwarze Exp $ */ 2 /* 3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv> 4 * Copyright (c) 2010-2017 Ingo Schwarze <schwarze@openbsd.org> 5 * Copyright (c) 2010, 2012 Joerg Sonnenberger <joerg@netbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 #include "config.h" 20 21 #include <sys/types.h> 22 #include <sys/mman.h> 23 #include <sys/stat.h> 24 25 #include <assert.h> 26 #include <ctype.h> 27 #include <errno.h> 28 #include <fcntl.h> 29 #include <stdarg.h> 30 #include <stdio.h> 31 #include <stdlib.h> 32 #include <string.h> 33 #include <unistd.h> 34 #include <zlib.h> 35 36 #include "mandoc_aux.h" 37 #include "mandoc.h" 38 #include "roff.h" 39 #include "mdoc.h" 40 #include "man.h" 41 #include "libmandoc.h" 42 43 #define REPARSE_LIMIT 1000 44 45 struct mparse { 46 struct roff *roff; /* roff parser (!NULL) */ 47 struct roff_man *man; /* man parser */ 48 char *sodest; /* filename pointed to by .so */ 49 const char *file; /* filename of current input file */ 50 struct buf *primary; /* buffer currently being parsed */ 51 struct buf *secondary; /* preprocessed copy of input */ 52 const char *os_s; /* default operating system */ 53 mandocmsg mmsg; /* warning/error message handler */ 54 enum mandoclevel file_status; /* status of current parse */ 55 enum mandocerr mmin; /* ignore messages below this */ 56 int options; /* parser options */ 57 int gzip; /* current input file is gzipped */ 58 int filenc; /* encoding of the current file */ 59 int reparse_count; /* finite interp. stack */ 60 int line; /* line number in the file */ 61 }; 62 63 static void choose_parser(struct mparse *); 64 static void resize_buf(struct buf *, size_t); 65 static int mparse_buf_r(struct mparse *, struct buf, size_t, int); 66 static int read_whole_file(struct mparse *, const char *, int, 67 struct buf *, int *); 68 static void mparse_end(struct mparse *); 69 static void mparse_parse_buffer(struct mparse *, struct buf, 70 const char *); 71 72 static const enum mandocerr mandoclimits[MANDOCLEVEL_MAX] = { 73 MANDOCERR_OK, 74 MANDOCERR_OK, 75 MANDOCERR_WARNING, 76 MANDOCERR_ERROR, 77 MANDOCERR_UNSUPP, 78 MANDOCERR_MAX, 79 MANDOCERR_MAX 80 }; 81 82 static const char * const mandocerrs[MANDOCERR_MAX] = { 83 "ok", 84 85 "base system convention", 86 87 "Mdocdate found", 88 "Mdocdate missing", 89 "unknown architecture", 90 "operating system explicitly specified", 91 "RCS id missing", 92 "referenced manual not found", 93 94 "generic style suggestion", 95 96 "legacy man(7) date format", 97 "lower case character in document title", 98 "duplicate RCS id", 99 "typo in section name", 100 "unterminated quoted argument", 101 "useless macro", 102 "consider using OS macro", 103 "errnos out of order", 104 "duplicate errno", 105 "trailing delimiter", 106 "no blank before trailing delimiter", 107 "fill mode already enabled, skipping", 108 "fill mode already disabled, skipping", 109 "function name without markup", 110 "whitespace at end of input line", 111 "bad comment style", 112 113 "generic warning", 114 115 /* related to the prologue */ 116 "missing manual title, using UNTITLED", 117 "missing manual title, using \"\"", 118 "missing manual section, using \"\"", 119 "unknown manual section", 120 "missing date, using today's date", 121 "cannot parse date, using it verbatim", 122 "date in the future, using it anyway", 123 "missing Os macro, using \"\"", 124 "late prologue macro", 125 "prologue macros out of order", 126 127 /* related to document structure */ 128 ".so is fragile, better use ln(1)", 129 "no document body", 130 "content before first section header", 131 "first section is not \"NAME\"", 132 "NAME section without Nm before Nd", 133 "NAME section without description", 134 "description not at the end of NAME", 135 "bad NAME section content", 136 "missing comma before name", 137 "missing description line, using \"\"", 138 "description line outside NAME section", 139 "sections out of conventional order", 140 "duplicate section title", 141 "unexpected section", 142 "cross reference to self", 143 "unusual Xr order", 144 "unusual Xr punctuation", 145 "AUTHORS section without An macro", 146 147 /* related to macros and nesting */ 148 "obsolete macro", 149 "macro neither callable nor escaped", 150 "skipping paragraph macro", 151 "moving paragraph macro out of list", 152 "skipping no-space macro", 153 "blocks badly nested", 154 "nested displays are not portable", 155 "moving content out of list", 156 "first macro on line", 157 "line scope broken", 158 "skipping blank line in line scope", 159 160 /* related to missing macro arguments */ 161 "skipping empty request", 162 "conditional request controls empty scope", 163 "skipping empty macro", 164 "empty block", 165 "empty argument, using 0n", 166 "missing display type, using -ragged", 167 "list type is not the first argument", 168 "missing -width in -tag list, using 6n", 169 "missing utility name, using \"\"", 170 "missing function name, using \"\"", 171 "empty head in list item", 172 "empty list item", 173 "missing argument, using next line", 174 "missing font type, using \\fR", 175 "unknown font type, using \\fR", 176 "nothing follows prefix", 177 "empty reference block", 178 "missing section argument", 179 "missing -std argument, adding it", 180 "missing option string, using \"\"", 181 "missing resource identifier, using \"\"", 182 "missing eqn box, using \"\"", 183 184 /* related to bad macro arguments */ 185 "duplicate argument", 186 "skipping duplicate argument", 187 "skipping duplicate display type", 188 "skipping duplicate list type", 189 "skipping -width argument", 190 "wrong number of cells", 191 "unknown AT&T UNIX version", 192 "comma in function argument", 193 "parenthesis in function name", 194 "unknown library name", 195 "invalid content in Rs block", 196 "invalid Boolean argument", 197 "unknown font, skipping request", 198 "odd number of characters in request", 199 200 /* related to plain text */ 201 "blank line in fill mode, using .sp", 202 "tab in filled text", 203 "new sentence, new line", 204 "invalid escape sequence", 205 "undefined string, using \"\"", 206 207 /* related to tables */ 208 "tbl line starts with span", 209 "tbl column starts with span", 210 "skipping vertical bar in tbl layout", 211 212 "generic error", 213 214 /* related to tables */ 215 "non-alphabetic character in tbl options", 216 "skipping unknown tbl option", 217 "missing tbl option argument", 218 "wrong tbl option argument size", 219 "empty tbl layout", 220 "invalid character in tbl layout", 221 "unmatched parenthesis in tbl layout", 222 "tbl without any data cells", 223 "ignoring data in spanned tbl cell", 224 "ignoring extra tbl data cells", 225 "data block open at end of tbl", 226 227 /* related to document structure and macros */ 228 NULL, 229 "duplicate prologue macro", 230 "skipping late title macro", 231 "input stack limit exceeded, infinite loop?", 232 "skipping bad character", 233 "skipping unknown macro", 234 "skipping insecure request", 235 "skipping item outside list", 236 "skipping column outside column list", 237 "skipping end of block that is not open", 238 "fewer RS blocks open, skipping", 239 "inserting missing end of block", 240 "appending missing end of block", 241 242 /* related to request and macro arguments */ 243 "escaped character not allowed in a name", 244 "NOT IMPLEMENTED: Bd -file", 245 "skipping display without arguments", 246 "missing list type, using -item", 247 "argument is not numeric, using 1", 248 "missing manual name, using \"\"", 249 "uname(3) system call failed, using UNKNOWN", 250 "unknown standard specifier", 251 "skipping request without numeric argument", 252 "NOT IMPLEMENTED: .so with absolute path or \"..\"", 253 ".so request failed", 254 "skipping all arguments", 255 "skipping excess arguments", 256 "divide by zero", 257 258 "unsupported feature", 259 "input too large", 260 "unsupported control character", 261 "unsupported roff request", 262 "eqn delim option in tbl", 263 "unsupported tbl layout modifier", 264 "ignoring macro in table", 265 }; 266 267 static const char * const mandoclevels[MANDOCLEVEL_MAX] = { 268 "SUCCESS", 269 "STYLE", 270 "WARNING", 271 "ERROR", 272 "UNSUPP", 273 "BADARG", 274 "SYSERR" 275 }; 276 277 278 static void 279 resize_buf(struct buf *buf, size_t initial) 280 { 281 282 buf->sz = buf->sz > initial/2 ? 2 * buf->sz : initial; 283 buf->buf = mandoc_realloc(buf->buf, buf->sz); 284 } 285 286 static void 287 choose_parser(struct mparse *curp) 288 { 289 char *cp, *ep; 290 int format; 291 292 /* 293 * If neither command line arguments -mdoc or -man select 294 * a parser nor the roff parser found a .Dd or .TH macro 295 * yet, look ahead in the main input buffer. 296 */ 297 298 if ((format = roff_getformat(curp->roff)) == 0) { 299 cp = curp->primary->buf; 300 ep = cp + curp->primary->sz; 301 while (cp < ep) { 302 if (*cp == '.' || *cp == '\'') { 303 cp++; 304 if (cp[0] == 'D' && cp[1] == 'd') { 305 format = MPARSE_MDOC; 306 break; 307 } 308 if (cp[0] == 'T' && cp[1] == 'H') { 309 format = MPARSE_MAN; 310 break; 311 } 312 } 313 cp = memchr(cp, '\n', ep - cp); 314 if (cp == NULL) 315 break; 316 cp++; 317 } 318 } 319 320 if (format == MPARSE_MDOC) { 321 curp->man->macroset = MACROSET_MDOC; 322 if (curp->man->mdocmac == NULL) 323 curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX); 324 } else { 325 curp->man->macroset = MACROSET_MAN; 326 if (curp->man->manmac == NULL) 327 curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX); 328 } 329 curp->man->first->tok = TOKEN_NONE; 330 } 331 332 /* 333 * Main parse routine for a buffer. 334 * It assumes encoding and line numbering are already set up. 335 * It can recurse directly (for invocations of user-defined 336 * macros, inline equations, and input line traps) 337 * and indirectly (for .so file inclusion). 338 */ 339 static int 340 mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start) 341 { 342 struct buf ln; 343 const char *save_file; 344 char *cp; 345 size_t pos; /* byte number in the ln buffer */ 346 enum rofferr rr; 347 int of; 348 int lnn; /* line number in the real file */ 349 int fd; 350 unsigned char c; 351 352 memset(&ln, 0, sizeof(ln)); 353 354 lnn = curp->line; 355 pos = 0; 356 357 while (i < blk.sz) { 358 if (0 == pos && '\0' == blk.buf[i]) 359 break; 360 361 if (start) { 362 curp->line = lnn; 363 curp->reparse_count = 0; 364 365 if (lnn < 3 && 366 curp->filenc & MPARSE_UTF8 && 367 curp->filenc & MPARSE_LATIN1) 368 curp->filenc = preconv_cue(&blk, i); 369 } 370 371 while (i < blk.sz && (start || blk.buf[i] != '\0')) { 372 373 /* 374 * When finding an unescaped newline character, 375 * leave the character loop to process the line. 376 * Skip a preceding carriage return, if any. 377 */ 378 379 if ('\r' == blk.buf[i] && i + 1 < blk.sz && 380 '\n' == blk.buf[i + 1]) 381 ++i; 382 if ('\n' == blk.buf[i]) { 383 ++i; 384 ++lnn; 385 break; 386 } 387 388 /* 389 * Make sure we have space for the worst 390 * case of 11 bytes: "\\[u10ffff]\0" 391 */ 392 393 if (pos + 11 > ln.sz) 394 resize_buf(&ln, 256); 395 396 /* 397 * Encode 8-bit input. 398 */ 399 400 c = blk.buf[i]; 401 if (c & 0x80) { 402 if ( ! (curp->filenc && preconv_encode( 403 &blk, &i, &ln, &pos, &curp->filenc))) { 404 mandoc_vmsg(MANDOCERR_CHAR_BAD, curp, 405 curp->line, pos, "0x%x", c); 406 ln.buf[pos++] = '?'; 407 i++; 408 } 409 continue; 410 } 411 412 /* 413 * Exclude control characters. 414 */ 415 416 if (c == 0x7f || (c < 0x20 && c != 0x09)) { 417 mandoc_vmsg(c == 0x00 || c == 0x04 || 418 c > 0x0a ? MANDOCERR_CHAR_BAD : 419 MANDOCERR_CHAR_UNSUPP, 420 curp, curp->line, pos, "0x%x", c); 421 i++; 422 if (c != '\r') 423 ln.buf[pos++] = '?'; 424 continue; 425 } 426 427 ln.buf[pos++] = blk.buf[i++]; 428 } 429 430 if (pos + 1 >= ln.sz) 431 resize_buf(&ln, 256); 432 433 if (i == blk.sz || blk.buf[i] == '\0') 434 ln.buf[pos++] = '\n'; 435 ln.buf[pos] = '\0'; 436 437 /* 438 * A significant amount of complexity is contained by 439 * the roff preprocessor. It's line-oriented but can be 440 * expressed on one line, so we need at times to 441 * readjust our starting point and re-run it. The roff 442 * preprocessor can also readjust the buffers with new 443 * data, so we pass them in wholesale. 444 */ 445 446 of = 0; 447 448 /* 449 * Maintain a lookaside buffer of all parsed lines. We 450 * only do this if mparse_keep() has been invoked (the 451 * buffer may be accessed with mparse_getkeep()). 452 */ 453 454 if (curp->secondary) { 455 curp->secondary->buf = mandoc_realloc( 456 curp->secondary->buf, 457 curp->secondary->sz + pos + 2); 458 memcpy(curp->secondary->buf + 459 curp->secondary->sz, 460 ln.buf, pos); 461 curp->secondary->sz += pos; 462 curp->secondary->buf 463 [curp->secondary->sz] = '\n'; 464 curp->secondary->sz++; 465 curp->secondary->buf 466 [curp->secondary->sz] = '\0'; 467 } 468 rerun: 469 rr = roff_parseln(curp->roff, curp->line, &ln, &of); 470 471 switch (rr) { 472 case ROFF_REPARSE: 473 if (++curp->reparse_count > REPARSE_LIMIT) 474 mandoc_msg(MANDOCERR_ROFFLOOP, curp, 475 curp->line, pos, NULL); 476 else if (mparse_buf_r(curp, ln, of, 0) == 1 || 477 start == 1) { 478 pos = 0; 479 continue; 480 } 481 free(ln.buf); 482 return 0; 483 case ROFF_APPEND: 484 pos = strlen(ln.buf); 485 continue; 486 case ROFF_RERUN: 487 goto rerun; 488 case ROFF_IGN: 489 pos = 0; 490 continue; 491 case ROFF_SO: 492 if ( ! (curp->options & MPARSE_SO) && 493 (i >= blk.sz || blk.buf[i] == '\0')) { 494 curp->sodest = mandoc_strdup(ln.buf + of); 495 free(ln.buf); 496 return 1; 497 } 498 /* 499 * We remove `so' clauses from our lookaside 500 * buffer because we're going to descend into 501 * the file recursively. 502 */ 503 if (curp->secondary) 504 curp->secondary->sz -= pos + 1; 505 save_file = curp->file; 506 if ((fd = mparse_open(curp, ln.buf + of)) != -1) { 507 mparse_readfd(curp, fd, ln.buf + of); 508 close(fd); 509 curp->file = save_file; 510 } else { 511 curp->file = save_file; 512 mandoc_vmsg(MANDOCERR_SO_FAIL, 513 curp, curp->line, pos, 514 ".so %s", ln.buf + of); 515 ln.sz = mandoc_asprintf(&cp, 516 ".sp\nSee the file %s.\n.sp", 517 ln.buf + of); 518 free(ln.buf); 519 ln.buf = cp; 520 of = 0; 521 mparse_buf_r(curp, ln, of, 0); 522 } 523 pos = 0; 524 continue; 525 default: 526 break; 527 } 528 529 if (curp->man->macroset == MACROSET_NONE) 530 choose_parser(curp); 531 532 if ((curp->man->macroset == MACROSET_MDOC ? 533 mdoc_parseln(curp->man, curp->line, ln.buf, of) : 534 man_parseln(curp->man, curp->line, ln.buf, of)) == 2) 535 break; 536 537 /* Temporary buffers typically are not full. */ 538 539 if (0 == start && '\0' == blk.buf[i]) 540 break; 541 542 /* Start the next input line. */ 543 544 pos = 0; 545 } 546 547 free(ln.buf); 548 return 1; 549 } 550 551 static int 552 read_whole_file(struct mparse *curp, const char *file, int fd, 553 struct buf *fb, int *with_mmap) 554 { 555 struct stat st; 556 gzFile gz; 557 size_t off; 558 ssize_t ssz; 559 560 if (fstat(fd, &st) == -1) { 561 mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0, 562 "fstat: %s", strerror(errno)); 563 return 0; 564 } 565 566 /* 567 * If we're a regular file, try just reading in the whole entry 568 * via mmap(). This is faster than reading it into blocks, and 569 * since each file is only a few bytes to begin with, I'm not 570 * concerned that this is going to tank any machines. 571 */ 572 573 if (curp->gzip == 0 && S_ISREG(st.st_mode)) { 574 if (st.st_size > 0x7fffffff) { 575 mandoc_msg(MANDOCERR_TOOLARGE, curp, 0, 0, NULL); 576 return 0; 577 } 578 *with_mmap = 1; 579 fb->sz = (size_t)st.st_size; 580 fb->buf = mmap(NULL, fb->sz, PROT_READ, MAP_SHARED, fd, 0); 581 if (fb->buf != MAP_FAILED) 582 return 1; 583 } 584 585 if (curp->gzip) { 586 if ((gz = gzdopen(fd, "rb")) == NULL) { 587 mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0, 588 "gzdopen: %s", strerror(errno)); 589 return 0; 590 } 591 } else 592 gz = NULL; 593 594 /* 595 * If this isn't a regular file (like, say, stdin), then we must 596 * go the old way and just read things in bit by bit. 597 */ 598 599 *with_mmap = 0; 600 off = 0; 601 fb->sz = 0; 602 fb->buf = NULL; 603 for (;;) { 604 if (off == fb->sz) { 605 if (fb->sz == (1U << 31)) { 606 mandoc_msg(MANDOCERR_TOOLARGE, curp, 607 0, 0, NULL); 608 break; 609 } 610 resize_buf(fb, 65536); 611 } 612 ssz = curp->gzip ? 613 gzread(gz, fb->buf + (int)off, fb->sz - off) : 614 read(fd, fb->buf + (int)off, fb->sz - off); 615 if (ssz == 0) { 616 fb->sz = off; 617 return 1; 618 } 619 if (ssz == -1) { 620 mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0, 621 "read: %s", strerror(errno)); 622 break; 623 } 624 off += (size_t)ssz; 625 } 626 627 free(fb->buf); 628 fb->buf = NULL; 629 return 0; 630 } 631 632 static void 633 mparse_end(struct mparse *curp) 634 { 635 if (curp->man->macroset == MACROSET_NONE) 636 curp->man->macroset = MACROSET_MAN; 637 if (curp->man->macroset == MACROSET_MDOC) 638 mdoc_endparse(curp->man); 639 else 640 man_endparse(curp->man); 641 roff_endparse(curp->roff); 642 } 643 644 static void 645 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file) 646 { 647 struct buf *svprimary; 648 const char *svfile; 649 size_t offset; 650 static int recursion_depth; 651 652 if (64 < recursion_depth) { 653 mandoc_msg(MANDOCERR_ROFFLOOP, curp, curp->line, 0, NULL); 654 return; 655 } 656 657 /* Line number is per-file. */ 658 svfile = curp->file; 659 curp->file = file; 660 svprimary = curp->primary; 661 curp->primary = &blk; 662 curp->line = 1; 663 recursion_depth++; 664 665 /* Skip an UTF-8 byte order mark. */ 666 if (curp->filenc & MPARSE_UTF8 && blk.sz > 2 && 667 (unsigned char)blk.buf[0] == 0xef && 668 (unsigned char)blk.buf[1] == 0xbb && 669 (unsigned char)blk.buf[2] == 0xbf) { 670 offset = 3; 671 curp->filenc &= ~MPARSE_LATIN1; 672 } else 673 offset = 0; 674 675 mparse_buf_r(curp, blk, offset, 1); 676 677 if (--recursion_depth == 0) 678 mparse_end(curp); 679 680 curp->primary = svprimary; 681 curp->file = svfile; 682 } 683 684 enum mandoclevel 685 mparse_readmem(struct mparse *curp, void *buf, size_t len, 686 const char *file) 687 { 688 struct buf blk; 689 690 blk.buf = buf; 691 blk.sz = len; 692 693 mparse_parse_buffer(curp, blk, file); 694 return curp->file_status; 695 } 696 697 /* 698 * Read the whole file into memory and call the parsers. 699 * Called recursively when an .so request is encountered. 700 */ 701 enum mandoclevel 702 mparse_readfd(struct mparse *curp, int fd, const char *file) 703 { 704 struct buf blk; 705 int with_mmap; 706 int save_filenc; 707 708 if (read_whole_file(curp, file, fd, &blk, &with_mmap)) { 709 save_filenc = curp->filenc; 710 curp->filenc = curp->options & 711 (MPARSE_UTF8 | MPARSE_LATIN1); 712 mparse_parse_buffer(curp, blk, file); 713 curp->filenc = save_filenc; 714 if (with_mmap) 715 munmap(blk.buf, blk.sz); 716 else 717 free(blk.buf); 718 } 719 return curp->file_status; 720 } 721 722 int 723 mparse_open(struct mparse *curp, const char *file) 724 { 725 char *cp; 726 int fd; 727 728 curp->file = file; 729 cp = strrchr(file, '.'); 730 curp->gzip = (cp != NULL && ! strcmp(cp + 1, "gz")); 731 732 /* First try to use the filename as it is. */ 733 734 if ((fd = open(file, O_RDONLY)) != -1) 735 return fd; 736 737 /* 738 * If that doesn't work and the filename doesn't 739 * already end in .gz, try appending .gz. 740 */ 741 742 if ( ! curp->gzip) { 743 mandoc_asprintf(&cp, "%s.gz", file); 744 fd = open(cp, O_RDONLY); 745 free(cp); 746 if (fd != -1) { 747 curp->gzip = 1; 748 return fd; 749 } 750 } 751 752 /* Neither worked, give up. */ 753 754 mandoc_msg(MANDOCERR_FILE, curp, 0, 0, strerror(errno)); 755 return -1; 756 } 757 758 struct mparse * 759 mparse_alloc(int options, enum mandocerr mmin, mandocmsg mmsg, 760 enum mandoc_os os_e, const char *os_s) 761 { 762 struct mparse *curp; 763 764 curp = mandoc_calloc(1, sizeof(struct mparse)); 765 766 curp->options = options; 767 curp->mmin = mmin; 768 curp->mmsg = mmsg; 769 curp->os_s = os_s; 770 771 curp->roff = roff_alloc(curp, options); 772 curp->man = roff_man_alloc(curp->roff, curp, curp->os_s, 773 curp->options & MPARSE_QUICK ? 1 : 0); 774 if (curp->options & MPARSE_MDOC) { 775 curp->man->macroset = MACROSET_MDOC; 776 if (curp->man->mdocmac == NULL) 777 curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX); 778 } else if (curp->options & MPARSE_MAN) { 779 curp->man->macroset = MACROSET_MAN; 780 if (curp->man->manmac == NULL) 781 curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX); 782 } 783 curp->man->first->tok = TOKEN_NONE; 784 curp->man->meta.os_e = os_e; 785 return curp; 786 } 787 788 void 789 mparse_reset(struct mparse *curp) 790 { 791 roff_reset(curp->roff); 792 roff_man_reset(curp->man); 793 794 free(curp->sodest); 795 curp->sodest = NULL; 796 797 if (curp->secondary) 798 curp->secondary->sz = 0; 799 800 curp->file_status = MANDOCLEVEL_OK; 801 curp->gzip = 0; 802 } 803 804 void 805 mparse_free(struct mparse *curp) 806 { 807 808 roffhash_free(curp->man->mdocmac); 809 roffhash_free(curp->man->manmac); 810 roff_man_free(curp->man); 811 roff_free(curp->roff); 812 if (curp->secondary) 813 free(curp->secondary->buf); 814 815 free(curp->secondary); 816 free(curp->sodest); 817 free(curp); 818 } 819 820 void 821 mparse_result(struct mparse *curp, struct roff_man **man, 822 char **sodest) 823 { 824 825 if (sodest && NULL != (*sodest = curp->sodest)) { 826 *man = NULL; 827 return; 828 } 829 if (man) 830 *man = curp->man; 831 } 832 833 void 834 mparse_updaterc(struct mparse *curp, enum mandoclevel *rc) 835 { 836 if (curp->file_status > *rc) 837 *rc = curp->file_status; 838 } 839 840 void 841 mandoc_vmsg(enum mandocerr t, struct mparse *m, 842 int ln, int pos, const char *fmt, ...) 843 { 844 char buf[256]; 845 va_list ap; 846 847 va_start(ap, fmt); 848 (void)vsnprintf(buf, sizeof(buf), fmt, ap); 849 va_end(ap); 850 851 mandoc_msg(t, m, ln, pos, buf); 852 } 853 854 void 855 mandoc_msg(enum mandocerr er, struct mparse *m, 856 int ln, int col, const char *msg) 857 { 858 enum mandoclevel level; 859 860 if (er < m->mmin && er != MANDOCERR_FILE) 861 return; 862 863 level = MANDOCLEVEL_UNSUPP; 864 while (er < mandoclimits[level]) 865 level--; 866 867 if (m->mmsg) 868 (*m->mmsg)(er, level, m->file, ln, col, msg); 869 870 if (m->file_status < level) 871 m->file_status = level; 872 } 873 874 const char * 875 mparse_strerror(enum mandocerr er) 876 { 877 878 return mandocerrs[er]; 879 } 880 881 const char * 882 mparse_strlevel(enum mandoclevel lvl) 883 { 884 return mandoclevels[lvl]; 885 } 886 887 void 888 mparse_keep(struct mparse *p) 889 { 890 891 assert(NULL == p->secondary); 892 p->secondary = mandoc_calloc(1, sizeof(struct buf)); 893 } 894 895 const char * 896 mparse_getkeep(const struct mparse *p) 897 { 898 899 assert(p->secondary); 900 return p->secondary->sz ? p->secondary->buf : NULL; 901 } 902