read.c

   1 /*      $Id: read.c,v 1.31 2012/07/18 11:11:12 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         "date missing, using today's date",
  99         "cannot parse date, using it verbatim",
 100         "prologue macros out of order",
 101         "duplicate prologue macro",
 102         "macro not allowed in prologue",
 103         "macro not allowed in body",
 104
 105         /* related to document structure */
 106         ".so is fragile, better use ln(1)",
 107         "NAME section must come first",
 108         "bad NAME section contents",
 109         "sections out of conventional order",
 110         "duplicate section name",
 111         "section not in conventional manual section",
 112
 113         /* related to macros and nesting */
 114         "skipping obsolete macro",
 115         "skipping paragraph macro",
 116         "moving paragraph macro out of list",
 117         "skipping no-space macro",
 118         "blocks badly nested",
 119         "child violates parent syntax",
 120         "nested displays are not portable",
 121         "already in literal mode",
 122         "line scope broken",
 123
 124         /* related to missing macro arguments */
 125         "skipping empty macro",
 126         "argument count wrong",
 127         "missing display type",
 128         "list type must come first",
 129         "tag lists require a width argument",
 130         "missing font type",
 131         "skipping end of block that is not open",
 132
 133         /* related to bad macro arguments */
 134         "skipping argument",
 135         "duplicate argument",
 136         "duplicate display type",
 137         "duplicate list type",
 138         "unknown AT&T UNIX version",
 139         "bad Boolean value",
 140         "unknown font",
 141         "unknown standard specifier",
 142         "bad width argument",
 143
 144         /* related to plain text */
 145         "blank line in non-literal context",
 146         "tab in non-literal context",
 147         "end of line whitespace",
 148         "bad comment style",
 149         "bad escape sequence",
 150         "unterminated quoted string",
 151
 152         /* related to equations */
 153         "unexpected literal in equation",
 154
 155         "generic error",
 156
 157         /* related to equations */
 158         "unexpected equation scope closure",
 159         "equation scope open on exit",
 160         "overlapping equation scopes",
 161         "unexpected end of equation",
 162         "equation syntax error",
 163
 164         /* related to tables */
 165         "bad table syntax",
 166         "bad table option",
 167         "bad table layout",
 168         "no table layout cells specified",
 169         "no table data cells specified",
 170         "ignore data in cell",
 171         "data block still open",
 172         "ignoring extra data cells",
 173
 174         "input stack limit exceeded, infinite loop?",
 175         "skipping bad character",
 176         "escaped character not allowed in a name",
 177         "manual name not yet set",
 178         "skipping text before the first section header",
 179         "skipping unknown macro",
 180         "NOT IMPLEMENTED, please use groff: skipping request",
 181         "argument count wrong",
 182         "skipping end of block that is not open",
 183         "missing end of block",
 184         "scope open on exit",
 185         "uname(3) system call failed",
 186         "macro requires line argument(s)",
 187         "macro requires body argument(s)",
 188         "macro requires argument(s)",
 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                          * Warn about bogus characters.  If you're using
 331                          * non-ASCII encoding, you're screwing your
 332                          * readers.  Since I'd rather this not happen,
 333                          * I'll be helpful and replace these characters
 334                          * with "?", so we don't display gibberish.
 335                          * Note to manual writers: use special characters.
 336                          */
 337
 338                         c = (unsigned char) blk.buf[i];
 339
 340                         if ( ! (isascii(c) &&
 341                                         (isgraph(c) || isblank(c)))) {
 342                                 mandoc_msg(MANDOCERR_BADCHAR, curp,
 343                                                 curp->line, pos, NULL);
 344                                 i++;
 345                                 if (pos >= (int)ln.sz)
 346                                         resize_buf(&ln, 256);
 347                                 ln.buf[pos++] = '?';
 348                                 continue;
 349                         }
 350
 351                         /* Trailing backslash = a plain char. */
 352
 353                         if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
 354                                 if (pos >= (int)ln.sz)
 355                                         resize_buf(&ln, 256);
 356                                 ln.buf[pos++] = blk.buf[i++];
 357                                 continue;
 358                         }
 359
 360                         /*
 361                          * Found escape and at least one other character.
 362                          * When it's a newline character, skip it.
 363                          * When there is a carriage return in between,
 364                          * skip that one as well.
 365                          */
 366
 367                         if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz &&
 368                             '\n' == blk.buf[i + 2])
 369                                 ++i;
 370                         if ('\n' == blk.buf[i + 1]) {
 371                                 i += 2;
 372                                 ++lnn;
 373                                 continue;
 374                         }
 375
 376                         if ('"' == blk.buf[i + 1] || '#' == blk.buf[i + 1]) {
 377                                 i += 2;
 378                                 /* Comment, skip to end of line */
 379                                 for (; i < (int)blk.sz; ++i) {
 380                                         if ('\n' == blk.buf[i]) {
 381                                                 ++i;
 382                                                 ++lnn;
 383                                                 break;
 384                                         }
 385                                 }
 386
 387                                 /* Backout trailing whitespaces */
 388                                 for (; pos > 0; --pos) {
 389                                         if (ln.buf[pos - 1] != ' ')
 390                                                 break;
 391                                         if (pos > 2 && ln.buf[pos - 2] == '\\')
 392                                                 break;
 393                                 }
 394                                 break;
 395                         }
 396
 397                         /* Some other escape sequence, copy & cont. */
 398
 399                         if (pos + 1 >= (int)ln.sz)
 400                                 resize_buf(&ln, 256);
 401
 402                         ln.buf[pos++] = blk.buf[i++];
 403                         ln.buf[pos++] = blk.buf[i++];
 404                 }
 405
 406                 if (pos >= (int)ln.sz)
 407                         resize_buf(&ln, 256);
 408
 409                 ln.buf[pos] = '\0';
 410
 411                 /*
 412                  * A significant amount of complexity is contained by
 413                  * the roff preprocessor.  It's line-oriented but can be
 414                  * expressed on one line, so we need at times to
 415                  * readjust our starting point and re-run it.  The roff
 416                  * preprocessor can also readjust the buffers with new
 417                  * data, so we pass them in wholesale.
 418                  */
 419
 420                 of = 0;
 421
 422                 /*
 423                  * Maintain a lookaside buffer of all parsed lines.  We
 424                  * only do this if mparse_keep() has been invoked (the
 425                  * buffer may be accessed with mparse_getkeep()).
 426                  */
 427
 428                 if (curp->secondary) {
 429                         curp->secondary->buf =
 430                                 mandoc_realloc
 431                                 (curp->secondary->buf,
 432                                  curp->secondary->sz + pos + 2);
 433                         memcpy(curp->secondary->buf +
 434                                         curp->secondary->sz,
 435                                         ln.buf, pos);
 436                         curp->secondary->sz += pos;
 437                         curp->secondary->buf
 438                                 [curp->secondary->sz] = '\n';
 439                         curp->secondary->sz++;
 440                         curp->secondary->buf
 441                                 [curp->secondary->sz] = '\0';
 442                 }
 443 rerun:
 444                 rr = roff_parseln
 445                         (curp->roff, curp->line,
 446                          &ln.buf, &ln.sz, of, &of);
 447
 448                 switch (rr) {
 449                 case (ROFF_REPARSE):
 450                         if (REPARSE_LIMIT >= ++curp->reparse_count)
 451                                 mparse_buf_r(curp, ln, 0);
 452                         else
 453                                 mandoc_msg(MANDOCERR_ROFFLOOP, curp,
 454                                         curp->line, pos, NULL);
 455                         pos = 0;
 456                         continue;
 457                 case (ROFF_APPEND):
 458                         pos = (int)strlen(ln.buf);
 459                         continue;
 460                 case (ROFF_RERUN):
 461                         goto rerun;
 462                 case (ROFF_IGN):
 463                         pos = 0;
 464                         continue;
 465                 case (ROFF_ERR):
 466                         assert(MANDOCLEVEL_FATAL <= curp->file_status);
 467                         break;
 468                 case (ROFF_SO):
 469                         /*
 470                          * We remove `so' clauses from our lookaside
 471                          * buffer because we're going to descend into
 472                          * the file recursively.
 473                          */
 474                         if (curp->secondary)
 475                                 curp->secondary->sz -= pos + 1;
 476                         mparse_readfd_r(curp, -1, ln.buf + of, 1);
 477                         if (MANDOCLEVEL_FATAL <= curp->file_status)
 478                                 break;
 479                         pos = 0;
 480                         continue;
 481                 default:
 482                         break;
 483                 }
 484
 485                 /*
 486                  * If we encounter errors in the recursive parse, make
 487                  * sure we don't continue parsing.
 488                  */
 489
 490                 if (MANDOCLEVEL_FATAL <= curp->file_status)
 491                         break;
 492
 493                 /*
 494                  * If input parsers have not been allocated, do so now.
 495                  * We keep these instanced between parsers, but set them
 496                  * locally per parse routine since we can use different
 497                  * parsers with each one.
 498                  */
 499
 500                 if ( ! (curp->man || curp->mdoc))
 501                         pset(ln.buf + of, pos - of, curp);
 502
 503                 /*
 504                  * Lastly, push down into the parsers themselves.  One
 505                  * of these will have already been set in the pset()
 506                  * routine.
 507                  * If libroff returns ROFF_TBL, then add it to the
 508                  * currently open parse.  Since we only get here if
 509                  * there does exist data (see tbl_data.c), we're
 510                  * guaranteed that something's been allocated.
 511                  * Do the same for ROFF_EQN.
 512                  */
 513
 514                 rc = -1;
 515
 516                 if (ROFF_TBL == rr)
 517                         while (NULL != (span = roff_span(curp->roff))) {
 518                                 rc = curp->man ?
 519                                         man_addspan(curp->man, span) :
 520                                         mdoc_addspan(curp->mdoc, span);
 521                                 if (0 == rc)
 522                                         break;
 523                         }
 524                 else if (ROFF_EQN == rr)
 525                         rc = curp->mdoc ?
 526                                 mdoc_addeqn(curp->mdoc,
 527                                         roff_eqn(curp->roff)) :
 528                                 man_addeqn(curp->man,
 529                                         roff_eqn(curp->roff));
 530                 else if (curp->man || curp->mdoc)
 531                         rc = curp->man ?
 532                                 man_parseln(curp->man,
 533                                         curp->line, ln.buf, of) :
 534                                 mdoc_parseln(curp->mdoc,
 535                                         curp->line, ln.buf, of);
 536
 537                 if (0 == rc) {
 538                         assert(MANDOCLEVEL_FATAL <= curp->file_status);
 539                         break;
 540                 }
 541
 542                 /* Temporary buffers typically are not full. */
 543
 544                 if (0 == start && '\0' == blk.buf[i])
 545                         break;
 546
 547                 /* Start the next input line. */
 548
 549                 pos = 0;
 550         }
 551
 552         free(ln.buf);
 553 }
 554
 555 static int
 556 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
 557 {
 558         size_t           off;
 559         ssize_t          ssz;
 560
 561 #ifdef  HAVE_MMAP
 562         struct stat      st;
 563         if (-1 == fstat(fd, &st)) {
 564                 perror(file);
 565                 return(0);
 566         }
 567
 568         /*
 569          * If we're a regular file, try just reading in the whole entry
 570          * via mmap().  This is faster than reading it into blocks, and
 571          * since each file is only a few bytes to begin with, I'm not
 572          * concerned that this is going to tank any machines.
 573          */
 574
 575         if (S_ISREG(st.st_mode)) {
 576                 if (st.st_size >= (1U << 31)) {
 577                         fprintf(stderr, "%s: input too large\n", file);
 578                         return(0);
 579                 }
 580                 *with_mmap = 1;
 581                 fb->sz = (size_t)st.st_size;
 582                 fb->buf = mmap(NULL, fb->sz, PROT_READ,
 583                                 MAP_FILE|MAP_SHARED, fd, 0);
 584                 if (fb->buf != MAP_FAILED)
 585                         return(1);
 586         }
 587 #endif
 588
 589         /*
 590          * If this isn't a regular file (like, say, stdin), then we must
 591          * go the old way and just read things in bit by bit.
 592          */
 593
 594         *with_mmap = 0;
 595         off = 0;
 596         fb->sz = 0;
 597         fb->buf = NULL;
 598         for (;;) {
 599                 if (off == fb->sz) {
 600                         if (fb->sz == (1U << 31)) {
 601                                 fprintf(stderr, "%s: input too large\n", file);
 602                                 break;
 603                         }
 604                         resize_buf(fb, 65536);
 605                 }
 606                 ssz = read(fd, fb->buf + (int)off, fb->sz - off);
 607                 if (ssz == 0) {
 608                         fb->sz = off;
 609                         return(1);
 610                 }
 611                 if (ssz == -1) {
 612                         perror(file);
 613                         break;
 614                 }
 615                 off += (size_t)ssz;
 616         }
 617
 618         free(fb->buf);
 619         fb->buf = NULL;
 620         return(0);
 621 }
 622
 623 static void
 624 mparse_end(struct mparse *curp)
 625 {
 626
 627         if (MANDOCLEVEL_FATAL <= curp->file_status)
 628                 return;
 629
 630         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
 631                 assert(MANDOCLEVEL_FATAL <= curp->file_status);
 632                 return;
 633         }
 634
 635         if (curp->man && ! man_endparse(curp->man)) {
 636                 assert(MANDOCLEVEL_FATAL <= curp->file_status);
 637                 return;
 638         }
 639
 640         if ( ! (curp->man || curp->mdoc)) {
 641                 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL);
 642                 curp->file_status = MANDOCLEVEL_FATAL;
 643                 return;
 644         }
 645
 646         roff_endparse(curp->roff);
 647 }
 648
 649 static void
 650 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file,
 651                 int re)
 652 {
 653         const char      *svfile;
 654
 655         /* Line number is per-file. */
 656         svfile = curp->file;
 657         curp->file = file;
 658         curp->line = 1;
 659
 660         mparse_buf_r(curp, blk, 1);
 661
 662         if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)
 663                 mparse_end(curp);
 664
 665         curp->file = svfile;
 666 }
 667
 668 enum mandoclevel
 669 mparse_readmem(struct mparse *curp, const void *buf, size_t len,
 670                 const char *file)
 671 {
 672         struct buf blk;
 673
 674         blk.buf = UNCONST(buf);
 675         blk.sz = len;
 676
 677         mparse_parse_buffer(curp, blk, file, 0);
 678         return(curp->file_status);
 679 }
 680
 681 static void
 682 mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re)
 683 {
 684         struct buf       blk;
 685         int              with_mmap;
 686
 687         if (-1 == fd)
 688                 if (-1 == (fd = open(file, O_RDONLY, 0))) {
 689                         perror(file);
 690                         curp->file_status = MANDOCLEVEL_SYSERR;
 691                         return;
 692                 }
 693         /*
 694          * Run for each opened file; may be called more than once for
 695          * each full parse sequence if the opened file is nested (i.e.,
 696          * from `so').  Simply sucks in the whole file and moves into
 697          * the parse phase for the file.
 698          */
 699
 700         if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {
 701                 curp->file_status = MANDOCLEVEL_SYSERR;
 702                 return;
 703         }
 704
 705         mparse_parse_buffer(curp, blk, file, re);
 706
 707 #ifdef  HAVE_MMAP
 708         if (with_mmap)
 709                 munmap(blk.buf, blk.sz);
 710         else
 711 #endif
 712                 free(blk.buf);
 713
 714         if (STDIN_FILENO != fd && -1 == close(fd))
 715                 perror(file);
 716 }
 717
 718 enum mandoclevel
 719 mparse_readfd(struct mparse *curp, int fd, const char *file)
 720 {
 721
 722         mparse_readfd_r(curp, fd, file, 0);
 723         return(curp->file_status);
 724 }
 725
 726 struct mparse *
 727 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel,
 728                 mandocmsg mmsg, void *arg, char *defos)
 729 {
 730         struct mparse   *curp;
 731
 732         assert(wlevel <= MANDOCLEVEL_FATAL);
 733
 734         curp = mandoc_calloc(1, sizeof(struct mparse));
 735
 736         curp->wlevel = wlevel;
 737         curp->mmsg = mmsg;
 738         curp->arg = arg;
 739         curp->inttype = inttype;
 740         curp->defos = defos;
 741
 742         curp->roff = roff_alloc(curp);
 743         return(curp);
 744 }
 745
 746 void
 747 mparse_reset(struct mparse *curp)
 748 {
 749
 750         roff_reset(curp->roff);
 751
 752         if (curp->mdoc)
 753                 mdoc_reset(curp->mdoc);
 754         if (curp->man)
 755                 man_reset(curp->man);
 756         if (curp->secondary)
 757                 curp->secondary->sz = 0;
 758
 759         curp->file_status = MANDOCLEVEL_OK;
 760         curp->mdoc = NULL;
 761         curp->man = NULL;
 762 }
 763
 764 void
 765 mparse_free(struct mparse *curp)
 766 {
 767
 768         if (curp->pmdoc)
 769                 mdoc_free(curp->pmdoc);
 770         if (curp->pman)
 771                 man_free(curp->pman);
 772         if (curp->roff)
 773                 roff_free(curp->roff);
 774         if (curp->secondary)
 775                 free(curp->secondary->buf);
 776
 777         free(curp->secondary);
 778         free(curp);
 779 }
 780
 781 void
 782 mparse_result(struct mparse *curp, struct mdoc **mdoc, struct man **man)
 783 {
 784
 785         if (mdoc)
 786                 *mdoc = curp->mdoc;
 787         if (man)
 788                 *man = curp->man;
 789 }
 790
 791 void
 792 mandoc_vmsg(enum mandocerr t, struct mparse *m,
 793                 int ln, int pos, const char *fmt, ...)
 794 {
 795         char             buf[256];
 796         va_list          ap;
 797
 798         va_start(ap, fmt);
 799         vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
 800         va_end(ap);
 801
 802         mandoc_msg(t, m, ln, pos, buf);
 803 }
 804
 805 void
 806 mandoc_msg(enum mandocerr er, struct mparse *m,
 807                 int ln, int col, const char *msg)
 808 {
 809         enum mandoclevel level;
 810
 811         level = MANDOCLEVEL_FATAL;
 812         while (er < mandoclimits[level])
 813                 level--;
 814
 815         if (level < m->wlevel)
 816                 return;
 817
 818         if (m->mmsg)
 819                 (*m->mmsg)(er, level, m->file, ln, col, msg);
 820
 821         if (m->file_status < level)
 822                 m->file_status = level;
 823 }
 824
 825 const char *
 826 mparse_strerror(enum mandocerr er)
 827 {
 828
 829         return(mandocerrs[er]);
 830 }
 831
 832 const char *
 833 mparse_strlevel(enum mandoclevel lvl)
 834 {
 835         return(mandoclevels[lvl]);
 836 }
 837
 838 void
 839 mparse_keep(struct mparse *p)
 840 {
 841
 842         assert(NULL == p->secondary);
 843         p->secondary = mandoc_calloc(1, sizeof(struct buf));
 844 }
 845
 846 const char *
 847 mparse_getkeep(const struct mparse *p)
 848 {
 849
 850         assert(p->secondary);
 851         return(p->secondary->sz ? p->secondary->buf : NULL);
 852 }