read.c

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