When a file is given on the command line, actually exists, and its name

[mandoc.git] / read.c

diff --git a/read.c b/read.c
index ee71370537b0b78da976334d7b9797fbf012370c..703e949aedc1a2b1b5654c0bcb68d32850a19d2a 100644 (file)
--- a/read.c
+++ b/read.c
@@ -1,7 +1,8 @@
-/*     $Id: read.c,v 1.18 2011/07/18 07:46:41 kristaps Exp $ */
+/*     $Id: read.c,v 1.106 2014/12/28 14:42:27 schwarze Exp $ */

 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>

- * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010, 2012 Joerg Sonnenberger <joerg@netbsd.org>

  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above


@@ -15,63 +16,64 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */

-#ifdef HAVE_CONFIG_H

 #include "config.h"
 #include "config.h"

-#endif

 
 

-#ifdef HAVE_MMAP
-# include <sys/stat.h>
-# include <sys/mman.h>
+#include <sys/types.h>
+#if HAVE_MMAP
+#include <sys/mman.h>
+#include <sys/stat.h>

 #endif
 #endif

+#include <sys/wait.h>

 
 #include <assert.h>
 #include <ctype.h>
 
 #include <assert.h>
 #include <ctype.h>

+#include <errno.h>

 #include <fcntl.h>
 #include <stdarg.h>
 #include <fcntl.h>
 #include <stdarg.h>

+#include <stdint.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "mandoc.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "mandoc.h"

+#include "mandoc_aux.h"

 #include "libmandoc.h"
 #include "mdoc.h"
 #include "man.h"
 
 #include "libmandoc.h"
 #include "mdoc.h"
 #include "man.h"
 

-#ifndef MAP_FILE
-#define        MAP_FILE        0
-#endif
-

 #define        REPARSE_LIMIT   1000
 
 #define        REPARSE_LIMIT   1000
 

-struct buf {
-       char             *buf; /* binary input buffer */
-       size_t            sz; /* size of binary buffer */
-};
-

 struct mparse {
 struct mparse {

-       enum mandoclevel  file_status; /* status of current parse */
-       enum mandoclevel  wlevel; /* ignore messages below this */
-       int               line; /* line number in the file */
-       enum mparset      inttype; /* which parser to use */

        struct man       *pman; /* persistent man parser */
        struct mdoc      *pmdoc; /* persistent mdoc parser */
        struct man       *man; /* man parser */
        struct mdoc      *mdoc; /* mdoc parser */
        struct roff      *roff; /* roff parser (!NULL) */
        struct man       *pman; /* persistent man parser */
        struct mdoc      *pmdoc; /* persistent mdoc parser */
        struct man       *man; /* man parser */
        struct mdoc      *mdoc; /* mdoc parser */
        struct roff      *roff; /* roff parser (!NULL) */

-       int               reparse_count; /* finite interp. stack */
+       const struct mchars *mchars; /* character table */
+       char             *sodest; /* filename pointed to by .so */
+       const char       *file; /* filename of current input file */
+       struct buf       *primary; /* buffer currently being parsed */
+       struct buf       *secondary; /* preprocessed copy of input */
+       const char       *defos; /* default operating system */

        mandocmsg         mmsg; /* warning/error message handler */
        mandocmsg         mmsg; /* warning/error message handler */

-       void             *arg; /* argument to mmsg */
-       const char       *file; 
+       enum mandoclevel  file_status; /* status of current parse */
+       enum mandoclevel  wlevel; /* ignore messages below this */
+       int               options; /* parser options */
+       int               filenc; /* encoding of the current file */
+       int               reparse_count; /* finite interp. stack */
+       int               line; /* line number in the file */
+       pid_t             child; /* the gunzip(1) process */

 };
 
 };
 

+static void      choose_parser(struct mparse *);

 static void      resize_buf(struct buf *, size_t);
 static void      resize_buf(struct buf *, size_t);

-static void      mparse_buf_r(struct mparse *, struct buf, int);
-static void      mparse_readfd_r(struct mparse *, int, const char *, int);
-static void      pset(const char *, int, struct mparse *);
-static void      pdesc(struct mparse *, const char *, int);
-static int       read_whole_file(const char *, int, struct buf *, int *);
+static void      mparse_buf_r(struct mparse *, struct buf, size_t, int);
+static int       read_whole_file(struct mparse *, const char *, int,
+                               struct buf *, int *);

 static void      mparse_end(struct mparse *);
 static void      mparse_end(struct mparse *);

