read.c

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