read.c

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