fix -Tascii .Fd line breaking

[mandoc.git] / read.c

diff --git a/read.c b/read.c
index 6c240c2bd2ba188798c0025f45f1087cd84d251e..5b51091c62ed92e1f70fc2ff8fb8d147013850c8 100644 (file)
--- a/read.c
+++ b/read.c
@@ -1,4 +1,4 @@
-/*     $Id: read.c,v 1.10 2011/04/03 10:11:25 kristaps Exp $ */
+/*     $Id: read.c,v 1.29 2012/05/27 17:48:57 schwarze Exp $ */

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


@@ -15,13 +15,20 @@
  * 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.
  */

-#include <sys/stat.h>
-#include <sys/mman.h>
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_MMAP
+# include <sys/stat.h>
+# include <sys/mman.h>
+#endif

 
 #include <assert.h>
 #include <ctype.h>
 #include <fcntl.h>
 #include <stdarg.h>
 
 #include <assert.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>


@@ -31,6 +38,7 @@
 #include "libmandoc.h"
 #include "mdoc.h"
 #include "man.h"
 #include "libmandoc.h"
 #include "mdoc.h"
 #include "man.h"

+#include "main.h"

 
 #ifndef MAP_FILE
 #define        MAP_FILE        0
 
 #ifndef MAP_FILE
 #define        MAP_FILE        0


@@ -53,18 +61,18 @@ struct      mparse {
        struct man       *man; /* man parser */
        struct mdoc      *mdoc; /* mdoc parser */
        struct roff      *roff; /* roff parser (!NULL) */
        struct man       *man; /* man parser */
        struct mdoc      *mdoc; /* mdoc parser */
        struct roff      *roff; /* roff parser (!NULL) */

-       struct regset     regs; /* roff registers */

        int               reparse_count; /* finite interp. stack */
        mandocmsg         mmsg; /* warning/error message handler */
        void             *arg; /* argument to mmsg */
        const char       *file; 
        int               reparse_count; /* finite interp. stack */
        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      mparse_readfd_r(struct mparse *, int, const char *, int);
 static void      pset(const char *, int, struct mparse *);
 };
 
 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_end(struct mparse *);
 
 static int       read_whole_file(const char *, int, struct buf *, int *);
 static void      mparse_end(struct mparse *);
 


@@ -138,11 +146,21 @@ static    const char * const      mandocerrs[MANDOCERR_MAX] = {
        "tab in non-literal context",
        "end of line whitespace",
        "bad comment style",
        "tab in non-literal context",
        "end of line whitespace",
        "bad comment style",

-       "unknown escape sequence",
+       "bad escape sequence",

        "unterminated quoted string",
        "unterminated quoted string",

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

        
        "generic error",
 
        
        "generic error",
 

+       /* related to equations */
+       "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",
        "bad table option",
        /* related to tables */
        "bad table syntax",
        "bad table option",


@@ -176,7 +194,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",


@@ -231,13 +248,14 @@ 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->regs, curp);
+                       curp->pmdoc = mdoc_alloc(curp->roff, curp,
+                                       curp->defos);

                assert(curp->pmdoc);
                curp->mdoc = curp->pmdoc;
                return;
        case (MPARSE_MAN):
                if (NULL == curp->pman) 
                assert(curp->pmdoc);
                curp->mdoc = curp->pmdoc;
                return;
        case (MPARSE_MAN):
                if (NULL == curp->pman) 

-                       curp->pman = man_alloc(&curp->regs, curp);
+                       curp->pman = man_alloc(curp->roff, curp);

                assert(curp->pman);
                curp->man = curp->pman;
                return;
                assert(curp->pman);
                curp->man = curp->pman;
                return;


@@ -247,14 +265,15 @@ 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->regs, curp);
+                       curp->pmdoc = mdoc_alloc(curp->roff, curp,
+                                       curp->defos);

                assert(curp->pmdoc);
                curp->mdoc = curp->pmdoc;
                return;
        } 
 
        if (NULL == curp->pman) 
                assert(curp->pmdoc);
                curp->mdoc = curp->pmdoc;
                return;
        } 
 
        if (NULL == curp->pman) 

-               curp->pman = man_alloc(&curp->regs, curp);
+               curp->pman = man_alloc(curp->roff, curp);

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


@@ -310,9 +329,9 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                         * 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];


@@ -320,8 +339,11 @@ 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++;

+                               if (pos >= (int)ln.sz)
+                                       resize_buf(&ln, 256);
+                               ln.buf[pos++] = '?';

                                continue;
                        }
 
                                continue;
                        }
 


