Re-admit the simple case of `.ig' that works with groff's stranger invocations.

[mandoc.git] / main.c

diff --git a/main.c b/main.c
index 2b256d2ce8067971929e91b256814499154a816d..7ad8a3e59d6d906fc70bc0bb26b4e7139a8b157c 100644 (file)
--- a/main.c
+++ b/main.c
@@ -1,4 +1,4 @@
-/*     $Id: main.c,v 1.73 2010/05/15 21:53:11 kristaps Exp $ */
+/*     $Id: main.c,v 1.76 2010/05/16 10:59:36 kristaps Exp $ */
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -386,7 +386,7 @@ static void
 fdesc(struct curparse *curp)
 {
        struct buf       ln, blk;
-       int              i, pos, lnn, lnn_start, with_mmap;
+       int              i, pos, lnn, lnn_start, with_mmap, of;
        enum rofferr     re;
        struct man      *man;
        struct mdoc     *mdoc;
@@ -467,22 +467,42 @@ fdesc(struct curparse *curp)
                                goto bailout;
                ln.buf[pos] = '\0';
 
-               re = roff_parseln(roff, lnn_start, &ln.buf, &ln.sz);
+               /*
+                * A significant amount of complexity is contained by
+                * the roff preprocessor.  It's line-oriented but can be
+                * expressed on one line, so we need at times to
+                * readjust our starting point and re-run it.  The roff
+                * preprocessor can also readjust the buffers with new
+                * data, so we pass them in wholesale.
+                */
+
+               of = 0;
+               do {
+                       re = roff_parseln(roff, lnn_start, 
+                                       &ln.buf, &ln.sz, of, &of);
+               } while (ROFF_RERUN == re);
+
                if (ROFF_IGN == re)
                        continue;
                else if (ROFF_ERR == re)
                        goto bailout;
 
-               /* If unset, assign parser in pset(). */
+               /*
+                * If input parsers have not been allocated, do so now.
+                * We keep these instanced betwen parsers, but set them
+                * locally per parse routine since we can use different
+                * parsers with each one.
+                */
 
-               if ( ! (man || mdoc) && ! pset(ln.buf, pos, curp, &man, &mdoc))
-                       goto bailout;
+               if ( ! (man || mdoc))
+                       if ( ! pset(ln.buf + of, pos - of, curp, &man, &mdoc))
+                               goto bailout;
 
-               /* Pass down into parsers. */
+               /* Lastly, push down into the parsers themselves. */
 
-               if (man && ! man_parseln(man, lnn_start, ln.buf))
+               if (man && ! man_parseln(man, lnn_start, ln.buf, of))
                        goto bailout;
-               if (mdoc && ! mdoc_parseln(mdoc, lnn_start, ln.buf))
+               if (mdoc && ! mdoc_parseln(mdoc, lnn_start, ln.buf, of))
                        goto bailout;
        }
 
@@ -493,6 +513,8 @@ fdesc(struct curparse *curp)
                goto bailout;
        }
 
+       /* Clean up the parse routine ASTs. */
+
        if (mdoc && ! mdoc_endparse(mdoc))
                goto bailout;
        if (man && ! man_endparse(man))
@@ -574,7 +596,7 @@ pset(const char *buf, int pos, struct curparse *curp,
         * default to -man, which is more lenient.
         */
 
-       if (buf[0] == '.') {
+       if ('.' == buf[0] || '\'' == buf[0]) {
                for (i = 1; buf[i]; i++)
                        if (' ' != buf[i] && '\t' != buf[i])
                                break;
@@ -789,6 +811,7 @@ static      const char * const      mandocerrs[MANDOCERR_MAX] = {
 static int
 mmsg(enum mandocerr t, void *arg, int ln, int col, const char *msg)
 {
+#if 0
        struct curparse *cp;
 
        cp = (struct curparse *)arg;
@@ -800,5 +823,6 @@ mmsg(enum mandocerr t, void *arg, int ln, int col, const char *msg)
                fprintf(stderr, ": %s", msg);
 
        fputc('\n', stderr);
+#endif
        return(1);
 }