read.c

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