1 /* $Id: read.c,v 1.39 2013/09/16 00:25:07 schwarze Exp $ */ 2 /* 3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv> 4 * Copyright (c) 2010, 2011, 2012, 2013 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 AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 #ifdef HAVE_CONFIG_H 19 #include "config.h" 20 #endif 21 22 #ifdef HAVE_MMAP 23 # include <sys/stat.h> 24 # include <sys/mman.h> 25 #endif 26 27 #include <assert.h> 28 #include <ctype.h> 29 #include <fcntl.h> 30 #include <stdarg.h> 31 #include <stdint.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <unistd.h> 36 37 #include "mandoc.h" 38 #include "libmandoc.h" 39 #include "mdoc.h" 40 #include "man.h" 41 #include "main.h" 42 43 #define REPARSE_LIMIT 1000 44 45 struct buf { 46 char *buf; /* binary input buffer */ 47 size_t sz; /* size of binary buffer */ 48 }; 49 50 struct mparse { 51 enum mandoclevel file_status; /* status of current parse */ 52 enum mandoclevel wlevel; /* ignore messages below this */ 53 int line; /* line number in the file */ 54 enum mparset inttype; /* which parser to use */ 55 struct man *pman; /* persistent man parser */ 56 struct mdoc *pmdoc; /* persistent mdoc parser */ 57 struct man *man; /* man parser */ 58 struct mdoc *mdoc; /* mdoc parser */ 59 struct roff *roff; /* roff parser (!NULL) */ 60 int reparse_count; /* finite interp. stack */ 61 mandocmsg mmsg; /* warning/error message handler */ 62 void *arg; /* argument to mmsg */ 63 const char *file; 64 struct buf *secondary; 65 char *defos; /* default operating system */ 66 }; 67 68 static void resize_buf(struct buf *, size_t); 69 static void mparse_buf_r(struct mparse *, struct buf, int); 70 static void pset(const char *, int, struct mparse *); 71 static int read_whole_file(const char *, int, struct buf *, int *); 72 static void mparse_end(struct mparse *); 73 static void mparse_parse_buffer(struct mparse *, struct buf, 74 const char *); 75 76 static const enum mandocerr mandoclimits[MANDOCLEVEL_MAX] = { 77 MANDOCERR_OK, 78 MANDOCERR_WARNING, 79 MANDOCERR_WARNING, 80 MANDOCERR_ERROR, 81 MANDOCERR_FATAL, 82 MANDOCERR_MAX, 83 MANDOCERR_MAX 84 }; 85 86 static const char * const mandocerrs[MANDOCERR_MAX] = { 87 "ok", 88 89 "generic warning", 90 91 /* related to the prologue */ 92 "no title in document", 93 "document title should be all caps", 94 "unknown manual section", 95 "unknown manual volume or arch", 96 "date missing, using today's date", 97 "cannot parse date, using it verbatim", 98 "prologue macros out of order", 99 "duplicate prologue macro", 100 "macro not allowed in prologue", 101 "macro not allowed in body", 102 103 /* related to document structure */ 104 ".so is fragile, better use ln(1)", 105 "NAME section must come first", 106 "bad NAME section contents", 107 "sections out of conventional order", 108 "duplicate section name", 109 "section header suited to sections 2, 3, and 9 only", 110 111 /* related to macros and nesting */ 112 "skipping obsolete macro", 113 "skipping paragraph macro", 114 "moving paragraph macro out of list", 115 "skipping no-space macro", 116 "blocks badly nested", 117 "child violates parent syntax", 118 "nested displays are not portable", 119 "already in literal mode", 120 "line scope broken", 121 122 /* related to missing macro arguments */ 123 "skipping empty macro", 124 "argument count wrong", 125 "missing display type", 126 "list type must come first", 127 "tag lists require a width argument", 128 "missing font type", 129 "skipping end of block that is not open", 130 131 /* related to bad macro arguments */ 132 "skipping argument", 133 "duplicate argument", 134 "duplicate display type", 135 "duplicate list type", 136 "unknown AT&T UNIX version", 137 "bad Boolean value", 138 "unknown font", 139 "unknown standard specifier", 140 "bad width argument", 141 142 /* related to plain text */ 143 "blank line in non-literal context", 144 "tab in non-literal context", 145 "end of line whitespace", 146 "bad comment style", 147 "bad escape sequence", 148 "unterminated quoted string", 149 150 /* related to equations */ 151 "unexpected literal in equation", 152 153 "generic error", 154 155 /* related to equations */ 156 "unexpected equation scope closure", 157 "equation scope open on exit", 158 "overlapping equation scopes", 159 "unexpected end of equation", 160 "equation syntax error", 161 162 /* related to tables */ 163 "bad table syntax", 164 "bad table option", 165 "bad table layout", 166 "no table layout cells specified", 167 "no table data cells specified", 168 "ignore data in cell", 169 "data block still open", 170 "ignoring extra data cells", 171 172 "input stack limit exceeded, infinite loop?", 173 "skipping bad character", 174 "escaped character not allowed in a name", 175 "manual name not yet set", 176 "skipping text before the first section header", 177 "skipping unknown macro", 178 "NOT IMPLEMENTED, please use groff: skipping request", 179 "argument count wrong", 180 "skipping column outside column list", 181 "skipping end of block that is not open", 182 "missing end of block", 183 "scope open on exit", 184 "uname(3) system call failed", 185 "macro requires line argument(s)", 186 "macro requires body argument(s)", 187 "macro requires argument(s)", 188 "request requires a numeric argument", 189 "missing list type", 190 "line argument(s) will be lost", 191 "body argument(s) will be lost", 192 193 "generic fatal error", 194 195 "not a manual", 196 "column syntax is inconsistent", 197 "NOT IMPLEMENTED: .Bd -file", 198 "argument count wrong, violates syntax", 199 "child violates parent syntax", 200 "argument count wrong, violates syntax", 201 "NOT IMPLEMENTED: .so with absolute path or \"..\"", 202 "no document body", 203 "no document prologue", 204 "static buffer exhausted", 205 }; 206 207 static const char * const mandoclevels[MANDOCLEVEL_MAX] = { 208 "SUCCESS", 209 "RESERVED", 210 "WARNING", 211 "ERROR", 212 "FATAL", 213 "BADARG", 214 "SYSERR" 215 }; 216 217 static void 218 resize_buf(struct buf *buf, size_t initial) 219 { 220 221 buf->sz = buf->sz > initial/2 ? 2 * buf->sz : initial; 222 buf->buf = mandoc_realloc(buf->buf, buf->sz); 223 } 224 225 static void 226 pset(const char *buf, int pos, struct mparse *curp) 227 { 228 int i; 229 230 /* 231 * Try to intuit which kind of manual parser should be used. If 232 * passed in by command-line (-man, -mdoc), then use that 233 * explicitly. If passed as -mandoc, then try to guess from the 234 * line: either skip dot-lines, use -mdoc when finding `.Dt', or 235 * default to -man, which is more lenient. 236 * 237 * Separate out pmdoc/pman from mdoc/man: the first persists 238 * through all parsers, while the latter is used per-parse. 239 */ 240 241 if ('.' == buf[0] || '\'' == buf[0]) { 242 for (i = 1; buf[i]; i++) 243 if (' ' != buf[i] && '\t' != buf[i]) 244 break; 245 if ('\0' == buf[i]) 246 return; 247 } 248 249 switch (curp->inttype) { 250 case (MPARSE_MDOC): 251 if (NULL == curp->pmdoc) 252 curp->pmdoc = mdoc_alloc(curp->roff, curp, 253 curp->defos); 254 assert(curp->pmdoc); 255 curp->mdoc = curp->pmdoc; 256 return; 257 case (MPARSE_MAN): 258 if (NULL == curp->pman) 259 curp->pman = man_alloc(curp->roff, curp); 260 assert(curp->pman); 261 curp->man = curp->pman; 262 return; 263 default: 264 break; 265 } 266 267 if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3)) { 268 if (NULL == curp->pmdoc) 269 curp->pmdoc = mdoc_alloc(curp->roff, curp, 270 curp->defos); 271 assert(curp->pmdoc); 272 curp->mdoc = curp->pmdoc; 273 return; 274 } 275 276 if (NULL == curp->pman) 277 curp->pman = man_alloc(curp->roff, curp); 278 assert(curp->pman); 279 curp->man = curp->pman; 280 } 281 282 /* 283 * Main parse routine for an opened file. This is called for each 284 * opened file and simply loops around the full input file, possibly 285 * nesting (i.e., with `so'). 286 */ 287 static void 288 mparse_buf_r(struct mparse *curp, struct buf blk, int start) 289 { 290 const struct tbl_span *span; 291 struct buf ln; 292 enum rofferr rr; 293 int i, of, rc; 294 int pos; /* byte number in the ln buffer */ 295 int lnn; /* line number in the real file */ 296 unsigned char c; 297 298 memset(&ln, 0, sizeof(struct buf)); 299 300 lnn = curp->line; 301 pos = 0; 302 303 for (i = 0; i < (int)blk.sz; ) { 304 if (0 == pos && '\0' == blk.buf[i]) 305 break; 306 307 if (start) { 308 curp->line = lnn; 309 curp->reparse_count = 0; 310 } 311 312 while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) { 313 314 /* 315 * When finding an unescaped newline character, 316 * leave the character loop to process the line. 317 * Skip a preceding carriage return, if any. 318 */ 319 320 if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz && 321 '\n' == blk.buf[i + 1]) 322 ++i; 323 if ('\n' == blk.buf[i]) { 324 ++i; 325 ++lnn; 326 break; 327 } 328 329 /* 330 * Make sure we have space for at least 331 * one backslash and one other character 332 * and the trailing NUL byte. 333 */ 334 335 if (pos + 2 >= (int)ln.sz) 336 resize_buf(&ln, 256); 337 338 /* 339 * Warn about bogus characters. If you're using 340 * non-ASCII encoding, you're screwing your 341 * readers. Since I'd rather this not happen, 342 * I'll be helpful and replace these characters 343 * with "?", so we don't display gibberish. 344 * Note to manual writers: use special characters. 345 */ 346 347 c = (unsigned char) blk.buf[i]; 348 349 if ( ! (isascii(c) && 350 (isgraph(c) || isblank(c)))) { 351 mandoc_msg(MANDOCERR_BADCHAR, curp, 352 curp->line, pos, NULL); 353 i++; 354 ln.buf[pos++] = '?'; 355 continue; 356 } 357 358 /* Trailing backslash = a plain char. */ 359 360 if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) { 361 ln.buf[pos++] = blk.buf[i++]; 362 continue; 363 } 364 365 /* 366 * Found escape and at least one other character. 367 * When it's a newline character, skip it. 368 * When there is a carriage return in between, 369 * skip that one as well. 370 */ 371 372 if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz && 373 '\n' == blk.buf[i + 2]) 374 ++i; 375 if ('\n' == blk.buf[i + 1]) { 376 i += 2; 377 ++lnn; 378 continue; 379 } 380 381 if ('"' == blk.buf[i + 1] || '#' == blk.buf[i + 1]) { 382 i += 2; 383 /* Comment, skip to end of line */ 384 for (; i < (int)blk.sz; ++i) { 385 if ('\n' == blk.buf[i]) { 386 ++i; 387 ++lnn; 388 break; 389 } 390 } 391 392 /* Backout trailing whitespaces */ 393 for (; pos > 0; --pos) { 394 if (ln.buf[pos - 1] != ' ') 395 break; 396 if (pos > 2 && ln.buf[pos - 2] == '\\') 397 break; 398 } 399 break; 400 } 401 402 /* Catch escaped bogus characters. */ 403 404 c = (unsigned char) blk.buf[i+1]; 405 406 if ( ! (isascii(c) && 407 (isgraph(c) || isblank(c)))) { 408 mandoc_msg(MANDOCERR_BADCHAR, curp, 409 curp->line, pos, NULL); 410 i += 2; 411 ln.buf[pos++] = '?'; 412 continue; 413 } 414 415 /* Some other escape sequence, copy & cont. */ 416 417 ln.buf[pos++] = blk.buf[i++]; 418 ln.buf[pos++] = blk.buf[i++]; 419 } 420 421 if (pos >= (int)ln.sz) 422 resize_buf(&ln, 256); 423 424 ln.buf[pos] = '\0'; 425 426 /* 427 * A significant amount of complexity is contained by 428 * the roff preprocessor. It's line-oriented but can be 429 * expressed on one line, so we need at times to 430 * readjust our starting point and re-run it. The roff 431 * preprocessor can also readjust the buffers with new 432 * data, so we pass them in wholesale. 433 */ 434 435 of = 0; 436 437 /* 438 * Maintain a lookaside buffer of all parsed lines. We 439 * only do this if mparse_keep() has been invoked (the 440 * buffer may be accessed with mparse_getkeep()). 441 */ 442 443 if (curp->secondary) { 444 curp->secondary->buf = 445 mandoc_realloc 446 (curp->secondary->buf, 447 curp->secondary->sz + pos + 2); 448 memcpy(curp->secondary->buf + 449 curp->secondary->sz, 450 ln.buf, pos); 451 curp->secondary->sz += pos; 452 curp->secondary->buf 453 [curp->secondary->sz] = '\n'; 454 curp->secondary->sz++; 455 curp->secondary->buf 456 [curp->secondary->sz] = '\0'; 457 } 458 rerun: 459 rr = roff_parseln 460 (curp->roff, curp->line, 461 &ln.buf, &ln.sz, of, &of); 462 463 switch (rr) { 464 case (ROFF_REPARSE): 465 if (REPARSE_LIMIT >= ++curp->reparse_count) 466 mparse_buf_r(curp, ln, 0); 467 else 468 mandoc_msg(MANDOCERR_ROFFLOOP, curp, 469 curp->line, pos, NULL); 470 pos = 0; 471 continue; 472 case (ROFF_APPEND): 473 pos = (int)strlen(ln.buf); 474 continue; 475 case (ROFF_RERUN): 476 goto rerun; 477 case (ROFF_IGN): 478 pos = 0; 479 continue; 480 case (ROFF_ERR): 481 assert(MANDOCLEVEL_FATAL <= curp->file_status); 482 break; 483 case (ROFF_SO): 484 /* 485 * We remove `so' clauses from our lookaside 486 * buffer because we're going to descend into 487 * the file recursively. 488 */ 489 if (curp->secondary) 490 curp->secondary->sz -= pos + 1; 491 mparse_readfd(curp, -1, ln.buf + of); 492 if (MANDOCLEVEL_FATAL <= curp->file_status) 493 break; 494 pos = 0; 495 continue; 496 default: 497 break; 498 } 499 500 /* 501 * If we encounter errors in the recursive parse, make 502 * sure we don't continue parsing. 503 */ 504 505 if (MANDOCLEVEL_FATAL <= curp->file_status) 506 break; 507 508 /* 509 * If input parsers have not been allocated, do so now. 510 * We keep these instanced between parsers, but set them 511 * locally per parse routine since we can use different 512 * parsers with each one. 513 */ 514 515 if ( ! (curp->man || curp->mdoc)) 516 pset(ln.buf + of, pos - of, curp); 517 518 /* 519 * Lastly, push down into the parsers themselves. One 520 * of these will have already been set in the pset() 521 * routine. 522 * If libroff returns ROFF_TBL, then add it to the 523 * currently open parse. Since we only get here if 524 * there does exist data (see tbl_data.c), we're 525 * guaranteed that something's been allocated. 526 * Do the same for ROFF_EQN. 527 */ 528 529 rc = -1; 530 531 if (ROFF_TBL == rr) 532 while (NULL != (span = roff_span(curp->roff))) { 533 rc = curp->man ? 534 man_addspan(curp->man, span) : 535 mdoc_addspan(curp->mdoc, span); 536 if (0 == rc) 537 break; 538 } 539 else if (ROFF_EQN == rr) 540 rc = curp->mdoc ? 541 mdoc_addeqn(curp->mdoc, 542 roff_eqn(curp->roff)) : 543 man_addeqn(curp->man, 544 roff_eqn(curp->roff)); 545 else if (curp->man || curp->mdoc) 546 rc = curp->man ? 547 man_parseln(curp->man, 548 curp->line, ln.buf, of) : 549 mdoc_parseln(curp->mdoc, 550 curp->line, ln.buf, of); 551 552 if (0 == rc) { 553 assert(MANDOCLEVEL_FATAL <= curp->file_status); 554 break; 555 } 556 557 /* Temporary buffers typically are not full. */ 558 559 if (0 == start && '\0' == blk.buf[i]) 560 break; 561 562 /* Start the next input line. */ 563 564 pos = 0; 565 } 566 567 free(ln.buf); 568 } 569 570 static int 571 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap) 572 { 573 size_t off; 574 ssize_t ssz; 575 576 #ifdef HAVE_MMAP 577 struct stat st; 578 if (-1 == fstat(fd, &st)) { 579 perror(file); 580 return(0); 581 } 582 583 /* 584 * If we're a regular file, try just reading in the whole entry 585 * via mmap(). This is faster than reading it into blocks, and 586 * since each file is only a few bytes to begin with, I'm not 587 * concerned that this is going to tank any machines. 588 */ 589 590 if (S_ISREG(st.st_mode)) { 591 if (st.st_size >= (1U << 31)) { 592 fprintf(stderr, "%s: input too large\n", file); 593 return(0); 594 } 595 *with_mmap = 1; 596 fb->sz = (size_t)st.st_size; 597 fb->buf = mmap(NULL, fb->sz, PROT_READ, MAP_SHARED, fd, 0); 598 if (fb->buf != MAP_FAILED) 599 return(1); 600 } 601 #endif 602 603 /* 604 * If this isn't a regular file (like, say, stdin), then we must 605 * go the old way and just read things in bit by bit. 606 */ 607 608 *with_mmap = 0; 609 off = 0; 610 fb->sz = 0; 611 fb->buf = NULL; 612 for (;;) { 613 if (off == fb->sz) { 614 if (fb->sz == (1U << 31)) { 615 fprintf(stderr, "%s: input too large\n", file); 616 break; 617 } 618 resize_buf(fb, 65536); 619 } 620 ssz = read(fd, fb->buf + (int)off, fb->sz - off); 621 if (ssz == 0) { 622 fb->sz = off; 623 return(1); 624 } 625 if (ssz == -1) { 626 perror(file); 627 break; 628 } 629 off += (size_t)ssz; 630 } 631 632 free(fb->buf); 633 fb->buf = NULL; 634 return(0); 635 } 636 637 static void 638 mparse_end(struct mparse *curp) 639 { 640 641 if (MANDOCLEVEL_FATAL <= curp->file_status) 642 return; 643 644 if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) { 645 assert(MANDOCLEVEL_FATAL <= curp->file_status); 646 return; 647 } 648 649 if (curp->man && ! man_endparse(curp->man)) { 650 assert(MANDOCLEVEL_FATAL <= curp->file_status); 651 return; 652 } 653 654 if ( ! (curp->man || curp->mdoc)) { 655 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL); 656 curp->file_status = MANDOCLEVEL_FATAL; 657 return; 658 } 659 660 roff_endparse(curp->roff); 661 } 662 663 static void 664 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file) 665 { 666 const char *svfile; 667 static int recursion_depth; 668 669 if (64 < recursion_depth) { 670 mandoc_msg(MANDOCERR_ROFFLOOP, curp, curp->line, 0, NULL); 671 return; 672 } 673 674 /* Line number is per-file. */ 675 svfile = curp->file; 676 curp->file = file; 677 curp->line = 1; 678 recursion_depth++; 679 680 mparse_buf_r(curp, blk, 1); 681 682 if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status) 683 mparse_end(curp); 684 685 curp->file = svfile; 686 } 687 688 enum mandoclevel 689 mparse_readmem(struct mparse *curp, const void *buf, size_t len, 690 const char *file) 691 { 692 struct buf blk; 693 694 blk.buf = UNCONST(buf); 695 blk.sz = len; 696 697 mparse_parse_buffer(curp, blk, file); 698 return(curp->file_status); 699 } 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 707 if (-1 == fd) 708 if (-1 == (fd = open(file, O_RDONLY, 0))) { 709 perror(file); 710 curp->file_status = MANDOCLEVEL_SYSERR; 711 goto out; 712 } 713 /* 714 * Run for each opened file; may be called more than once for 715 * each full parse sequence if the opened file is nested (i.e., 716 * from `so'). Simply sucks in the whole file and moves into 717 * the parse phase for the file. 718 */ 719 720 if ( ! read_whole_file(file, fd, &blk, &with_mmap)) { 721 curp->file_status = MANDOCLEVEL_SYSERR; 722 goto out; 723 } 724 725 mparse_parse_buffer(curp, blk, file); 726 727 #ifdef HAVE_MMAP 728 if (with_mmap) 729 munmap(blk.buf, blk.sz); 730 else 731 #endif 732 free(blk.buf); 733 734 if (STDIN_FILENO != fd && -1 == close(fd)) 735 perror(file); 736 out: 737 return(curp->file_status); 738 } 739 740 struct mparse * 741 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel, 742 mandocmsg mmsg, void *arg, char *defos) 743 { 744 struct mparse *curp; 745 746 assert(wlevel <= MANDOCLEVEL_FATAL); 747 748 curp = mandoc_calloc(1, sizeof(struct mparse)); 749 750 curp->wlevel = wlevel; 751 curp->mmsg = mmsg; 752 curp->arg = arg; 753 curp->inttype = inttype; 754 curp->defos = defos; 755 756 curp->roff = roff_alloc(inttype, curp); 757 return(curp); 758 } 759 760 void 761 mparse_reset(struct mparse *curp) 762 { 763 764 roff_reset(curp->roff); 765 766 if (curp->mdoc) 767 mdoc_reset(curp->mdoc); 768 if (curp->man) 769 man_reset(curp->man); 770 if (curp->secondary) 771 curp->secondary->sz = 0; 772 773 curp->file_status = MANDOCLEVEL_OK; 774 curp->mdoc = NULL; 775 curp->man = NULL; 776 } 777 778 void 779 mparse_free(struct mparse *curp) 780 { 781 782 if (curp->pmdoc) 783 mdoc_free(curp->pmdoc); 784 if (curp->pman) 785 man_free(curp->pman); 786 if (curp->roff) 787 roff_free(curp->roff); 788 if (curp->secondary) 789 free(curp->secondary->buf); 790 791 free(curp->secondary); 792 free(curp); 793 } 794 795 void 796 mparse_result(struct mparse *curp, struct mdoc **mdoc, struct man **man) 797 { 798 799 if (mdoc) 800 *mdoc = curp->mdoc; 801 if (man) 802 *man = curp->man; 803 } 804 805 void 806 mandoc_vmsg(enum mandocerr t, struct mparse *m, 807 int ln, int pos, const char *fmt, ...) 808 { 809 char buf[256]; 810 va_list ap; 811 812 va_start(ap, fmt); 813 vsnprintf(buf, sizeof(buf) - 1, fmt, ap); 814 va_end(ap); 815 816 mandoc_msg(t, m, ln, pos, buf); 817 } 818 819 void 820 mandoc_msg(enum mandocerr er, struct mparse *m, 821 int ln, int col, const char *msg) 822 { 823 enum mandoclevel level; 824 825 level = MANDOCLEVEL_FATAL; 826 while (er < mandoclimits[level]) 827 level--; 828 829 if (level < m->wlevel) 830 return; 831 832 if (m->mmsg) 833 (*m->mmsg)(er, level, m->file, ln, col, msg); 834 835 if (m->file_status < level) 836 m->file_status = level; 837 } 838 839 const char * 840 mparse_strerror(enum mandocerr er) 841 { 842 843 return(mandocerrs[er]); 844 } 845 846 const char * 847 mparse_strlevel(enum mandoclevel lvl) 848 { 849 return(mandoclevels[lvl]); 850 } 851 852 void 853 mparse_keep(struct mparse *p) 854 { 855 856 assert(NULL == p->secondary); 857 p->secondary = mandoc_calloc(1, sizeof(struct buf)); 858 } 859 860 const char * 861 mparse_getkeep(const struct mparse *p) 862 { 863 864 assert(p->secondary); 865 return(p->secondary->sz ? p->secondary->buf : NULL); 866 } 867