read.c

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