+static void      mparse_parse_buffer(struct mparse *, struct buf,
+                       const char *);

 
 static const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {
        MANDOCERR_OK,
 
 static const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {
        MANDOCERR_OK,


@@ -89,70 +91,93 @@ static      const char * const      mandocerrs[MANDOCERR_MAX] = {
        "generic warning",
 
        /* related to the prologue */
        "generic warning",
 
        /* related to the prologue */

-       "no title in document",
-       "document title should be all caps",
+       "missing manual title, using UNTITLED",
+       "missing manual title, using \"\"",
+       "lower case character in document title",
+       "missing manual section, using \"\"",

        "unknown manual section",
        "unknown manual section",

-       "date missing, using today's date",
+       "missing date, using today's date",

        "cannot parse date, using it verbatim",
        "cannot parse date, using it verbatim",

-       "prologue macros out of order",
+       "missing Os macro, using \"\"",

        "duplicate prologue macro",
        "duplicate prologue macro",

-       "macro not allowed in prologue",
-       "macro not allowed in body",
+       "late prologue macro",
+       "skipping late title macro",
+       "prologue macros out of order",

 
        /* related to document structure */
        ".so is fragile, better use ln(1)",
 
        /* related to document structure */
        ".so is fragile, better use ln(1)",

-       "NAME section must come first",
+       "no document body",
+       "content before first section header",
+       "first section is not \"NAME\"",

        "bad NAME section contents",
        "bad NAME section contents",

-       "manual name not yet set",

        "sections out of conventional order",
        "sections out of conventional order",

-       "duplicate section name",
-       "section not in conventional manual section",
+       "duplicate section title",
+       "unexpected section",
+       "unusual Xr order",
+       "unusual Xr punctuation",
+       "AUTHORS section without An macro",

 
        /* related to macros and nesting */
 
        /* related to macros and nesting */

-       "skipping obsolete macro",
+       "obsolete macro",
+       "macro neither callable nor escaped",

        "skipping paragraph macro",
        "skipping paragraph macro",

+       "moving paragraph macro out of list",

        "skipping no-space macro",
        "blocks badly nested",
        "skipping no-space macro",
        "blocks badly nested",

-       "child violates parent syntax",

        "nested displays are not portable",
        "nested displays are not portable",

-       "already in literal mode",
+       "moving content out of list",
+       ".Vt block has child macro",
+       "fill mode already enabled, skipping",
+       "fill mode already disabled, skipping",

        "line scope broken",
 
        /* related to missing macro arguments */
        "line scope broken",
 
        /* related to missing macro arguments */

+       "skipping empty request",
+       "conditional request controls empty scope",

        "skipping empty macro",
        "skipping empty macro",

+       "empty argument, using 0n",

        "argument count wrong",
        "argument count wrong",

-       "missing display type",
-       "list type must come first",
-       "tag lists require a width argument",
-       "missing font type",
-       "skipping end of block that is not open",
+       "missing display type, using -ragged",
+       "list type is not the first argument",
+       "missing -width in -tag list, using 8n",
+       "missing utility name, using \"\"",
+       "empty head in list item",
+       "empty list item",
+       "missing font type, using \\fR",
+       "unknown font type, using \\fR",
+       "nothing follows prefix",
+       "missing -std argument, adding it",
+       "missing eqn box, using \"\"",

 
        /* related to bad macro arguments */
 
        /* related to bad macro arguments */

-       "skipping argument",
+       "unterminated quoted argument",

        "duplicate argument",
        "duplicate argument",

-       "duplicate display type",
-       "duplicate list type",
+       "skipping duplicate argument",
+       "skipping duplicate display type",
+       "skipping duplicate list type",
+       "skipping -width argument",

        "unknown AT&T UNIX version",
        "unknown AT&T UNIX version",

-       "bad Boolean value",
-       "unknown font",
-       "unknown standard specifier",
-       "bad width argument",
+       "comma in function argument",
+       "parenthesis in function name",
+       "invalid content in Rs block",
+       "invalid Boolean argument",
+       "unknown font, skipping request",

 
        /* related to plain text */
 
        /* related to plain text */

-       "blank line in non-literal context",
-       "tab in non-literal context",
-       "end of line whitespace",
+       "blank line in fill mode, using .sp",
+       "tab in filled text",
+       "whitespace at end of input line",

        "bad comment style",
        "bad comment style",

-       "bad escape sequence",
-       "unterminated quoted string",
+       "invalid escape sequence",
+       "undefined string, using \"\"",

 
 

-       /* related to equations */
-       "unexpected literal in equation",
-       

        "generic error",
 
        /* related to equations */
        "generic error",
 
        /* related to equations */

-       "bad equation macro syntax",
+       "unexpected equation scope closure",
+       "equation scope open on exit",
+       "overlapping equation scopes",
+       "unexpected end of equation",

 
        /* related to tables */
        "bad table syntax",
 
        /* related to tables */
        "bad table syntax",


@@ -163,38 +188,48 @@ static    const char * const      mandocerrs[MANDOCERR_MAX] = {
        "ignore data in cell",
        "data block still open",
        "ignoring extra data cells",
        "ignore data in cell",
        "data block still open",
        "ignoring extra data cells",

+       "ignoring macro in table",

 
 

+       /* related to document structure and macros */

        "input stack limit exceeded, infinite loop?",
        "skipping bad character",
        "input stack limit exceeded, infinite loop?",
        "skipping bad character",

-       "escaped character not allowed in a name",
-       "skipping text before the first section header",

        "skipping unknown macro",
        "skipping unknown macro",

-       "NOT IMPLEMENTED, please use groff: skipping request",
-       "argument count wrong",
+       "skipping item outside list",
+       "skipping column outside column list",

        "skipping end of block that is not open",
        "skipping end of block that is not open",

-       "missing end of block",
-       "scope open on exit",
-       "uname(3) system call failed",
-       "macro requires line argument(s)",
-       "macro requires body argument(s)",
-       "macro requires argument(s)",
-       "missing list type",
-       "line argument(s) will be lost",
-       "body argument(s) will be lost",
+       "inserting missing end of block",
+       "appending missing end of block",
+
+       /* related to request and macro arguments */
+       "escaped character not allowed in a name",
+       "argument count wrong",
+       "NOT IMPLEMENTED: Bd -file",
+       "missing list type, using -item",
+       "missing manual name, using \"\"",
+       "uname(3) system call failed, using UNKNOWN",
+       "unknown standard specifier",
+       "skipping request without numeric argument",
+       "skipping all arguments",
+       "skipping excess arguments",
+       "divide by zero",

 
        "generic fatal error",
 
 
        "generic fatal error",
 

-       "not a manual",
-       "column syntax is inconsistent",
-       "NOT IMPLEMENTED: .Bd -file",
-       "line scope broken, syntax violated",
-       "argument count wrong, violates syntax",
-       "child violates parent syntax",
-       "argument count wrong, violates syntax",
+       "input too large",

        "NOT IMPLEMENTED: .so with absolute path or \"..\"",
        "NOT IMPLEMENTED: .so with absolute path or \"..\"",

-       "no document body",
-       "no document prologue",
-       "static buffer exhausted",
+       ".so request failed",
+
+       /* system errors */
+       "cannot dup file descriptor",
+       "cannot exec",
+       "gunzip failed with code",
+       "cannot fork",
+       NULL,
+       "cannot open pipe",
+       "cannot read file",
+       "gunzip died from signal",
+       "cannot stat file",
+       "wait failed",

 };
 
 static const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
 };
 
 static const char * const      mandoclevels[MANDOCLEVEL_MAX] = {


@@ -207,6 +242,7 @@ static      const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
        "SYSERR"
 };
 
        "SYSERR"
 };
 

+

 static void
 resize_buf(struct buf *buf, size_t initial)
 {
 static void
 resize_buf(struct buf *buf, size_t initial)
 {


@@ -216,91 +252,97 @@ resize_buf(struct buf *buf, size_t initial)
 }
 
 static void
 }
 
 static void

-pset(const char *buf, int pos, struct mparse *curp)
+choose_parser(struct mparse *curp)

 {
 {

-       int              i;
+       char            *cp, *ep;
+       int              format;

 
        /*
 
        /*

-        * Try to intuit which kind of manual parser should be used.  If
-        * passed in by command-line (-man, -mdoc), then use that
-        * explicitly.  If passed as -mandoc, then try to guess from the
-        * line: either skip dot-lines, use -mdoc when finding `.Dt', or
-        * default to -man, which is more lenient.
-        *
-        * Separate out pmdoc/pman from mdoc/man: the first persists
-        * through all parsers, while the latter is used per-parse.
+        * If neither command line arguments -mdoc or -man select
+        * a parser nor the roff parser found a .Dd or .TH macro
+        * yet, look ahead in the main input buffer.

         */
 
         */
 

-       if ('.' == buf[0] || '\'' == buf[0]) {
-               for (i = 1; buf[i]; i++)
-                       if (' ' != buf[i] && '\t' != buf[i])
+       if ((format = roff_getformat(curp->roff)) == 0) {
+               cp = curp->primary->buf;
+               ep = cp + curp->primary->sz;
+               while (cp < ep) {
+                       if (*cp == '.' || *cp == '\'') {
+                               cp++;
+                               if (cp[0] == 'D' && cp[1] == 'd') {
+                                       format = MPARSE_MDOC;
+                                       break;
+                               }
+                               if (cp[0] == 'T' && cp[1] == 'H') {
+                                       format = MPARSE_MAN;
+                                       break;
+                               }
+                       }
+                       cp = memchr(cp, '\n', ep - cp);
+                       if (cp == NULL)

                                break;
                                break;

-               if ('\0' == buf[i])
-                       return;
+                       cp++;
+               }

        }
 
        }
 

-       switch (curp->inttype) {
-       case (MPARSE_MDOC):
-               if (NULL == curp->pmdoc) 
-                       curp->pmdoc = mdoc_alloc(curp->roff, curp);
+       if (format == MPARSE_MDOC) {
+               if (NULL == curp->pmdoc)
+                       curp->pmdoc = mdoc_alloc(
+                           curp->roff, curp, curp->defos,
+                           MPARSE_QUICK & curp->options ? 1 : 0);

                assert(curp->pmdoc);
                curp->mdoc = curp->pmdoc;
                return;
                assert(curp->pmdoc);
                curp->mdoc = curp->pmdoc;
                return;

-       case (MPARSE_MAN):
-               if (NULL == curp->pman) 
-                       curp->pman = man_alloc(curp->roff, curp);
-               assert(curp->pman);
-               curp->man = curp->pman;
-               return;
-       default:
-               break;

        }
 
        }
 

-       if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
-               if (NULL == curp->pmdoc) 
-                       curp->pmdoc = mdoc_alloc(curp->roff, curp);
-               assert(curp->pmdoc);
-               curp->mdoc = curp->pmdoc;
-               return;
-       } 
+       /* Fall back to man(7) as a last resort. */

 
 

-       if (NULL == curp->pman) 
-               curp->pman = man_alloc(curp->roff, curp);
+       if (NULL == curp->pman)
+               curp->pman = man_alloc(
+                   curp->roff, curp, curp->defos,
+                   MPARSE_QUICK & curp->options ? 1 : 0);

        assert(curp->pman);
        curp->man = curp->pman;
 }
 
 /*
        assert(curp->pman);
        curp->man = curp->pman;
 }
 
 /*

- * Main parse routine for an opened file.  This is called for each
- * opened file and simply loops around the full input file, possibly
- * nesting (i.e., with `so').
+ * Main parse routine for a buffer.
+ * It assumes encoding and line numbering are already set up.
+ * It can recurse directly (for invocations of user-defined
+ * macros, inline equations, and input line traps)
+ * and indirectly (for .so file inclusion).

  */
 static void
  */
 static void

-mparse_buf_r(struct mparse *curp, struct buf blk, int start)
+mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)

 {
        const struct tbl_span   *span;
        struct buf       ln;
 {
        const struct tbl_span   *span;
        struct buf       ln;

+       size_t           pos; /* byte number in the ln buffer */

        enum rofferr     rr;
        enum rofferr     rr;

-       int              i, of, rc;
-       int              pos; /* byte number in the ln buffer */
+       int              of;

        int              lnn; /* line number in the real file */
        unsigned char    c;
 
        int              lnn; /* line number in the real file */
        unsigned char    c;
 

-       memset(&ln, 0, sizeof(struct buf));
+       memset(&ln, 0, sizeof(ln));

 
 

-       lnn = curp->line; 
-       pos = 0; 
+       lnn = curp->line;
+       pos = 0;

 
 

-       for (i = 0; i < (int)blk.sz; ) {
+       while (i < blk.sz) {

                if (0 == pos && '\0' == blk.buf[i])
                        break;
 
                if (start) {
                        curp->line = lnn;
                        curp->reparse_count = 0;
                if (0 == pos && '\0' == blk.buf[i])
                        break;
 
                if (start) {
                        curp->line = lnn;
                        curp->reparse_count = 0;

+
+                       if (lnn < 3 &&
+                           curp->filenc & MPARSE_UTF8 &&
+                           curp->filenc & MPARSE_LATIN1)
+                               curp->filenc = preconv_cue(&blk, i);

                }
 
                }
 

-               while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) {
+               while (i < blk.sz && (start || blk.buf[i] != '\0')) {

 
                        /*
                         * When finding an unescaped newline character,
 
                        /*
                         * When finding an unescaped newline character,


@@ -308,7 +350,7 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                         * Skip a preceding carriage return, if any.
                         */
 
                         * Skip a preceding carriage return, if any.
                         */
 

-                       if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz &&
+                       if ('\r' == blk.buf[i] && i + 1 < blk.sz &&

                            '\n' == blk.buf[i + 1])
                                ++i;
                        if ('\n' == blk.buf[i]) {
                            '\n' == blk.buf[i + 1])
                                ++i;
                        if ('\n' == blk.buf[i]) {


@@ -317,30 +359,46 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                                break;
                        }
 
                                break;
                        }
 

-                       /* 
-                        * Warn about bogus characters.  If you're using
-                        * non-ASCII encoding, you're screwing your
-                        * readers.  Since I'd rather this not happen,
-                        * I'll be helpful and drop these characters so
-                        * we don't display gibberish.  Note to manual
-                        * writers: use special characters.
+                       /*
+                        * Make sure we have space for the worst
+                        * case of 11 bytes: "\\[u10ffff]\0"
+                        */
+
+                       if (pos + 11 > ln.sz)
+                               resize_buf(&ln, 256);
+
+                       /*
+                        * Encode 8-bit input.

                         */
 
                         */
 

-                       c = (unsigned char) blk.buf[i];
+                       c = blk.buf[i];
+                       if (c & 0x80) {
+                               if ( ! (curp->filenc && preconv_encode(
+                                   &blk, &i, &ln, &pos, &curp->filenc))) {
+                                       mandoc_vmsg(MANDOCERR_BADCHAR,
+                                           curp, curp->line, pos,
+                                           "0x%x", c);
+                                       ln.buf[pos++] = '?';
+                                       i++;
+                               }
+                               continue;
+                       }
+
+                       /*
+                        * Exclude control characters.
+                        */

 
 

-                       if ( ! (isascii(c) && 
-                                       (isgraph(c) || isblank(c)))) {
-                               mandoc_msg(MANDOCERR_BADCHAR, curp,
-                                               curp->line, pos, "ignoring byte");
+                       if (c == 0x7f || (c < 0x20 && c != 0x09)) {
+                               mandoc_vmsg(MANDOCERR_BADCHAR, curp,
+                                   curp->line, pos, "0x%x", c);

                                i++;
                                i++;

+                               ln.buf[pos++] = '?';

                                continue;
                        }
 
                        /* Trailing backslash = a plain char. */
 
                                continue;
                        }
 
                        /* Trailing backslash = a plain char. */
 

-                       if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
-                               if (pos >= (int)ln.sz)
-                                       resize_buf(&ln, 256);
+                       if (blk.buf[i] != '\\' || i + 1 == blk.sz) {

                                ln.buf[pos++] = blk.buf[i++];
                                continue;
                        }
                                ln.buf[pos++] = blk.buf[i++];
                                continue;
                        }


@@ -352,7 +410,7 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                         * skip that one as well.
                         */
 
                         * skip that one as well.
                         */
 

-                       if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz &&
+                       if ('\r' == blk.buf[i + 1] && i + 2 < blk.sz &&

                            '\n' == blk.buf[i + 2])
                                ++i;
                        if ('\n' == blk.buf[i + 1]) {
                            '\n' == blk.buf[i + 2])
                                ++i;
                        if ('\n' == blk.buf[i + 1]) {


@@ -364,7 +422,7 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                        if ('"' == blk.buf[i + 1] || '#' == blk.buf[i + 1]) {
                                i += 2;
                                /* Comment, skip to end of line */
                        if ('"' == blk.buf[i + 1] || '#' == blk.buf[i + 1]) {
                                i += 2;
                                /* Comment, skip to end of line */

-                               for (; i < (int)blk.sz; ++i) {
+                               for (; i < blk.sz; ++i) {

                                        if ('\n' == blk.buf[i]) {
                                                ++i;
                                                ++lnn;
                                        if ('\n' == blk.buf[i]) {
                                                ++i;
                                                ++lnn;


@@ -382,16 +440,26 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                                break;
                        }
 
                                break;
                        }
 

-                       /* Some other escape sequence, copy & cont. */
+                       /* Catch escaped bogus characters. */

 
 

-                       if (pos + 1 >= (int)ln.sz)
-                               resize_buf(&ln, 256);
+                       c = (unsigned char) blk.buf[i+1];
+
+                       if ( ! (isascii(c) &&
+                           (isgraph(c) || isblank(c)))) {
+                               mandoc_vmsg(MANDOCERR_BADCHAR, curp,
+                                   curp->line, pos, "0x%x", c);
+                               i += 2;
+                               ln.buf[pos++] = '?';
+                               continue;
+                       }
+
+                       /* Some other escape sequence, copy & cont. */

 
                        ln.buf[pos++] = blk.buf[i++];
                        ln.buf[pos++] = blk.buf[i++];
                }
 
 
                        ln.buf[pos++] = blk.buf[i++];
                        ln.buf[pos++] = blk.buf[i++];
                }
 

-               if (pos >= (int)ln.sz)
+               if (pos >= ln.sz)

                        resize_buf(&ln, 256);
 
                ln.buf[pos] = '\0';
                        resize_buf(&ln, 256);
 
                ln.buf[pos] = '\0';


@@ -407,35 +475,70 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
 
                of = 0;
 
 
                of = 0;
 

+               /*
+                * Maintain a lookaside buffer of all parsed lines.  We
+                * only do this if mparse_keep() has been invoked (the
+                * buffer may be accessed with mparse_getkeep()).
+                */
+
+               if (curp->secondary) {
+                       curp->secondary->buf = mandoc_realloc(
+                           curp->secondary->buf,
+                           curp->secondary->sz + pos + 2);
+                       memcpy(curp->secondary->buf +
+                           curp->secondary->sz,
+                           ln.buf, pos);
+                       curp->secondary->sz += pos;
+                       curp->secondary->buf
+                               [curp->secondary->sz] = '\n';
+                       curp->secondary->sz++;
+                       curp->secondary->buf
+                               [curp->secondary->sz] = '\0';
+               }

 rerun:
 rerun:

-               rr = roff_parseln
-                       (curp->roff, curp->line, 
-                        &ln.buf, &ln.sz, of, &of);
+               rr = roff_parseln(curp->roff, curp->line, &ln, &of);

 
                switch (rr) {
 
                switch (rr) {

-               case (ROFF_REPARSE):
+               case ROFF_REPARSE:

                        if (REPARSE_LIMIT >= ++curp->reparse_count)
                        if (REPARSE_LIMIT >= ++curp->reparse_count)

-                               mparse_buf_r(curp, ln, 0);
+                               mparse_buf_r(curp, ln, of, 0);

                        else
                                mandoc_msg(MANDOCERR_ROFFLOOP, curp,
                        else
                                mandoc_msg(MANDOCERR_ROFFLOOP, curp,

-                                       curp->line, pos, NULL);
+                                   curp->line, pos, NULL);

                        pos = 0;
                        continue;
                        pos = 0;
                        continue;

-               case (ROFF_APPEND):
-                       pos = (int)strlen(ln.buf);
+               case ROFF_APPEND:
+                       pos = strlen(ln.buf);

                        continue;
                        continue;

-               case (ROFF_RERUN):
+               case ROFF_RERUN:

                        goto rerun;
                        goto rerun;

-               case (ROFF_IGN):
+               case ROFF_IGN:

                        pos = 0;
                        continue;
                        pos = 0;
                        continue;

-               case (ROFF_ERR):
+               case ROFF_ERR:

                        assert(MANDOCLEVEL_FATAL <= curp->file_status);
                        break;
                        assert(MANDOCLEVEL_FATAL <= curp->file_status);
                        break;

-               case (ROFF_SO):
-                       mparse_readfd_r(curp, -1, ln.buf + of, 1);
-                       if (MANDOCLEVEL_FATAL <= curp->file_status)
+               case ROFF_SO:
+                       if ( ! (curp->options & MPARSE_SO) &&
+                           (i >= blk.sz || blk.buf[i] == '\0')) {
+                               curp->sodest = mandoc_strdup(ln.buf + of);
+                               free(ln.buf);
+                               return;
+                       }
+                       /*
+                        * We remove `so' clauses from our lookaside
+                        * buffer because we're going to descend into
+                        * the file recursively.
+                        */
+                       if (curp->secondary)
+                               curp->secondary->sz -= pos + 1;
+                       mparse_readfd(curp, -1, ln.buf + of);
+                       if (MANDOCLEVEL_FATAL <= curp->file_status) {
+                               mandoc_vmsg(MANDOCERR_SO_FAIL,
+                                   curp, curp->line, pos,
+                                   ".so %s", ln.buf + of);

                                break;
                                break;

+                       }

                        pos = 0;
                        continue;
                default:
                        pos = 0;
                        continue;
                default:


@@ -458,12 +561,10 @@ rerun:
                 */
 
                if ( ! (curp->man || curp->mdoc))
                 */
 
                if ( ! (curp->man || curp->mdoc))

-                       pset(ln.buf + of, pos - of, curp);
+                       choose_parser(curp);

 
 

-               /* 
-                * Lastly, push down into the parsers themselves.  One
-                * of these will have already been set in the pset()
-                * routine.
+               /*
+                * Lastly, push down into the parsers themselves.

                 * If libroff returns ROFF_TBL, then add it to the
                 * currently open parse.  Since we only get here if
                 * there does exist data (see tbl_data.c), we're
                 * If libroff returns ROFF_TBL, then add it to the
                 * currently open parse.  Since we only get here if
                 * there does exist data (see tbl_data.c), we're


@@ -471,33 +572,21 @@ rerun:
                 * Do the same for ROFF_EQN.
                 */
 
                 * Do the same for ROFF_EQN.
                 */
 

-               rc = -1;
-
-               if (ROFF_TBL == rr)
-                       while (NULL != (span = roff_span(curp->roff))) {
-                               rc = curp->man ?
-                                       man_addspan(curp->man, span) :
+               if (rr == ROFF_TBL) {
+                       while ((span = roff_span(curp->roff)) != NULL)
+                               if (curp->man == NULL)

                                        mdoc_addspan(curp->mdoc, span);
                                        mdoc_addspan(curp->mdoc, span);

-                               if (0 == rc)
-                                       break;
-                       }
-               else if (ROFF_EQN == rr)
-                       rc = curp->mdoc ? 
-                               mdoc_addeqn(curp->mdoc, 
-                                       roff_eqn(curp->roff)) :
-                               man_addeqn(curp->man,
-                                       roff_eqn(curp->roff));
-               else if (curp->man || curp->mdoc)
-                       rc = curp->man ?
-                               man_parseln(curp->man, 
-                                       curp->line, ln.buf, of) :
-                               mdoc_parseln(curp->mdoc, 
-                                       curp->line, ln.buf, of);
-
-               if (0 == rc) {
-                       assert(MANDOCLEVEL_FATAL <= curp->file_status);
-                       break;
-               }
+                               else
+                                       man_addspan(curp->man, span);
+               } else if (rr == ROFF_EQN) {
+                       if (curp->man == NULL)
+                               mdoc_addeqn(curp->mdoc, roff_eqn(curp->roff));
+                       else
+                               man_addeqn(curp->man, roff_eqn(curp->roff));
+               } else if ((curp->man == NULL ?
+                   mdoc_parseln(curp->mdoc, curp->line, ln.buf, of) :
+                   man_parseln(curp->man, curp->line, ln.buf, of)) == 2)
+                               break;

 
                /* Temporary buffers typically are not full. */
 
 
                /* Temporary buffers typically are not full. */
 


@@ -512,48 +601,20 @@ rerun:
        free(ln.buf);
 }
 
        free(ln.buf);
 }
 

-static void
-pdesc(struct mparse *curp, const char *file, int fd)
-{
-       struct buf       blk;
-       int              with_mmap;
-
-       /*
-        * Run for each opened file; may be called more than once for
-        * each full parse sequence if the opened file is nested (i.e.,
-        * from `so').  Simply sucks in the whole file and moves into
-        * the parse phase for the file.
-        */
-
-       if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {
-               curp->file_status = MANDOCLEVEL_SYSERR;
-               return;
-       }
-
-       /* Line number is per-file. */
-
-       curp->line = 1;
-
-       mparse_buf_r(curp, blk, 1);
-
-#ifdef HAVE_MMAP
-       if (with_mmap)
-               munmap(blk.buf, blk.sz);
-       else
-#endif
-               free(blk.buf);
-}
-

 static int
 static int

-read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
+read_whole_file(struct mparse *curp, const char *file, int fd,
+               struct buf *fb, int *with_mmap)

 {
        size_t           off;
        ssize_t          ssz;
 
 {
        size_t           off;
        ssize_t          ssz;
 

-#ifdef HAVE_MMAP
+#if HAVE_MMAP

        struct stat      st;
        if (-1 == fstat(fd, &st)) {
        struct stat      st;
        if (-1 == fstat(fd, &st)) {

-               perror(file);
+               curp->file_status = MANDOCLEVEL_SYSERR;
+               if (curp->mmsg)
+                       (*curp->mmsg)(MANDOCERR_SYSSTAT, curp->file_status,
+                           file, 0, 0, strerror(errno));

                return(0);
        }
 
                return(0);
        }
 


@@ -566,13 +627,15 @@ read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
 
        if (S_ISREG(st.st_mode)) {
                if (st.st_size >= (1U << 31)) {
 
        if (S_ISREG(st.st_mode)) {
                if (st.st_size >= (1U << 31)) {

-                       fprintf(stderr, "%s: input too large\n", file);
+                       curp->file_status = MANDOCLEVEL_FATAL;
+                       if (curp->mmsg)
+                               (*curp->mmsg)(MANDOCERR_TOOLARGE,
+                                   curp->file_status, file, 0, 0, NULL);

                        return(0);
                }
                *with_mmap = 1;
                fb->sz = (size_t)st.st_size;
                        return(0);
                }
                *with_mmap = 1;
                fb->sz = (size_t)st.st_size;

-               fb->buf = mmap(NULL, fb->sz, PROT_READ, 
-                               MAP_FILE|MAP_SHARED, fd, 0);
+               fb->buf = mmap(NULL, fb->sz, PROT_READ, MAP_SHARED, fd, 0);

                if (fb->buf != MAP_FAILED)
                        return(1);
        }
                if (fb->buf != MAP_FAILED)
                        return(1);
        }


@@ -590,7 +653,11 @@ read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
        for (;;) {
                if (off == fb->sz) {
                        if (fb->sz == (1U << 31)) {
        for (;;) {
                if (off == fb->sz) {
                        if (fb->sz == (1U << 31)) {

-                               fprintf(stderr, "%s: input too large\n", file);
+                               curp->file_status = MANDOCLEVEL_FATAL;
+                               if (curp->mmsg)
+                                       (*curp->mmsg)(MANDOCERR_TOOLARGE,
+                                           curp->file_status,
+                                           file, 0, 0, NULL);

                                break;
                        }
                        resize_buf(fb, 65536);
                                break;
                        }
                        resize_buf(fb, 65536);


@@ -601,7 +668,11 @@ read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
                        return(1);
                }
                if (ssz == -1) {
                        return(1);
                }
                if (ssz == -1) {

-                       perror(file);
+                       curp->file_status = MANDOCLEVEL_SYSERR;
+                       if (curp->mmsg)
+                               (*curp->mmsg)(MANDOCERR_SYSREAD,
+                                   curp->file_status, file, 0, 0,
+                                   strerror(errno));

                        break;
                }
                off += (size_t)ssz;
                        break;
                }
                off += (size_t)ssz;


@@ -619,6 +690,20 @@ mparse_end(struct mparse *curp)
        if (MANDOCLEVEL_FATAL <= curp->file_status)
                return;
 
        if (MANDOCLEVEL_FATAL <= curp->file_status)
                return;
 

+       if (curp->mdoc == NULL &&
+           curp->man == NULL &&
+           curp->sodest == NULL) {
+               if (curp->options & MPARSE_MDOC)
+                       curp->mdoc = curp->pmdoc;
+               else {
+                       if (curp->pman == NULL)
+                               curp->pman = man_alloc(
+                                   curp->roff, curp, curp->defos,
+                                   curp->options & MPARSE_QUICK ? 1 : 0);
+                       curp->man = curp->pman;
+               }
+       }
+

        if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
                assert(MANDOCLEVEL_FATAL <= curp->file_status);
                return;
        if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
                assert(MANDOCLEVEL_FATAL <= curp->file_status);
                return;


@@ -629,51 +714,215 @@ mparse_end(struct mparse *curp)
                return;
        }
 
                return;
        }
 

-       if ( ! (curp->man || curp->mdoc)) {
-               mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL);
-               curp->file_status = MANDOCLEVEL_FATAL;
-               return;
-       }
-

        roff_endparse(curp->roff);
 }
 
 static void
        roff_endparse(curp->roff);
 }
 
 static void

-mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re)
+mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file)

 {
 {

+       struct buf      *svprimary;

        const char      *svfile;
        const char      *svfile;

+       size_t           offset;
+       static int       recursion_depth;

 
 

-       if (-1 == fd)
-               if (-1 == (fd = open(file, O_RDONLY, 0))) {
-                       perror(file);
-                       curp->file_status = MANDOCLEVEL_SYSERR;
-                       return;
-               }
+       if (64 < recursion_depth) {
+               mandoc_msg(MANDOCERR_ROFFLOOP, curp, curp->line, 0, NULL);
+               return;
+       }

 
 

+       /* Line number is per-file. */

        svfile = curp->file;
        curp->file = file;
        svfile = curp->file;
        curp->file = file;

+       svprimary = curp->primary;
+       curp->primary = &blk;
+       curp->line = 1;
+       recursion_depth++;

 
 

-       pdesc(curp, file, fd);
+       /* Skip an UTF-8 byte order mark. */
+       if (curp->filenc & MPARSE_UTF8 && blk.sz > 2 &&
+           (unsigned char)blk.buf[0] == 0xef &&
+           (unsigned char)blk.buf[1] == 0xbb &&
+           (unsigned char)blk.buf[2] == 0xbf) {
+               offset = 3;
+               curp->filenc &= ~MPARSE_LATIN1;
+       } else
+               offset = 0;

 
 

-       if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)
-               mparse_end(curp);
+       mparse_buf_r(curp, blk, offset, 1);

 
 

-       if (STDIN_FILENO != fd && -1 == close(fd))
-               perror(file);
+       if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status)
+               mparse_end(curp);

 
 

+       curp->primary = svprimary;

        curp->file = svfile;
 }
 
        curp->file = svfile;
 }
 

+enum mandoclevel
+mparse_readmem(struct mparse *curp, void *buf, size_t len,
+               const char *file)
+{
+       struct buf blk;
+
+       blk.buf = buf;
+       blk.sz = len;
+
+       mparse_parse_buffer(curp, blk, file);
+       return(curp->file_status);
+}
+
+/*
+ * If a file descriptor is given, use it and assume it points
+ * to the named file.  Otherwise, open the named file.
+ * Read the whole file into memory and call the parsers.
+ * Called recursively when an .so request is encountered.
+ */

 enum mandoclevel
 mparse_readfd(struct mparse *curp, int fd, const char *file)
 {
 enum mandoclevel
 mparse_readfd(struct mparse *curp, int fd, const char *file)
 {

+       struct buf       blk;
+       int              with_mmap;
+       int              save_filenc;
+       pid_t            save_child;
+
+       save_child = curp->child;
+       if (fd != -1)
+               curp->child = 0;
+       else if (mparse_open(curp, &fd, file) >= MANDOCLEVEL_SYSERR)
+               goto out;
+
+       if (read_whole_file(curp, file, fd, &blk, &with_mmap)) {
+               save_filenc = curp->filenc;
+               curp->filenc = curp->options &
+                   (MPARSE_UTF8 | MPARSE_LATIN1);
+               mparse_parse_buffer(curp, blk, file);
+               curp->filenc = save_filenc;
+#if HAVE_MMAP
+               if (with_mmap)
+                       munmap(blk.buf, blk.sz);
+               else
+#endif
+                       free(blk.buf);
+       }
+
+       if (fd != STDIN_FILENO && close(fd) == -1)
+               perror(file);
+
+       mparse_wait(curp);
+out:
+       curp->child = save_child;
+       return(curp->file_status);
+}
+
+enum mandoclevel
+mparse_open(struct mparse *curp, int *fd, const char *file)
+{
+       int               pfd[2];
+       int               save_errno;
+       char             *cp;
+       enum mandocerr    err;
+
+       pfd[1] = -1;
+       curp->file = file;
+
+       /* Unless zipped, try to just open the file. */
+
+       if ((cp = strrchr(file, '.')) == NULL ||
+           strcmp(cp + 1, "gz")) {
+               curp->child = 0;
+               if ((*fd = open(file, O_RDONLY)) != -1)
+                       return(MANDOCLEVEL_OK);
+
+               /* Open failed; try to append ".gz". */

 
 

-       mparse_readfd_r(curp, fd, file, 0);
+               mandoc_asprintf(&cp, "%s.gz", file);
+               file = cp;
+       } else
+               cp = NULL;
+
+       /* Before forking, make sure the file can be read. */
+
+       save_errno = errno;
+       if (access(file, R_OK) == -1) {
+               if (cp != NULL)
+                       errno = save_errno;
+               err = MANDOCERR_SYSOPEN;
+               goto out;
+       }
+
+       /* Run gunzip(1). */
+
+       if (pipe(pfd) == -1) {
+               err = MANDOCERR_SYSPIPE;
+               goto out;
+       }
+
+       switch (curp->child = fork()) {
+       case -1:
+               err = MANDOCERR_SYSFORK;
+               close(pfd[0]);
+               close(pfd[1]);
+               pfd[1] = -1;
+               break;
+       case 0:
+               close(pfd[0]);
+               if (dup2(pfd[1], STDOUT_FILENO) == -1) {
+                       err = MANDOCERR_SYSDUP;
+                       break;
+               }
+               execlp("gunzip", "gunzip", "-c", file, NULL);
+               err = MANDOCERR_SYSEXEC;
+               break;
+       default:
+               close(pfd[1]);
+               *fd = pfd[0];
+               return(MANDOCLEVEL_OK);
+       }
+
+out:
+       free(cp);
+       *fd = -1;
+       curp->child = 0;
+       curp->file_status = MANDOCLEVEL_SYSERR;
+       if (curp->mmsg)
+               (*curp->mmsg)(err, curp->file_status, curp->file,
+                   0, 0, strerror(errno));
+       if (pfd[1] != -1)
+               exit(1);

        return(curp->file_status);
 }
 
        return(curp->file_status);
 }
 

+enum mandoclevel
+mparse_wait(struct mparse *curp)
+{
+       int       status;
+
+       if (curp->child == 0)
+               return(MANDOCLEVEL_OK);
+
+       if (waitpid(curp->child, &status, 0) == -1) {
+               mandoc_msg(MANDOCERR_SYSWAIT, curp, 0, 0,
+                   strerror(errno));
+               curp->file_status = MANDOCLEVEL_SYSERR;
+               return(curp->file_status);
+       }
+       if (WIFSIGNALED(status)) {
+               mandoc_vmsg(MANDOCERR_SYSSIG, curp, 0, 0,
+                   "%d", WTERMSIG(status));
+               curp->file_status = MANDOCLEVEL_SYSERR;
+               return(curp->file_status);
+       }
+       if (WEXITSTATUS(status)) {
+               mandoc_vmsg(MANDOCERR_SYSEXIT, curp, 0, 0,
+                   "%d", WEXITSTATUS(status));
+               curp->file_status = MANDOCLEVEL_SYSERR;
+               return(curp->file_status);
+       }
+       return(MANDOCLEVEL_OK);
+}
+

 struct mparse *
 struct mparse *

-mparse_alloc(enum mparset inttype, enum mandoclevel wlevel, mandocmsg mmsg, void *arg)
+mparse_alloc(int options, enum mandoclevel wlevel, mandocmsg mmsg,
+    const struct mchars *mchars, const char *defos)

 {
        struct mparse   *curp;
 
 {
        struct mparse   *curp;
 


@@ -681,12 +930,22 @@ mparse_alloc(enum mparset inttype, enum mandoclevel wlevel, mandocmsg mmsg, void
 
        curp = mandoc_calloc(1, sizeof(struct mparse));
 
 
        curp = mandoc_calloc(1, sizeof(struct mparse));
 

+       curp->options = options;

        curp->wlevel = wlevel;
        curp->mmsg = mmsg;
        curp->wlevel = wlevel;
        curp->mmsg = mmsg;

-       curp->arg = arg;
-       curp->inttype = inttype;
+       curp->defos = defos;
+
+       curp->mchars = mchars;
+       curp->roff = roff_alloc(curp, curp->mchars, options);
+       if (curp->options & MPARSE_MDOC)
+               curp->pmdoc = mdoc_alloc(
+                   curp->roff, curp, curp->defos,
+                   curp->options & MPARSE_QUICK ? 1 : 0);
+       if (curp->options & MPARSE_MAN)
+               curp->pman = man_alloc(
+                   curp->roff, curp, curp->defos,
+                   curp->options & MPARSE_QUICK ? 1 : 0);

 
 

-       curp->roff = roff_alloc(curp);

        return(curp);
 }
 
        return(curp);
 }
 


@@ -700,10 +959,15 @@ mparse_reset(struct mparse *curp)
                mdoc_reset(curp->mdoc);
        if (curp->man)
                man_reset(curp->man);
                mdoc_reset(curp->mdoc);
        if (curp->man)
                man_reset(curp->man);

+       if (curp->secondary)
+               curp->secondary->sz = 0;

 
        curp->file_status = MANDOCLEVEL_OK;
        curp->mdoc = NULL;
        curp->man = NULL;
 
        curp->file_status = MANDOCLEVEL_OK;
        curp->mdoc = NULL;
        curp->man = NULL;

+
+       free(curp->sodest);
+       curp->sodest = NULL;

 }
 
 void
 }
 
 void


