read.c

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