read.c

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