@@ -716,14 +980,24 @@ mparse_free(struct mparse *curp)
                man_free(curp->pman);
        if (curp->roff)
                roff_free(curp->roff);
                man_free(curp->pman);
        if (curp->roff)
                roff_free(curp->roff);

+       if (curp->secondary)
+               free(curp->secondary->buf);

 
 

+       free(curp->secondary);
+       free(curp->sodest);

        free(curp);
 }
 
 void
        free(curp);
 }
 
 void

-mparse_result(struct mparse *curp, struct mdoc **mdoc, struct man **man)
+mparse_result(struct mparse *curp,
+       struct mdoc **mdoc, struct man **man, char **sodest)

 {
 
 {
 

+       if (sodest && NULL != (*sodest = curp->sodest)) {
+               *mdoc = NULL;
+               *man = NULL;
+               return;
+       }

        if (mdoc)
                *mdoc = curp->mdoc;
        if (man)
        if (mdoc)
                *mdoc = curp->mdoc;
        if (man)


@@ -738,14 +1012,14 @@ mandoc_vmsg(enum mandocerr t, struct mparse *m,
        va_list          ap;
 
        va_start(ap, fmt);
        va_list          ap;
 
        va_start(ap, fmt);

-       vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
+       (void)vsnprintf(buf, sizeof(buf), fmt, ap);

        va_end(ap);
 
        mandoc_msg(t, m, ln, pos, buf);
 }
 
 void
        va_end(ap);
 
        mandoc_msg(t, m, ln, pos, buf);
 }
 
 void

-mandoc_msg(enum mandocerr er, struct mparse *m, 
+mandoc_msg(enum mandocerr er, struct mparse *m,

                int ln, int col, const char *msg)
 {
        enum mandoclevel level;
                int ln, int col, const char *msg)
 {
        enum mandoclevel level;


@@ -776,3 +1050,19 @@ mparse_strlevel(enum mandoclevel lvl)
 {
        return(mandoclevels[lvl]);
 }
 {
        return(mandoclevels[lvl]);
 }

+
+void
+mparse_keep(struct mparse *p)
+{
+
+       assert(NULL == p->secondary);
+       p->secondary = mandoc_calloc(1, sizeof(struct buf));
+}
+
+const char *
+mparse_getkeep(const struct mparse *p)
+{
+
+       assert(p->secondary);
+       return(p->secondary->sz ? p->secondary->buf : NULL);
+}