Allow `Bd' to accept (warn about then ignore) in-line arguments.

[mandoc.git] / man.c

diff --git a/man.c b/man.c
index 9dceb79010846daa29cbb61e48f00a73fd51bd22..b1853d1a08d6acb7ae85e4d28620bacc82cb8584 100644 (file)
--- a/man.c
+++ b/man.c
@@ -1,4 +1,4 @@
-/*     $Id: man.c,v 1.55 2010/03/27 10:04:56 kristaps Exp $ */
+/*     $Id: man.c,v 1.59 2010/03/29 10:10:35 kristaps Exp $ */
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -478,23 +478,25 @@ macrowarn(struct man *m, int ln, const char *buf)
 int
 man_pmacro(struct man *m, int ln, char *buf)
 {
-       int              i, j, ppos, fl;
+       int              i, j, ppos;
        enum mant        tok;
        char             mac[5];
        struct man_node *n;
 
        /* Comments and empties are quickly ignored. */
 
-       fl = m->flags;
-
        if ('\0' == buf[1])
                return(1);
 
        i = 1;
 
-       if (' ' == buf[i]) {
+       /*
+        * Skip whitespace between the control character and initial
+        * text.  "Whitespace" is both spaces and tabs.
+        */
+       if (' ' == buf[i] || '\t' == buf[i]) {
                i++;
-               while (buf[i] && ' ' == buf[i])
+               while (buf[i] && (' ' == buf[i] || '\t' == buf[i]))
                        i++;
                if ('\0' == buf[i])
                        goto out;
@@ -550,6 +552,9 @@ man_pmacro(struct man *m, int ln, char *buf)
         * Remove prior ELINE macro, as it's being clobbering by a new
         * macro.  Note that NSCOPED macros do not close out ELINE
         * macros---they don't print text---so we let those slip by.
+        * NOTE: we don't allow roff blocks (NOCLOSE) to be embedded
+        * here because that would stipulate blocks as children of
+        * elements!
         */
 
        if ( ! (MAN_NSCOPED & man_macros[tok].flags) &&
@@ -581,10 +586,18 @@ man_pmacro(struct man *m, int ln, char *buf)
                m->flags &= ~MAN_ELINE;
        }
 
-       /* Begin recursive parse sequence. */
+       /*
+        * Save the fact that we're in the next-line for a block.  In
+        * this way, embedded roff instructions can "remember" state
+        * when they exit.
+        */
+
+       if (MAN_BLINE & m->flags)
+               m->flags |= MAN_BPLINE;
 
-       assert(man_macros[tok].fp);
+       /* Call to handler... */
 
+       assert(man_macros[tok].fp);
        if ( ! (*man_macros[tok].fp)(m, tok, ln, ppos, &i, buf))
                goto err;
 
@@ -592,15 +605,13 @@ out:
        /* 
         * We weren't in a block-line scope when entering the
         * above-parsed macro, so return.
-        *
-        * FIXME: this prohibits the nesting of blocks (e.g., `de' and
-        * family) within BLINE or ELINE systems.  This is annoying.
         */
 
-       if ( ! (MAN_BLINE & fl)) {
+       if ( ! (MAN_BPLINE & m->flags)) {
                m->flags &= ~MAN_ILINE; 
                return(1);
        }
+       m->flags &= ~MAN_BPLINE;
 
        /*
         * If we're in a block scope, then allow this macro to slip by