read.c

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