read.c

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