contrib/mdocml/read.c

   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 }