@@ -350,7 +372,7 @@ mparse_buf_r(struct mparse *curp, struct buf blk, int start)
                                continue;
                        }
 
                                continue;
                        }
 

-                       if ('"' == blk.buf[i + 1]) {
+                       if ('"' == blk.buf[i + 1] || '#' == blk.buf[i + 1]) {

                                i += 2;
                                /* Comment, skip to end of line */
                                for (; i < (int)blk.sz; ++i) {
                                i += 2;
                                /* Comment, skip to end of line */
                                for (; i < (int)blk.sz; ++i) {


@@ -396,6 +418,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, 


@@ -422,6 +465,13 @@ rerun:
                        assert(MANDOCLEVEL_FATAL <= curp->file_status);
                        break;
                case (ROFF_SO):
                        assert(MANDOCLEVEL_FATAL <= curp->file_status);
                        break;
                case (ROFF_SO):

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


@@ -441,7 +491,7 @@ rerun:
 
                /*
                 * If input parsers have not been allocated, do so now.
 
                /*
                 * If input parsers have not been allocated, do so now.

-                * We keep these instanced betwen parsers, but set them
+                * We keep these instanced between parsers, but set them

                 * locally per parse routine since we can use different
                 * parsers with each one.
                 */
                 * locally per parse routine since we can use different
                 * parsers with each one.
                 */


@@ -501,43 +551,14 @@ 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);
-
-       if (with_mmap)
-               munmap(blk.buf, blk.sz);
-       else
-               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)
 {

-       struct stat      st;

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

+#ifdef HAVE_MMAP
+       struct stat      st;

        if (-1 == fstat(fd, &st)) {
                perror(file);
                return(0);
        if (-1 == fstat(fd, &st)) {
                perror(file);
                return(0);


@@ -562,6 +583,7 @@ read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
                if (fb->buf != MAP_FAILED)
                        return(1);
        }
                if (fb->buf != MAP_FAILED)
                        return(1);
        }

+#endif

 
        /*
         * If this isn't a regular file (like, say, stdin), then we must
 
        /*
         * If this isn't a regular file (like, say, stdin), then we must


@@ -624,29 +646,72 @@ 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,
+               int re)

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

+       /* Line number is per-file. */
+       svfile = curp->file;
+       curp->file = file;
+       curp->line = 1;
+
+       mparse_buf_r(curp, blk, 1);
+
+       if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)
+               mparse_end(curp);
+
+       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, 0);
+       return(curp->file_status);
+}
+
+static void
+mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re)
+{
+       struct buf       blk;
+       int              with_mmap;
+

        if (-1 == fd)
                if (-1 == (fd = open(file, O_RDONLY, 0))) {
                        perror(file);
                        curp->file_status = MANDOCLEVEL_SYSERR;
                        return;
                }
        if (-1 == fd)
                if (-1 == (fd = open(file, O_RDONLY, 0))) {
                        perror(file);
                        curp->file_status = MANDOCLEVEL_SYSERR;
                        return;
                }

+       /*
+        * 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.
+        */

 
 

-       svfile = curp->file;
-       curp->file = file;
+       if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {
+               curp->file_status = MANDOCLEVEL_SYSERR;
+               return;
+       }

 
 

-       pdesc(curp, file, fd);
+       mparse_parse_buffer(curp, blk, file, re);

 
 

-       if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)
-               mparse_end(curp);
+#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);
 
        if (STDIN_FILENO != fd && -1 == close(fd))
                perror(file);

-
-       curp->file = svfile;

 }
 
 enum mandoclevel
 }
 
 enum mandoclevel


@@ -658,7 +723,8 @@ mparse_readfd(struct mparse *curp, int fd, const char *file)
 }
 
 struct mparse *
 }
 
 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;
 


@@ -670,8 +736,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->regs, curp);
+       curp->roff = roff_alloc(curp);

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


@@ -679,14 +746,14 @@ void
 mparse_reset(struct mparse *curp)
 {
 
 mparse_reset(struct mparse *curp)
 {
 

-       memset(&curp->regs, 0, sizeof(struct regset));
-

        roff_reset(curp->roff);
 
        if (curp->mdoc)
                mdoc_reset(curp->mdoc);
        if (curp->man)
                man_reset(curp->man);
        roff_reset(curp->roff);
 
        if (curp->mdoc)
                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;


@@ -703,7 +770,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);
 }
 


@@ -763,3 +833,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);
+}