Stop parsing man(7) input when we found all we were searching for,

[mandoc.git] / read.c

diff --git a/read.c b/read.c
index c79f080fd7d087e894ac5a5642f9975d930296fb..511ba7dc466deba542e433a2ef1f454785f769e3 100644 (file)
--- a/read.c
+++ b/read.c
@@ -1,7 +1,7 @@
-/*     $Id: read.c,v 1.20 2011/07/21 12:30:44 kristaps Exp $ */
+/*     $Id: read.c,v 1.39 2013/09/16 00:25:07 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, 2011, 2012, 2013 Ingo Schwarze <schwarze@openbsd.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


@@ -28,6 +28,7 @@
 #include <ctype.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <ctype.h>
 #include <fcntl.h>
 #include <stdarg.h>

+#include <stdint.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>


@@ -37,10 +38,7 @@
 #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
+#include "main.h"

 
 #define        REPARSE_LIMIT   1000
 
 
 #define        REPARSE_LIMIT   1000
 


@@ -63,15 +61,17 @@ struct      mparse {
        mandocmsg         mmsg; /* warning/error message handler */
        void             *arg; /* argument to mmsg */
        const char       *file; 
        mandocmsg         mmsg; /* warning/error message handler */
        void             *arg; /* argument to mmsg */
        const char       *file; 

+       struct buf       *secondary;
+       char             *defos; /* default operating system */

 };
 
 static void      resize_buf(struct buf *, size_t);
 static void      mparse_buf_r(struct mparse *, struct buf, int);
 };
 
 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      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_end(struct mparse *);
 static int       read_whole_file(const char *, int, struct buf *, int *);
 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,


