read.c

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