read.c

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