read.c

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