@@ -92,6 +92,7 @@ static        const char * const      mandocerrs[MANDOCERR_MAX] = {
        "no title in document",
        "document title should be all caps",
        "unknown manual section",
        "no title in document",
        "document title should be all caps",
        "unknown manual section",

+       "unknown manual volume or arch",

        "date missing, using today's date",
        "cannot parse date, using it verbatim",
        "prologue macros out of order",
        "date missing, using today's date",
        "cannot parse date, using it verbatim",
        "prologue macros out of order",


@@ -103,14 +104,14 @@ static    const char * const      mandocerrs[MANDOCERR_MAX] = {
        ".so is fragile, better use ln(1)",
        "NAME section must come first",
        "bad NAME section contents",
        ".so is fragile, better use ln(1)",
        "NAME section must come first",
        "bad NAME section contents",

-       "manual name not yet set",

        "sections out of conventional order",
        "duplicate section name",
        "sections out of conventional order",
        "duplicate section name",

-       "section not in conventional manual section",
+       "section header suited to sections 2, 3, and 9 only",

 
        /* related to macros and nesting */
        "skipping obsolete macro",
        "skipping paragraph macro",
 
        /* related to macros and nesting */
        "skipping obsolete macro",
        "skipping paragraph macro",

+       "moving paragraph macro out of list",

        "skipping no-space macro",
        "blocks badly nested",
        "child violates parent syntax",
        "skipping no-space macro",
        "blocks badly nested",
        "child violates parent syntax",


@@ -152,10 +153,11 @@ static    const char * const      mandocerrs[MANDOCERR_MAX] = {
        "generic error",
 
        /* related to equations */
        "generic error",
 
        /* related to equations */

-       "bad equation macro syntax",
-       "too many nested equation defines",

        "unexpected equation scope closure",
        "equation scope open on exit",
        "unexpected equation scope closure",
        "equation scope open on exit",

+       "overlapping equation scopes",
+       "unexpected end of equation",
+       "equation syntax error",

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


@@ -170,10 +172,12 @@ static    const char * const      mandocerrs[MANDOCERR_MAX] = {
        "input stack limit exceeded, infinite loop?",
        "skipping bad character",
        "escaped character not allowed in a name",
        "input stack limit exceeded, infinite loop?",
        "skipping bad character",
        "escaped character not allowed in a name",

+       "manual name not yet set",

        "skipping text before the first section header",
        "skipping unknown macro",
        "NOT IMPLEMENTED, please use groff: skipping request",
        "argument count wrong",
        "skipping text before the first section header",
        "skipping unknown macro",
        "NOT IMPLEMENTED, please use groff: skipping request",
        "argument count wrong",

+       "skipping column outside column list",

        "skipping end of block that is not open",
        "missing end of block",
        "scope open on exit",
        "skipping end of block that is not open",
        "missing end of block",
        "scope open on exit",


@@ -181,6 +185,7 @@ static      const char * const      mandocerrs[MANDOCERR_MAX] = {
        "macro requires line argument(s)",
        "macro requires body argument(s)",
        "macro requires argument(s)",
        "macro requires line argument(s)",
        "macro requires body argument(s)",
        "macro requires argument(s)",

+       "request requires a numeric argument",

        "missing list type",
        "line argument(s) will be lost",
        "body argument(s) will be lost",
        "missing list type",
        "line argument(s) will be lost",
        "body argument(s) will be lost",


@@ -190,7 +195,6 @@ static      const char * const      mandocerrs[MANDOCERR_MAX] = {
        "not a manual",
        "column syntax is inconsistent",
        "NOT IMPLEMENTED: .Bd -file",
        "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",
        "argument count wrong, violates syntax",
        "child violates parent syntax",
        "argument count wrong, violates syntax",


@@ -245,7 +249,8 @@ pset(const char *buf, int pos, struct mparse *curp)
        switch (curp->inttype) {
        case (MPARSE_MDOC):
                if (NULL == curp->pmdoc) 
        switch (curp->inttype) {
        case (MPARSE_MDOC):
                if (NULL == curp->pmdoc) 

-                       curp->pmdoc = mdoc_alloc(curp->roff, curp);
+                       curp->pmdoc = mdoc_alloc(curp->roff, curp,
+                                       curp->defos);

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


@@ -261,7 +266,8 @@ pset(const char *buf, int pos, struct mparse *curp)
 
        if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
                if (NULL == curp->pmdoc) 
 
        if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
                if (NULL == curp->pmdoc) 

-                       curp->pmdoc = mdoc_alloc(curp->roff, curp);
+                       curp->pmdoc = mdoc_alloc(curp->roff, curp,
+                                       curp->defos);

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


@@ -320,13 +326,22 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                                break;
                        }
 
                                break;
                        }
 

+                       /*
+                        * Make sure we have space for at least
+                        * one backslash and one other character
+                        * and the trailing NUL byte.
+                        */
+
+                       if (pos + 2 >= (int)ln.sz)
+                               resize_buf(&ln, 256);
+

                        /* 
                         * Warn about bogus characters.  If you're using
                         * non-ASCII encoding, you're screwing your
                         * readers.  Since I'd rather this not happen,
                        /* 
                         * 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.
+                        * I'll be helpful and replace these characters
+                        * with "?", so we don't display gibberish.
+                        * Note to manual writers: use special characters.

                         */
 
                        c = (unsigned char) blk.buf[i];
                         */
 
                        c = (unsigned char) blk.buf[i];


@@ -334,16 +349,15 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                        if ( ! (isascii(c) && 
                                        (isgraph(c) || isblank(c)))) {
                                mandoc_msg(MANDOCERR_BADCHAR, curp,
                        if ( ! (isascii(c) && 
                                        (isgraph(c) || isblank(c)))) {
                                mandoc_msg(MANDOCERR_BADCHAR, curp,

-                                               curp->line, pos, "ignoring byte");
+                                               curp->line, pos, NULL);

                                i++;
                                i++;

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

                                continue;
                        }
 
                        /* Trailing backslash = a plain char. */
 
                        if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
                                continue;
                        }
 
                        /* Trailing backslash = a plain char. */
 
                        if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {

-                               if (pos >= (int)ln.sz)
-                                       resize_buf(&ln, 256);

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


@@ -385,10 +399,20 @@ 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_msg(MANDOCERR_BADCHAR, curp,
+                                               curp->line, pos, NULL);
+                               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++];


@@ -410,6 +434,27 @@ 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:
                rr = roff_parseln
                        (curp->roff, curp->line, 
 rerun:
                rr = roff_parseln
                        (curp->roff, curp->line, 


@@ -436,7 +481,14 @@ rerun:
                        assert(MANDOCLEVEL_FATAL <= curp->file_status);
                        break;
                case (ROFF_SO):
                        assert(MANDOCLEVEL_FATAL <= curp->file_status);
                        break;
                case (ROFF_SO):

-                       mparse_readfd_r(curp, -1, ln.buf + of, 1);
+                       /*
+                        * 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)
                                break;
                        pos = 0;
                        if (MANDOCLEVEL_FATAL <= curp->file_status)
                                break;
                        pos = 0;


@@ -515,38 +567,6 @@ 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
 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
 {
 static int
 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
 {


@@ -574,8 +594,7 @@ read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
                }
                *with_mmap = 1;
                fb->sz = (size_t)st.st_size;
                }
                *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);
        }


@@ -642,41 +661,85 @@ mparse_end(struct mparse *curp)
 }
 
 static void
 }
 
 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)

 {
        const char      *svfile;
 {
        const char      *svfile;

+       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;

+       curp->line = 1;
+       recursion_depth++;

 
 

-       pdesc(curp, file, fd);
+       mparse_buf_r(curp, blk, 1);

 
 

-       if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)
+       if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status)

                mparse_end(curp);
 
                mparse_end(curp);
 

-       if (STDIN_FILENO != fd && -1 == close(fd))
-               perror(file);
-

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

+enum mandoclevel
+mparse_readmem(struct mparse *curp, const void *buf, size_t len,
+               const char *file)
+{
+       struct buf blk;
+
+       blk.buf = UNCONST(buf);
+       blk.sz = len;
+
+       mparse_parse_buffer(curp, blk, file);
+       return(curp->file_status);
+}
+

 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;
+
+       if (-1 == fd)
+               if (-1 == (fd = open(file, O_RDONLY, 0))) {
+                       perror(file);
+                       curp->file_status = MANDOCLEVEL_SYSERR;
+                       goto out;
+               }
+       /*
+        * 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.
+        */

 
 

-       mparse_readfd_r(curp, fd, file, 0);
+       if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {
+               curp->file_status = MANDOCLEVEL_SYSERR;
+               goto out;
+       }
+
+       mparse_parse_buffer(curp, blk, file);
+
+#ifdef HAVE_MMAP
+       if (with_mmap)
+               munmap(blk.buf, blk.sz);
+       else
+#endif
+               free(blk.buf);
+
+       if (STDIN_FILENO != fd && -1 == close(fd))
+               perror(file);
+out:

        return(curp->file_status);
 }
 
 struct mparse *
        return(curp->file_status);
 }
 
 struct mparse *

-mparse_alloc(enum mparset inttype, enum mandoclevel wlevel, mandocmsg mmsg, void *arg)
+mparse_alloc(enum mparset inttype, enum mandoclevel wlevel,
+               mandocmsg mmsg, void *arg, char *defos)

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


@@ -688,8 +751,9 @@ mparse_alloc(enum mparset inttype, enum mandoclevel wlevel, mandocmsg mmsg, void
        curp->mmsg = mmsg;
        curp->arg = arg;
        curp->inttype = inttype;
        curp->mmsg = mmsg;
        curp->arg = arg;
        curp->inttype = inttype;

+       curp->defos = defos;

 
 

-       curp->roff = roff_alloc(curp);
+       curp->roff = roff_alloc(inttype, curp);

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


@@ -703,6 +767,8 @@ 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->file_status = MANDOCLEVEL_OK;
        curp->mdoc = NULL;


@@ -719,7 +785,10 @@ 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);
 }
 
        free(curp);
 }
 


@@ -779,3 +848,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);
+}