read.c

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