read.c

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