read.c

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