read.c

   1 /*      $Id: read.c,v 1.185 2017/07/02 15:31:59 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010-2017 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 AUTHORS DISCLAIM ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS 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 #include "config.h"
  20
  21 #include <sys/types.h>
  22 #include <sys/mman.h>
  23 #include <sys/stat.h>
  24
  25 #include <assert.h>
  26 #include <ctype.h>
  27 #if HAVE_ERR
  28 #include <err.h>
  29 #endif
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <stdarg.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <unistd.h>
  37 #include <zlib.h>
  38
  39 #include "mandoc_aux.h"
  40 #include "mandoc.h"
  41 #include "roff.h"
  42 #include "mdoc.h"
  43 #include "man.h"
  44 #include "libmandoc.h"
  45 #include "roff_int.h"
  46
  47 #define REPARSE_LIMIT   1000
  48
  49 struct  mparse {
  50         struct roff      *roff; /* roff parser (!NULL) */
  51         struct roff_man  *man; /* man parser */
  52         char             *sodest; /* filename pointed to by .so */
  53         const char       *file; /* filename of current input file */
  54         struct buf       *primary; /* buffer currently being parsed */
  55         struct buf       *secondary; /* preprocessed copy of input */
  56         const char       *os_s; /* default operating system */
  57         mandocmsg         mmsg; /* warning/error message handler */
  58         enum mandoclevel  file_status; /* status of current parse */
  59         enum mandocerr    mmin; /* ignore messages below this */
  60         int               options; /* parser options */
  61         int               gzip; /* current input file is gzipped */
  62         int               filenc; /* encoding of the current file */
  63         int               reparse_count; /* finite interp. stack */
  64         int               line; /* line number in the file */
  65 };
  66
  67 static  void      choose_parser(struct mparse *);
  68 static  void      resize_buf(struct buf *, size_t);
  69 static  int       mparse_buf_r(struct mparse *, struct buf, size_t, int);
  70 static  int       read_whole_file(struct mparse *, const char *, int,
  71                                 struct buf *, int *);
  72 static  void      mparse_end(struct mparse *);
  73 static  void      mparse_parse_buffer(struct mparse *, struct buf,
  74                         const char *);
  75
  76 static  const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {
  77         MANDOCERR_OK,
  78         MANDOCERR_STYLE,
  79         MANDOCERR_WARNING,
  80         MANDOCERR_ERROR,
  81         MANDOCERR_UNSUPP,
  82         MANDOCERR_MAX,
  83         MANDOCERR_MAX
  84 };
  85
  86 static  const char * const      mandocerrs[MANDOCERR_MAX] = {
  87         "ok",
  88
  89         "base system convention",
  90
  91         "Mdocdate found",
  92         "Mdocdate missing",
  93         "unknown architecture",
  94         "operating system explicitly specified",
  95         "RCS id missing",
  96         "referenced manual not found",
  97
  98         "generic style suggestion",
  99
 100         "legacy man(7) date format",
 101         "duplicate RCS id",
 102         "typo in section name",
 103         "useless macro",
 104         "consider using OS macro",
 105         "errnos out of order",
 106         "duplicate errno",
 107         "description line ends with a full stop",
 108         "no blank before trailing delimiter",
 109         "function name without markup",
 110
 111         "generic warning",
 112
 113         /* related to the prologue */
 114         "missing manual title, using UNTITLED",
 115         "missing manual title, using \"\"",
 116         "lower case character in document title",
 117         "missing manual section, using \"\"",
 118         "unknown manual section",
 119         "missing date, using today's date",
 120         "cannot parse date, using it verbatim",
 121         "missing Os macro, using \"\"",
 122         "duplicate prologue macro",
 123         "late prologue macro",
 124         "skipping late title macro",
 125         "prologue macros out of order",
 126
 127         /* related to document structure */
 128         ".so is fragile, better use ln(1)",
 129         "no document body",
 130         "content before first section header",
 131         "first section is not \"NAME\"",
 132         "NAME section without Nm before Nd",
 133         "NAME section without description",
 134         "description not at the end of NAME",
 135         "bad NAME section content",
 136         "missing comma before name",
 137         "missing description line, using \"\"",
 138         "description line outside NAME section",
 139         "sections out of conventional order",
 140         "duplicate section title",
 141         "unexpected section",
 142         "cross reference to self",
 143         "unusual Xr order",
 144         "unusual Xr punctuation",
 145         "AUTHORS section without An macro",
 146
 147         /* related to macros and nesting */
 148         "obsolete macro",
 149         "macro neither callable nor escaped",
 150         "skipping paragraph macro",
 151         "moving paragraph macro out of list",
 152         "skipping no-space macro",
 153         "blocks badly nested",
 154         "nested displays are not portable",
 155         "moving content out of list",
 156         "first macro on line",
 157         "fill mode already enabled, skipping",
 158         "fill mode already disabled, skipping",
 159         "line scope broken",
 160         "skipping blank line in line scope",
 161
 162         /* related to missing macro arguments */
 163         "skipping empty request",
 164         "conditional request controls empty scope",
 165         "skipping empty macro",
 166         "empty block",
 167         "empty argument, using 0n",
 168         "missing display type, using -ragged",
 169         "list type is not the first argument",
 170         "missing -width in -tag list, using 6n",
 171         "missing utility name, using \"\"",
 172         "missing function name, using \"\"",
 173         "empty head in list item",
 174         "empty list item",
 175         "missing argument, using next line",
 176         "missing font type, using \\fR",
 177         "unknown font type, using \\fR",
 178         "nothing follows prefix",
 179         "empty reference block",
 180         "missing section argument",
 181         "missing -std argument, adding it",
 182         "missing option string, using \"\"",
 183         "missing resource identifier, using \"\"",
 184         "missing eqn box, using \"\"",
 185
 186         /* related to bad macro arguments */
 187         "unterminated quoted argument",
 188         "duplicate argument",
 189         "skipping duplicate argument",
 190         "skipping duplicate display type",
 191         "skipping duplicate list type",
 192         "skipping -width argument",
 193         "wrong number of cells",
 194         "unknown AT&T UNIX version",
 195         "comma in function argument",
 196         "parenthesis in function name",
 197         "unknown library name",
 198         "invalid content in Rs block",
 199         "invalid Boolean argument",
 200         "unknown font, skipping request",
 201         "odd number of characters in request",
 202
 203         /* related to plain text */
 204         "blank line in fill mode, using .sp",
 205         "tab in filled text",
 206         "whitespace at end of input line",
 207         "new sentence, new line",
 208         "bad comment style",
 209         "invalid escape sequence",
 210         "undefined string, using \"\"",
 211
 212         /* related to tables */
 213         "tbl line starts with span",
 214         "tbl column starts with span",
 215         "skipping vertical bar in tbl layout",
 216
 217         "generic error",
 218
 219         /* related to tables */
 220         "non-alphabetic character in tbl options",
 221         "skipping unknown tbl option",
 222         "missing tbl option argument",
 223         "wrong tbl option argument size",
 224         "empty tbl layout",
 225         "invalid character in tbl layout",
 226         "unmatched parenthesis in tbl layout",
 227         "tbl without any data cells",
 228         "ignoring data in spanned tbl cell",
 229         "ignoring extra tbl data cells",
 230         "data block open at end of tbl",
 231
 232         /* related to document structure and macros */
 233         NULL,
 234         "input stack limit exceeded, infinite loop?",
 235         "skipping bad character",
 236         "skipping unknown macro",
 237         "skipping insecure request",
 238         "skipping item outside list",
 239         "skipping column outside column list",
 240         "skipping end of block that is not open",
 241         "fewer RS blocks open, skipping",
 242         "inserting missing end of block",
 243         "appending missing end of block",
 244
 245         /* related to request and macro arguments */
 246         "escaped character not allowed in a name",
 247         "NOT IMPLEMENTED: Bd -file",
 248         "skipping display without arguments",
 249         "missing list type, using -item",
 250         "argument is not numeric, using 1",
 251         "missing manual name, using \"\"",
 252         "uname(3) system call failed, using UNKNOWN",
 253         "unknown standard specifier",
 254         "skipping request without numeric argument",
 255         "NOT IMPLEMENTED: .so with absolute path or \"..\"",
 256         ".so request failed",
 257         "skipping all arguments",
 258         "skipping excess arguments",
 259         "divide by zero",
 260
 261         "unsupported feature",
 262         "input too large",
 263         "unsupported control character",
 264         "unsupported roff request",
 265         "eqn delim option in tbl",
 266         "unsupported tbl layout modifier",
 267         "ignoring macro in table",
 268 };
 269
 270 static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
 271         "SUCCESS",
 272         "STYLE",
 273         "WARNING",
 274         "ERROR",
 275         "UNSUPP",
 276         "BADARG",
 277         "SYSERR"
 278 };
 279
 280
 281 static void
 282 resize_buf(struct buf *buf, size_t initial)
 283 {
 284
 285         buf->sz = buf->sz > initial/2 ? 2 * buf->sz : initial;
 286         buf->buf = mandoc_realloc(buf->buf, buf->sz);
 287 }
 288
 289 static void
 290 choose_parser(struct mparse *curp)
 291 {
 292         char            *cp, *ep;
 293         int              format;
 294
 295         /*
 296          * If neither command line arguments -mdoc or -man select
 297          * a parser nor the roff parser found a .Dd or .TH macro
 298          * yet, look ahead in the main input buffer.
 299          */
 300
 301         if ((format = roff_getformat(curp->roff)) == 0) {
 302                 cp = curp->primary->buf;
 303                 ep = cp + curp->primary->sz;
 304                 while (cp < ep) {
 305                         if (*cp == '.' || *cp == '\'') {
 306                                 cp++;
 307                                 if (cp[0] == 'D' && cp[1] == 'd') {
 308                                         format = MPARSE_MDOC;
 309                                         break;
 310                                 }
 311                                 if (cp[0] == 'T' && cp[1] == 'H') {
 312                                         format = MPARSE_MAN;
 313                                         break;
 314                                 }
 315                         }
 316                         cp = memchr(cp, '\n', ep - cp);
 317                         if (cp == NULL)
 318                                 break;
 319                         cp++;
 320                 }
 321         }
 322
 323         if (format == MPARSE_MDOC) {
 324                 curp->man->macroset = MACROSET_MDOC;
 325                 if (curp->man->mdocmac == NULL)
 326                         curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX);
 327         } else {
 328                 curp->man->macroset = MACROSET_MAN;
 329                 if (curp->man->manmac == NULL)
 330                         curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX);
 331         }
 332         curp->man->first->tok = TOKEN_NONE;
 333 }
 334
 335 /*
 336  * Main parse routine for a buffer.
 337  * It assumes encoding and line numbering are already set up.
 338  * It can recurse directly (for invocations of user-defined
 339  * macros, inline equations, and input line traps)
 340  * and indirectly (for .so file inclusion).
 341  */
 342 static int
 343 mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)
 344 {
 345         const struct tbl_span   *span;
 346         struct buf       ln;
 347         const char      *save_file;
 348         char            *cp;
 349         size_t           pos; /* byte number in the ln buffer */
 350         enum rofferr     rr;
 351         int              of;
 352         int              lnn; /* line number in the real file */
 353         int              fd;
 354         unsigned char    c;
 355
 356         memset(&ln, 0, sizeof(ln));
 357
 358         lnn = curp->line;
 359         pos = 0;
 360
 361         while (i < blk.sz) {
 362                 if (0 == pos && '\0' == blk.buf[i])
 363                         break;
 364
 365                 if (start) {
 366                         curp->line = lnn;
 367                         curp->reparse_count = 0;
 368
 369                         if (lnn < 3 &&
 370                             curp->filenc & MPARSE_UTF8 &&
 371                             curp->filenc & MPARSE_LATIN1)
 372                                 curp->filenc = preconv_cue(&blk, i);
 373                 }
 374
 375                 while (i < blk.sz && (start || blk.buf[i] != '\0')) {
 376
 377                         /*
 378                          * When finding an unescaped newline character,
 379                          * leave the character loop to process the line.
 380                          * Skip a preceding carriage return, if any.
 381                          */
 382
 383                         if ('\r' == blk.buf[i] && i + 1 < blk.sz &&
 384                             '\n' == blk.buf[i + 1])
 385                                 ++i;
 386                         if ('\n' == blk.buf[i]) {
 387                                 ++i;
 388                                 ++lnn;
 389                                 break;
 390                         }
 391
 392                         /*
 393                          * Make sure we have space for the worst
 394                          * case of 11 bytes: "\\[u10ffff]\0"
 395                          */
 396
 397                         if (pos + 11 > ln.sz)
 398                                 resize_buf(&ln, 256);
 399
 400                         /*
 401                          * Encode 8-bit input.
 402                          */
 403
 404                         c = blk.buf[i];
 405                         if (c & 0x80) {
 406                                 if ( ! (curp->filenc && preconv_encode(
 407                                     &blk, &i, &ln, &pos, &curp->filenc))) {
 408                                         mandoc_vmsg(MANDOCERR_CHAR_BAD, curp,
 409                                             curp->line, pos, "0x%x", c);
 410                                         ln.buf[pos++] = '?';
 411                                         i++;
 412                                 }
 413                                 continue;
 414                         }
 415
 416                         /*
 417                          * Exclude control characters.
 418                          */
 419
 420                         if (c == 0x7f || (c < 0x20 && c != 0x09)) {
 421                                 mandoc_vmsg(c == 0x00 || c == 0x04 ||
 422                                     c > 0x0a ? MANDOCERR_CHAR_BAD :
 423                                     MANDOCERR_CHAR_UNSUPP,
 424                                     curp, curp->line, pos, "0x%x", c);
 425                                 i++;
 426                                 if (c != '\r')
 427                                         ln.buf[pos++] = '?';
 428                                 continue;
 429                         }
 430
 431                         ln.buf[pos++] = blk.buf[i++];
 432                 }
 433
 434                 if (pos + 1 >= ln.sz)
 435                         resize_buf(&ln, 256);
 436
 437                 if (i == blk.sz || blk.buf[i] == '\0')
 438                         ln.buf[pos++] = '\n';
 439                 ln.buf[pos] = '\0';
 440
 441                 /*
 442                  * A significant amount of complexity is contained by
 443                  * the roff preprocessor.  It's line-oriented but can be
 444                  * expressed on one line, so we need at times to
 445                  * readjust our starting point and re-run it.  The roff
 446                  * preprocessor can also readjust the buffers with new
 447                  * data, so we pass them in wholesale.
 448                  */
 449
 450                 of = 0;
 451
 452                 /*
 453                  * Maintain a lookaside buffer of all parsed lines.  We
 454                  * only do this if mparse_keep() has been invoked (the
 455                  * buffer may be accessed with mparse_getkeep()).
 456                  */
 457
 458                 if (curp->secondary) {
 459                         curp->secondary->buf = mandoc_realloc(
 460                             curp->secondary->buf,
 461                             curp->secondary->sz + pos + 2);
 462                         memcpy(curp->secondary->buf +
 463                             curp->secondary->sz,
 464                             ln.buf, pos);
 465                         curp->secondary->sz += pos;
 466                         curp->secondary->buf
 467                                 [curp->secondary->sz] = '\n';
 468                         curp->secondary->sz++;
 469                         curp->secondary->buf
 470                                 [curp->secondary->sz] = '\0';
 471                 }
 472 rerun:
 473                 rr = roff_parseln(curp->roff, curp->line, &ln, &of);
 474
 475                 switch (rr) {
 476                 case ROFF_REPARSE:
 477                         if (++curp->reparse_count > REPARSE_LIMIT)
 478                                 mandoc_msg(MANDOCERR_ROFFLOOP, curp,
 479                                     curp->line, pos, NULL);
 480                         else if (mparse_buf_r(curp, ln, of, 0) == 1 ||
 481                             start == 1) {
 482                                 pos = 0;
 483                                 continue;
 484                         }
 485                         free(ln.buf);
 486                         return 0;
 487                 case ROFF_APPEND:
 488                         pos = strlen(ln.buf);
 489                         continue;
 490                 case ROFF_RERUN:
 491                         goto rerun;
 492                 case ROFF_IGN:
 493                         pos = 0;
 494                         continue;
 495                 case ROFF_SO:
 496                         if ( ! (curp->options & MPARSE_SO) &&
 497                             (i >= blk.sz || blk.buf[i] == '\0')) {
 498                                 curp->sodest = mandoc_strdup(ln.buf + of);
 499                                 free(ln.buf);
 500                                 return 1;
 501                         }
 502                         /*
 503                          * We remove `so' clauses from our lookaside
 504                          * buffer because we're going to descend into
 505                          * the file recursively.
 506                          */
 507                         if (curp->secondary)
 508                                 curp->secondary->sz -= pos + 1;
 509                         save_file = curp->file;
 510                         if ((fd = mparse_open(curp, ln.buf + of)) != -1) {
 511                                 mparse_readfd(curp, fd, ln.buf + of);
 512                                 close(fd);
 513                                 curp->file = save_file;
 514                         } else {
 515                                 curp->file = save_file;
 516                                 mandoc_vmsg(MANDOCERR_SO_FAIL,
 517                                     curp, curp->line, pos,
 518                                     ".so %s", ln.buf + of);
 519                                 ln.sz = mandoc_asprintf(&cp,
 520                                     ".sp\nSee the file %s.\n.sp",
 521                                     ln.buf + of);
 522                                 free(ln.buf);
 523                                 ln.buf = cp;
 524                                 of = 0;
 525                                 mparse_buf_r(curp, ln, of, 0);
 526                         }
 527                         pos = 0;
 528                         continue;
 529                 default:
 530                         break;
 531                 }
 532
 533                 if (curp->man->macroset == MACROSET_NONE)
 534                         choose_parser(curp);
 535
 536                 /*
 537                  * Lastly, push down into the parsers themselves.
 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                 if (rr == ROFF_TBL)
 546                         while ((span = roff_span(curp->roff)) != NULL)
 547                                 roff_addtbl(curp->man, span);
 548                 else if (rr == ROFF_EQN)
 549                         roff_addeqn(curp->man, roff_eqn(curp->roff));
 550                 else if ((curp->man->macroset == MACROSET_MDOC ?
 551                     mdoc_parseln(curp->man, curp->line, ln.buf, of) :
 552                     man_parseln(curp->man, curp->line, ln.buf, of)) == 2)
 553                                 break;
 554
 555                 /* Temporary buffers typically are not full. */
 556
 557                 if (0 == start && '\0' == blk.buf[i])
 558                         break;
 559
 560                 /* Start the next input line. */
 561
 562                 pos = 0;
 563         }
 564
 565         free(ln.buf);
 566         return 1;
 567 }
 568
 569 static int
 570 read_whole_file(struct mparse *curp, const char *file, int fd,
 571                 struct buf *fb, int *with_mmap)
 572 {
 573         struct stat      st;
 574         gzFile           gz;
 575         size_t           off;
 576         ssize_t          ssz;
 577
 578         if (fstat(fd, &st) == -1)
 579                 err((int)MANDOCLEVEL_SYSERR, "%s", file);
 580
 581         /*
 582          * If we're a regular file, try just reading in the whole entry
 583          * via mmap().  This is faster than reading it into blocks, and
 584          * since each file is only a few bytes to begin with, I'm not
 585          * concerned that this is going to tank any machines.
 586          */
 587
 588         if (curp->gzip == 0 && S_ISREG(st.st_mode)) {
 589                 if (st.st_size > 0x7fffffff) {
 590                         mandoc_msg(MANDOCERR_TOOLARGE, curp, 0, 0, NULL);
 591                         return 0;
 592                 }
 593                 *with_mmap = 1;
 594                 fb->sz = (size_t)st.st_size;
 595                 fb->buf = mmap(NULL, fb->sz, PROT_READ, MAP_SHARED, fd, 0);
 596                 if (fb->buf != MAP_FAILED)
 597                         return 1;
 598         }
 599
 600         if (curp->gzip) {
 601                 if ((gz = gzdopen(fd, "rb")) == NULL)
 602                         err((int)MANDOCLEVEL_SYSERR, "%s", file);
 603         } else
 604                 gz = NULL;
 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                                 mandoc_msg(MANDOCERR_TOOLARGE, curp,
 619                                     0, 0, NULL);
 620                                 break;
 621                         }
 622                         resize_buf(fb, 65536);
 623                 }
 624                 ssz = curp->gzip ?
 625                     gzread(gz, fb->buf + (int)off, fb->sz - off) :
 626                     read(fd, fb->buf + (int)off, fb->sz - off);
 627                 if (ssz == 0) {
 628                         fb->sz = off;
 629                         return 1;
 630                 }
 631                 if (ssz == -1)
 632                         err((int)MANDOCLEVEL_SYSERR, "%s", file);
 633                 off += (size_t)ssz;
 634         }
 635
 636         free(fb->buf);
 637         fb->buf = NULL;
 638         return 0;
 639 }
 640
 641 static void
 642 mparse_end(struct mparse *curp)
 643 {
 644         if (curp->man->macroset == MACROSET_NONE)
 645                 curp->man->macroset = MACROSET_MAN;
 646         if (curp->man->macroset == MACROSET_MDOC)
 647                 mdoc_endparse(curp->man);
 648         else
 649                 man_endparse(curp->man);
 650         roff_endparse(curp->roff);
 651 }
 652
 653 static void
 654 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file)
 655 {
 656         struct buf      *svprimary;
 657         const char      *svfile;
 658         size_t           offset;
 659         static int       recursion_depth;
 660
 661         if (64 < recursion_depth) {
 662                 mandoc_msg(MANDOCERR_ROFFLOOP, curp, curp->line, 0, NULL);
 663                 return;
 664         }
 665
 666         /* Line number is per-file. */
 667         svfile = curp->file;
 668         curp->file = file;
 669         svprimary = curp->primary;
 670         curp->primary = &blk;
 671         curp->line = 1;
 672         recursion_depth++;
 673
 674         /* Skip an UTF-8 byte order mark. */
 675         if (curp->filenc & MPARSE_UTF8 && blk.sz > 2 &&
 676             (unsigned char)blk.buf[0] == 0xef &&
 677             (unsigned char)blk.buf[1] == 0xbb &&
 678             (unsigned char)blk.buf[2] == 0xbf) {
 679                 offset = 3;
 680                 curp->filenc &= ~MPARSE_LATIN1;
 681         } else
 682                 offset = 0;
 683
 684         mparse_buf_r(curp, blk, offset, 1);
 685
 686         if (--recursion_depth == 0)
 687                 mparse_end(curp);
 688
 689         curp->primary = svprimary;
 690         curp->file = svfile;
 691 }
 692
 693 enum mandoclevel
 694 mparse_readmem(struct mparse *curp, void *buf, size_t len,
 695                 const char *file)
 696 {
 697         struct buf blk;
 698
 699         blk.buf = buf;
 700         blk.sz = len;
 701
 702         mparse_parse_buffer(curp, blk, file);
 703         return curp->file_status;
 704 }
 705
 706 /*
 707  * Read the whole file into memory and call the parsers.
 708  * Called recursively when an .so request is encountered.
 709  */
 710 enum mandoclevel
 711 mparse_readfd(struct mparse *curp, int fd, const char *file)
 712 {
 713         struct buf       blk;
 714         int              with_mmap;
 715         int              save_filenc;
 716
 717         if (read_whole_file(curp, file, fd, &blk, &with_mmap)) {
 718                 save_filenc = curp->filenc;
 719                 curp->filenc = curp->options &
 720                     (MPARSE_UTF8 | MPARSE_LATIN1);
 721                 mparse_parse_buffer(curp, blk, file);
 722                 curp->filenc = save_filenc;
 723                 if (with_mmap)
 724                         munmap(blk.buf, blk.sz);
 725                 else
 726                         free(blk.buf);
 727         }
 728         return curp->file_status;
 729 }
 730
 731 int
 732 mparse_open(struct mparse *curp, const char *file)
 733 {
 734         char             *cp;
 735         int               fd;
 736
 737         curp->file = file;
 738         cp = strrchr(file, '.');
 739         curp->gzip = (cp != NULL && ! strcmp(cp + 1, "gz"));
 740
 741         /* First try to use the filename as it is. */
 742
 743         if ((fd = open(file, O_RDONLY)) != -1)
 744                 return fd;
 745
 746         /*
 747          * If that doesn't work and the filename doesn't
 748          * already  end in .gz, try appending .gz.
 749          */
 750
 751         if ( ! curp->gzip) {
 752                 mandoc_asprintf(&cp, "%s.gz", file);
 753                 fd = open(cp, O_RDONLY);
 754                 free(cp);
 755                 if (fd != -1) {
 756                         curp->gzip = 1;
 757                         return fd;
 758                 }
 759         }
 760
 761         /* Neither worked, give up. */
 762
 763         mandoc_msg(MANDOCERR_FILE, curp, 0, 0, strerror(errno));
 764         return -1;
 765 }
 766
 767 struct mparse *
 768 mparse_alloc(int options, enum mandocerr mmin, mandocmsg mmsg,
 769     enum mandoc_os os_e, const char *os_s)
 770 {
 771         struct mparse   *curp;
 772
 773         curp = mandoc_calloc(1, sizeof(struct mparse));
 774
 775         curp->options = options;
 776         curp->mmin = mmin;
 777         curp->mmsg = mmsg;
 778         curp->os_s = os_s;
 779
 780         curp->roff = roff_alloc(curp, options);
 781         curp->man = roff_man_alloc(curp->roff, curp, curp->os_s,
 782                 curp->options & MPARSE_QUICK ? 1 : 0);
 783         if (curp->options & MPARSE_MDOC) {
 784                 curp->man->macroset = MACROSET_MDOC;
 785                 if (curp->man->mdocmac == NULL)
 786                         curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX);
 787         } else if (curp->options & MPARSE_MAN) {
 788                 curp->man->macroset = MACROSET_MAN;
 789                 if (curp->man->manmac == NULL)
 790                         curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX);
 791         }
 792         curp->man->first->tok = TOKEN_NONE;
 793         curp->man->meta.os_e = os_e;
 794         return curp;
 795 }
 796
 797 void
 798 mparse_reset(struct mparse *curp)
 799 {
 800         roff_reset(curp->roff);
 801         roff_man_reset(curp->man);
 802
 803         free(curp->sodest);
 804         curp->sodest = NULL;
 805
 806         if (curp->secondary)
 807                 curp->secondary->sz = 0;
 808
 809         curp->file_status = MANDOCLEVEL_OK;
 810         curp->gzip = 0;
 811 }
 812
 813 void
 814 mparse_free(struct mparse *curp)
 815 {
 816
 817         roffhash_free(curp->man->mdocmac);
 818         roffhash_free(curp->man->manmac);
 819         roff_man_free(curp->man);
 820         roff_free(curp->roff);
 821         if (curp->secondary)
 822                 free(curp->secondary->buf);
 823
 824         free(curp->secondary);
 825         free(curp->sodest);
 826         free(curp);
 827 }
 828
 829 void
 830 mparse_result(struct mparse *curp, struct roff_man **man,
 831         char **sodest)
 832 {
 833
 834         if (sodest && NULL != (*sodest = curp->sodest)) {
 835                 *man = NULL;
 836                 return;
 837         }
 838         if (man)
 839                 *man = curp->man;
 840 }
 841
 842 void
 843 mparse_updaterc(struct mparse *curp, enum mandoclevel *rc)
 844 {
 845         if (curp->file_status > *rc)
 846                 *rc = curp->file_status;
 847 }
 848
 849 void
 850 mandoc_vmsg(enum mandocerr t, struct mparse *m,
 851                 int ln, int pos, const char *fmt, ...)
 852 {
 853         char             buf[256];
 854         va_list          ap;
 855
 856         va_start(ap, fmt);
 857         (void)vsnprintf(buf, sizeof(buf), fmt, ap);
 858         va_end(ap);
 859
 860         mandoc_msg(t, m, ln, pos, buf);
 861 }
 862
 863 void
 864 mandoc_msg(enum mandocerr er, struct mparse *m,
 865                 int ln, int col, const char *msg)
 866 {
 867         enum mandoclevel level;
 868
 869         if (er < m->mmin && er != MANDOCERR_FILE)
 870                 return;
 871
 872         level = MANDOCLEVEL_UNSUPP;
 873         while (er < mandoclimits[level])
 874                 level--;
 875
 876         if (m->mmsg)
 877                 (*m->mmsg)(er, level, m->file, ln, col, msg);
 878
 879         if (m->file_status < level)
 880                 m->file_status = level;
 881 }
 882
 883 const char *
 884 mparse_strerror(enum mandocerr er)
 885 {
 886
 887         return mandocerrs[er];
 888 }
 889
 890 const char *
 891 mparse_strlevel(enum mandoclevel lvl)
 892 {
 893         return mandoclevels[lvl];
 894 }
 895
 896 void
 897 mparse_keep(struct mparse *p)
 898 {
 899
 900         assert(NULL == p->secondary);
 901         p->secondary = mandoc_calloc(1, sizeof(struct buf));
 902 }
 903
 904 const char *
 905 mparse_getkeep(const struct mparse *p)
 906 {
 907
 908         assert(p->secondary);
 909         return p->secondary->sz ? p->secondary->buf : NULL;
 910 }