read.c

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