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