read.c

   1 /*      $Id: read.c,v 1.35 2013/05/30 03:52:59 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010, 2011, 2012, 2013 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #ifdef HAVE_MMAP
  23 # include <sys/stat.h>
  24 # include <sys/mman.h>
  25 #endif
  26
  27 #include <assert.h>
  28 #include <ctype.h>
  29 #include <fcntl.h>
  30 #include <stdarg.h>
  31 #include <stdint.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36
  37 #include "mandoc.h"
  38 #include "libmandoc.h"
  39 #include "mdoc.h"
  40 #include "man.h"
  41 #include "main.h"
  42
  43 #ifndef MAP_FILE
  44 #define MAP_FILE        0
  45 #endif
  46
  47 #define REPARSE_LIMIT   1000
  48
  49 struct  buf {
  50         char             *buf; /* binary input buffer */
  51         size_t            sz; /* size of binary buffer */
  52 };
  53
  54 struct  mparse {
  55         enum mandoclevel  file_status; /* status of current parse */
  56         enum mandoclevel  wlevel; /* ignore messages below this */
  57         int               line; /* line number in the file */
  58         enum mparset      inttype; /* which parser to use */
  59         struct man       *pman; /* persistent man parser */
  60         struct mdoc      *pmdoc; /* persistent mdoc parser */
  61         struct man       *man; /* man parser */
  62         struct mdoc      *mdoc; /* mdoc parser */
  63         struct roff      *roff; /* roff parser (!NULL) */
  64         int               reparse_count; /* finite interp. stack */
  65         mandocmsg         mmsg; /* warning/error message handler */
  66         void             *arg; /* argument to mmsg */
  67         const char       *file;
  68         struct buf       *secondary;
  69         char             *defos; /* default operating system */
  70 };
  71
  72 static  void      resize_buf(struct buf *, size_t);
  73 static  void      mparse_buf_r(struct mparse *, struct buf, int);
  74 static  void      mparse_readfd_r(struct mparse *, int, const char *, int);
  75 static  void      pset(const char *, int, struct mparse *);
  76 static  int       read_whole_file(const char *, int, struct buf *, int *);
  77 static  void      mparse_end(struct mparse *);
  78
  79 static  const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {
  80         MANDOCERR_OK,
  81         MANDOCERR_WARNING,
  82         MANDOCERR_WARNING,
  83         MANDOCERR_ERROR,
  84         MANDOCERR_FATAL,
  85         MANDOCERR_MAX,
  86         MANDOCERR_MAX
  87 };
  88
  89 static  const char * const      mandocerrs[MANDOCERR_MAX] = {
  90         "ok",
  91
  92         "generic warning",
  93
  94         /* related to the prologue */
  95         "no title in document",
  96         "document title should be all caps",
  97         "unknown manual section",
  98         "unknown manual volume or arch",
  99         "date missing, using today's date",
 100         "cannot parse date, using it verbatim",
 101         "prologue macros out of order",
 102         "duplicate prologue macro",
 103         "macro not allowed in prologue",
 104         "macro not allowed in body",
 105
 106         /* related to document structure */
 107         ".so is fragile, better use ln(1)",
 108         "NAME section must come first",
 109         "bad NAME section contents",
 110         "sections out of conventional order",
 111         "duplicate section name",
 112         "section not in conventional manual section",
 113
 114         /* related to macros and nesting */
 115         "skipping obsolete macro",
 116         "skipping paragraph macro",
 117         "moving paragraph macro out of list",
 118         "skipping no-space macro",
 119         "blocks badly nested",
 120         "child violates parent syntax",
 121         "nested displays are not portable",
 122         "already in literal mode",
 123         "line scope broken",
 124
 125         /* related to missing macro arguments */
 126         "skipping empty macro",
 127         "argument count wrong",
 128         "missing display type",
 129         "list type must come first",
 130         "tag lists require a width argument",
 131         "missing font type",
 132         "skipping end of block that is not open",
 133
 134         /* related to bad macro arguments */
 135         "skipping argument",
 136         "duplicate argument",
 137         "duplicate display type",
 138         "duplicate list type",
 139         "unknown AT&T UNIX version",
 140         "bad Boolean value",
 141         "unknown font",
 142         "unknown standard specifier",
 143         "bad width argument",
 144
 145         /* related to plain text */
 146         "blank line in non-literal context",
 147         "tab in non-literal context",
 148         "end of line whitespace",
 149         "bad comment style",
 150         "bad escape sequence",
 151         "unterminated quoted string",
 152
 153         /* related to equations */
 154         "unexpected literal in equation",
 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 the 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         "missing list type",
 192         "line argument(s) will be lost",
 193         "body argument(s) will be lost",
 194
 195         "generic fatal error",
 196
 197         "not a manual",
 198         "column syntax is inconsistent",
 199         "NOT IMPLEMENTED: .Bd -file",
 200         "argument count wrong, violates syntax",
 201         "child violates parent syntax",
 202         "argument count wrong, violates syntax",
 203         "NOT IMPLEMENTED: .so with absolute path or \"..\"",
 204         "no document body",
 205         "no document prologue",
 206         "static buffer exhausted",
 207 };
 208
 209 static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
 210         "SUCCESS",
 211         "RESERVED",
 212         "WARNING",
 213         "ERROR",
 214         "FATAL",
 215         "BADARG",
 216         "SYSERR"
 217 };
 218
 219 static void
 220 resize_buf(struct buf *buf, size_t initial)
 221 {
 222
 223         buf->sz = buf->sz > initial/2 ? 2 * buf->sz : initial;
 224         buf->buf = mandoc_realloc(buf->buf, buf->sz);
 225 }
 226
 227 static void
 228 pset(const char *buf, int pos, struct mparse *curp)
 229 {
 230         int              i;
 231
 232         /*
 233          * Try to intuit which kind of manual parser should be used.  If
 234          * passed in by command-line (-man, -mdoc), then use that
 235          * explicitly.  If passed as -mandoc, then try to guess from the
 236          * line: either skip dot-lines, use -mdoc when finding `.Dt', or
 237          * default to -man, which is more lenient.
 238          *
 239          * Separate out pmdoc/pman from mdoc/man: the first persists
 240          * through all parsers, while the latter is used per-parse.
 241          */
 242
 243         if ('.' == buf[0] || '\'' == buf[0]) {
 244                 for (i = 1; buf[i]; i++)
 245                         if (' ' != buf[i] && '\t' != buf[i])
 246                                 break;
 247                 if ('\0' == buf[i])
 248                         return;
 249         }
 250
 251         switch (curp->inttype) {
 252         case (MPARSE_MDOC):
 253                 if (NULL == curp->pmdoc)
 254                         curp->pmdoc = mdoc_alloc(curp->roff, curp,
 255                                         curp->defos);
 256                 assert(curp->pmdoc);
 257                 curp->mdoc = curp->pmdoc;
 258                 return;
 259         case (MPARSE_MAN):
 260                 if (NULL == curp->pman)
 261                         curp->pman = man_alloc(curp->roff, curp);
 262                 assert(curp->pman);
 263                 curp->man = curp->pman;
 264                 return;
 265         default:
 266                 break;
 267         }
 268
 269         if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
 270                 if (NULL == curp->pmdoc)
 271                         curp->pmdoc = mdoc_alloc(curp->roff, curp,
 272                                         curp->defos);
 273                 assert(curp->pmdoc);
 274                 curp->mdoc = curp->pmdoc;
 275                 return;
 276         }
 277
 278         if (NULL == curp->pman)
 279                 curp->pman = man_alloc(curp->roff, curp);
 280         assert(curp->pman);
 281         curp->man = curp->pman;
 282 }
 283
 284 /*
 285  * Main parse routine for an opened file.  This is called for each
 286  * opened file and simply loops around the full input file, possibly
 287  * nesting (i.e., with `so').
 288  */
 289 static void
 290 mparse_buf_r(struct mparse *curp, struct buf blk, int start)
 291 {
 292         const struct tbl_span   *span;
 293         struct buf       ln;
 294         enum rofferr     rr;
 295         int              i, of, rc;
 296         int              pos; /* byte number in the ln buffer */
 297         int              lnn; /* line number in the real file */
 298         unsigned char    c;
 299
 300         memset(&ln, 0, sizeof(struct buf));
 301
 302         lnn = curp->line;
 303         pos = 0;
 304
 305         for (i = 0; i < (int)blk.sz; ) {
 306                 if (0 == pos && '\0' == blk.buf[i])
 307                         break;
 308
 309                 if (start) {
 310                         curp->line = lnn;
 311                         curp->reparse_count = 0;
 312                 }
 313
 314                 while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) {
 315
 316                         /*
 317                          * When finding an unescaped newline character,
 318                          * leave the character loop to process the line.
 319                          * Skip a preceding carriage return, if any.
 320                          */
 321
 322                         if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz &&
 323                             '\n' == blk.buf[i + 1])
 324                                 ++i;
 325                         if ('\n' == blk.buf[i]) {
 326                                 ++i;
 327                                 ++lnn;
 328                                 break;
 329                         }
 330
 331                         /*
 332                          * Make sure we have space for at least
 333                          * one backslash and one other character
 334                          * and the trailing NUL byte.
 335                          */
 336
 337                         if (pos + 2 >= (int)ln.sz)
 338                                 resize_buf(&ln, 256);
 339
 340                         /*
 341                          * Warn about bogus characters.  If you're using
 342                          * non-ASCII encoding, you're screwing your
 343                          * readers.  Since I'd rather this not happen,
 344                          * I'll be helpful and replace these characters
 345                          * with "?", so we don't display gibberish.
 346                          * Note to manual writers: use special characters.
 347                          */
 348
 349                         c = (unsigned char) blk.buf[i];
 350
 351                         if ( ! (isascii(c) &&
 352                                         (isgraph(c) || isblank(c)))) {
 353                                 mandoc_msg(MANDOCERR_BADCHAR, curp,
 354                                                 curp->line, pos, NULL);
 355                                 i++;
 356                                 ln.buf[pos++] = '?';
 357                                 continue;
 358                         }
 359
 360                         /* Trailing backslash = a plain char. */
 361
 362                         if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
 363                                 ln.buf[pos++] = blk.buf[i++];
 364                                 continue;
 365                         }
 366
 367                         /*
 368                          * Found escape and at least one other character.
 369                          * When it's a newline character, skip it.
 370                          * When there is a carriage return in between,
 371                          * skip that one as well.
 372                          */
 373
 374                         if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz &&
 375                             '\n' == blk.buf[i + 2])
 376                                 ++i;
 377                         if ('\n' == blk.buf[i + 1]) {
 378                                 i += 2;
 379                                 ++lnn;
 380                                 continue;
 381                         }
 382
 383                         if ('"' == blk.buf[i + 1] || '#' == blk.buf[i + 1]) {
 384                                 i += 2;
 385                                 /* Comment, skip to end of line */
 386                                 for (; i < (int)blk.sz; ++i) {
 387                                         if ('\n' == blk.buf[i]) {
 388                                                 ++i;
 389                                                 ++lnn;
 390                                                 break;
 391                                         }
 392                                 }
 393
 394                                 /* Backout trailing whitespaces */
 395                                 for (; pos > 0; --pos) {
 396                                         if (ln.buf[pos - 1] != ' ')
 397                                                 break;
 398                                         if (pos > 2 && ln.buf[pos - 2] == '\\')
 399                                                 break;
 400                                 }
 401                                 break;
 402                         }
 403
 404                         /* Catch escaped bogus characters. */
 405
 406                         c = (unsigned char) blk.buf[i+1];
 407
 408                         if ( ! (isascii(c) &&
 409                                         (isgraph(c) || isblank(c)))) {
 410                                 mandoc_msg(MANDOCERR_BADCHAR, curp,
 411                                                 curp->line, pos, NULL);
 412                                 i += 2;
 413                                 ln.buf[pos++] = '?';
 414                                 continue;
 415                         }
 416
 417                         /* Some other escape sequence, copy & cont. */
 418
 419                         ln.buf[pos++] = blk.buf[i++];
 420                         ln.buf[pos++] = blk.buf[i++];
 421                 }
 422
 423                 if (pos >= (int)ln.sz)
 424                         resize_buf(&ln, 256);
 425
 426                 ln.buf[pos] = '\0';
 427
 428                 /*
 429                  * A significant amount of complexity is contained by
 430                  * the roff preprocessor.  It's line-oriented but can be
 431                  * expressed on one line, so we need at times to
 432                  * readjust our starting point and re-run it.  The roff
 433                  * preprocessor can also readjust the buffers with new
 434                  * data, so we pass them in wholesale.
 435                  */
 436
 437                 of = 0;
 438
 439                 /*
 440                  * Maintain a lookaside buffer of all parsed lines.  We
 441                  * only do this if mparse_keep() has been invoked (the
 442                  * buffer may be accessed with mparse_getkeep()).
 443                  */
 444
 445                 if (curp->secondary) {
 446                         curp->secondary->buf =
 447                                 mandoc_realloc
 448                                 (curp->secondary->buf,
 449                                  curp->secondary->sz + pos + 2);
 450                         memcpy(curp->secondary->buf +
 451                                         curp->secondary->sz,
 452                                         ln.buf, pos);
 453                         curp->secondary->sz += pos;
 454                         curp->secondary->buf
 455                                 [curp->secondary->sz] = '\n';
 456                         curp->secondary->sz++;
 457                         curp->secondary->buf
 458                                 [curp->secondary->sz] = '\0';
 459                 }
 460 rerun:
 461                 rr = roff_parseln
 462                         (curp->roff, curp->line,
 463                          &ln.buf, &ln.sz, of, &of);
 464
 465                 switch (rr) {
 466                 case (ROFF_REPARSE):
 467                         if (REPARSE_LIMIT >= ++curp->reparse_count)
 468                                 mparse_buf_r(curp, ln, 0);
 469                         else
 470                                 mandoc_msg(MANDOCERR_ROFFLOOP, curp,
 471                                         curp->line, pos, NULL);
 472                         pos = 0;
 473                         continue;
 474                 case (ROFF_APPEND):
 475                         pos = (int)strlen(ln.buf);
 476                         continue;
 477                 case (ROFF_RERUN):
 478                         goto rerun;
 479                 case (ROFF_IGN):
 480                         pos = 0;
 481                         continue;
 482                 case (ROFF_ERR):
 483                         assert(MANDOCLEVEL_FATAL <= curp->file_status);
 484                         break;
 485                 case (ROFF_SO):
 486                         /*
 487                          * We remove `so' clauses from our lookaside
 488                          * buffer because we're going to descend into
 489                          * the file recursively.
 490                          */
 491                         if (curp->secondary)
 492                                 curp->secondary->sz -= pos + 1;
 493                         mparse_readfd_r(curp, -1, ln.buf + of, 1);
 494                         if (MANDOCLEVEL_FATAL <= curp->file_status)
 495                                 break;
 496                         pos = 0;
 497                         continue;
 498                 default:
 499                         break;
 500                 }
 501
 502                 /*
 503                  * If we encounter errors in the recursive parse, make
 504                  * sure we don't continue parsing.
 505                  */
 506
 507                 if (MANDOCLEVEL_FATAL <= curp->file_status)
 508                         break;
 509
 510                 /*
 511                  * If input parsers have not been allocated, do so now.
 512                  * We keep these instanced between parsers, but set them
 513                  * locally per parse routine since we can use different
 514                  * parsers with each one.
 515                  */
 516
 517                 if ( ! (curp->man || curp->mdoc))
 518                         pset(ln.buf + of, pos - of, curp);
 519
 520                 /*
 521                  * Lastly, push down into the parsers themselves.  One
 522                  * of these will have already been set in the pset()
 523                  * routine.
 524                  * If libroff returns ROFF_TBL, then add it to the
 525                  * currently open parse.  Since we only get here if
 526                  * there does exist data (see tbl_data.c), we're
 527                  * guaranteed that something's been allocated.
 528                  * Do the same for ROFF_EQN.
 529                  */
 530
 531                 rc = -1;
 532
 533                 if (ROFF_TBL == rr)
 534                         while (NULL != (span = roff_span(curp->roff))) {
 535                                 rc = curp->man ?
 536                                         man_addspan(curp->man, span) :
 537                                         mdoc_addspan(curp->mdoc, span);
 538                                 if (0 == rc)
 539                                         break;
 540                         }
 541                 else if (ROFF_EQN == rr)
 542                         rc = curp->mdoc ?
 543                                 mdoc_addeqn(curp->mdoc,
 544                                         roff_eqn(curp->roff)) :
 545                                 man_addeqn(curp->man,
 546                                         roff_eqn(curp->roff));
 547                 else if (curp->man || curp->mdoc)
 548                         rc = curp->man ?
 549                                 man_parseln(curp->man,
 550                                         curp->line, ln.buf, of) :
 551                                 mdoc_parseln(curp->mdoc,
 552                                         curp->line, ln.buf, of);
 553
 554                 if (0 == rc) {
 555                         assert(MANDOCLEVEL_FATAL <= curp->file_status);
 556                         break;
 557                 }
 558
 559                 /* Temporary buffers typically are not full. */
 560
 561                 if (0 == start && '\0' == blk.buf[i])
 562                         break;
 563
 564                 /* Start the next input line. */
 565
 566                 pos = 0;
 567         }
 568
 569         free(ln.buf);
 570 }
 571
 572 static int
 573 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
 574 {
 575         size_t           off;
 576         ssize_t          ssz;
 577
 578 #ifdef  HAVE_MMAP
 579         struct stat      st;
 580         if (-1 == fstat(fd, &st)) {
 581                 perror(file);
 582                 return(0);
 583         }
 584
 585         /*
 586          * If we're a regular file, try just reading in the whole entry
 587          * via mmap().  This is faster than reading it into blocks, and
 588          * since each file is only a few bytes to begin with, I'm not
 589          * concerned that this is going to tank any machines.
 590          */
 591
 592         if (S_ISREG(st.st_mode)) {
 593                 if (st.st_size >= (1U << 31)) {
 594                         fprintf(stderr, "%s: input too large\n", file);
 595                         return(0);
 596                 }
 597                 *with_mmap = 1;
 598                 fb->sz = (size_t)st.st_size;
 599                 fb->buf = mmap(NULL, fb->sz, PROT_READ,
 600                                 MAP_FILE|MAP_SHARED, fd, 0);
 601                 if (fb->buf != MAP_FAILED)
 602                         return(1);
 603         }
 604 #endif
 605
 606         /*
 607          * If this isn't a regular file (like, say, stdin), then we must
 608          * go the old way and just read things in bit by bit.
 609          */
 610
 611         *with_mmap = 0;
 612         off = 0;
 613         fb->sz = 0;
 614         fb->buf = NULL;
 615         for (;;) {
 616                 if (off == fb->sz) {
 617                         if (fb->sz == (1U << 31)) {
 618                                 fprintf(stderr, "%s: input too large\n", file);
 619                                 break;
 620                         }
 621                         resize_buf(fb, 65536);
 622                 }
 623                 ssz = read(fd, fb->buf + (int)off, fb->sz - off);
 624                 if (ssz == 0) {
 625                         fb->sz = off;
 626                         return(1);
 627                 }
 628                 if (ssz == -1) {
 629                         perror(file);
 630                         break;
 631                 }
 632                 off += (size_t)ssz;
 633         }
 634
 635         free(fb->buf);
 636         fb->buf = NULL;
 637         return(0);
 638 }
 639
 640 static void
 641 mparse_end(struct mparse *curp)
 642 {
 643
 644         if (MANDOCLEVEL_FATAL <= curp->file_status)
 645                 return;
 646
 647         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
 648                 assert(MANDOCLEVEL_FATAL <= curp->file_status);
 649                 return;
 650         }
 651
 652         if (curp->man && ! man_endparse(curp->man)) {
 653                 assert(MANDOCLEVEL_FATAL <= curp->file_status);
 654                 return;
 655         }
 656
 657         if ( ! (curp->man || curp->mdoc)) {
 658                 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL);
 659                 curp->file_status = MANDOCLEVEL_FATAL;
 660                 return;
 661         }
 662
 663         roff_endparse(curp->roff);
 664 }
 665
 666 static void
 667 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file,
 668                 int re)
 669 {
 670         const char      *svfile;
 671
 672         /* Line number is per-file. */
 673         svfile = curp->file;
 674         curp->file = file;
 675         curp->line = 1;
 676
 677         mparse_buf_r(curp, blk, 1);
 678
 679         if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)
 680                 mparse_end(curp);
 681
 682         curp->file = svfile;
 683 }
 684
 685 enum mandoclevel
 686 mparse_readmem(struct mparse *curp, const void *buf, size_t len,
 687                 const char *file)
 688 {
 689         struct buf blk;
 690
 691         blk.buf = UNCONST(buf);
 692         blk.sz = len;
 693
 694         mparse_parse_buffer(curp, blk, file, 0);
 695         return(curp->file_status);
 696 }
 697
 698 static void
 699 mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re)
 700 {
 701         struct buf       blk;
 702         int              with_mmap;
 703
 704         if (-1 == fd)
 705                 if (-1 == (fd = open(file, O_RDONLY, 0))) {
 706                         perror(file);
 707                         curp->file_status = MANDOCLEVEL_SYSERR;
 708                         return;
 709                 }
 710         /*
 711          * Run for each opened file; may be called more than once for
 712          * each full parse sequence if the opened file is nested (i.e.,
 713          * from `so').  Simply sucks in the whole file and moves into
 714          * the parse phase for the file.
 715          */
 716
 717         if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {
 718                 curp->file_status = MANDOCLEVEL_SYSERR;
 719                 return;
 720         }
 721
 722         mparse_parse_buffer(curp, blk, file, re);
 723
 724 #ifdef  HAVE_MMAP
 725         if (with_mmap)
 726                 munmap(blk.buf, blk.sz);
 727         else
 728 #endif
 729                 free(blk.buf);
 730
 731         if (STDIN_FILENO != fd && -1 == close(fd))
 732                 perror(file);
 733 }
 734
 735 enum mandoclevel
 736 mparse_readfd(struct mparse *curp, int fd, const char *file)
 737 {
 738
 739         mparse_readfd_r(curp, fd, file, 0);
 740         return(curp->file_status);
 741 }
 742
 743 struct mparse *
 744 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel,
 745                 mandocmsg mmsg, void *arg, char *defos)
 746 {
 747         struct mparse   *curp;
 748
 749         assert(wlevel <= MANDOCLEVEL_FATAL);
 750
 751         curp = mandoc_calloc(1, sizeof(struct mparse));
 752
 753         curp->wlevel = wlevel;
 754         curp->mmsg = mmsg;
 755         curp->arg = arg;
 756         curp->inttype = inttype;
 757         curp->defos = defos;
 758
 759         curp->roff = roff_alloc(inttype, curp);
 760         return(curp);
 761 }
 762
 763 void
 764 mparse_reset(struct mparse *curp)
 765 {
 766
 767         roff_reset(curp->roff);
 768
 769         if (curp->mdoc)
 770                 mdoc_reset(curp->mdoc);
 771         if (curp->man)
 772                 man_reset(curp->man);
 773         if (curp->secondary)
 774                 curp->secondary->sz = 0;
 775
 776         curp->file_status = MANDOCLEVEL_OK;
 777         curp->mdoc = NULL;
 778         curp->man = NULL;
 779 }
 780
 781 void
 782 mparse_free(struct mparse *curp)
 783 {
 784
 785         if (curp->pmdoc)
 786                 mdoc_free(curp->pmdoc);
 787         if (curp->pman)
 788                 man_free(curp->pman);
 789         if (curp->roff)
 790                 roff_free(curp->roff);
 791         if (curp->secondary)
 792                 free(curp->secondary->buf);
 793
 794         free(curp->secondary);
 795         free(curp);
 796 }
 797
 798 void
 799 mparse_result(struct mparse *curp, struct mdoc **mdoc, struct man **man)
 800 {
 801
 802         if (mdoc)
 803                 *mdoc = curp->mdoc;
 804         if (man)
 805                 *man = curp->man;
 806 }
 807
 808 void
 809 mandoc_vmsg(enum mandocerr t, struct mparse *m,
 810                 int ln, int pos, const char *fmt, ...)
 811 {
 812         char             buf[256];
 813         va_list          ap;
 814
 815         va_start(ap, fmt);
 816         vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
 817         va_end(ap);
 818
 819         mandoc_msg(t, m, ln, pos, buf);
 820 }
 821
 822 void
 823 mandoc_msg(enum mandocerr er, struct mparse *m,
 824                 int ln, int col, const char *msg)
 825 {
 826         enum mandoclevel level;
 827
 828         level = MANDOCLEVEL_FATAL;
 829         while (er < mandoclimits[level])
 830                 level--;
 831
 832         if (level < m->wlevel)
 833                 return;
 834
 835         if (m->mmsg)
 836                 (*m->mmsg)(er, level, m->file, ln, col, msg);
 837
 838         if (m->file_status < level)
 839                 m->file_status = level;
 840 }
 841
 842 const char *
 843 mparse_strerror(enum mandocerr er)
 844 {
 845
 846         return(mandocerrs[er]);
 847 }
 848
 849 const char *
 850 mparse_strlevel(enum mandoclevel lvl)
 851 {
 852         return(mandoclevels[lvl]);
 853 }
 854
 855 void
 856 mparse_keep(struct mparse *p)
 857 {
 858
 859         assert(NULL == p->secondary);
 860         p->secondary = mandoc_calloc(1, sizeof(struct buf));
 861 }
 862
 863 const char *
 864 mparse_getkeep(const struct mparse *p)
 865 {
 866
 867         assert(p->secondary);
 868         return(p->secondary->sz ? p->secondary->buf : NULL);
 869 }