contrib/mdocml/read.c

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