Fix mdoc bug found by Claus Assmann: `Pf' should be callable.

[mandoc.git] / mdoc_macro.c

diff --git a/mdoc_macro.c b/mdoc_macro.c
index 66e5faf0728275ee199bbcb5ba1f218849db6904..d58825f735d50e50c3dd60b5b36af33c1ee579b2 100644 (file)
--- a/mdoc_macro.c
+++ b/mdoc_macro.c
@@ -1,4 +1,4 @@
-/*     $Id: mdoc_macro.c,v 1.36 2009/09/20 17:24:57 kristaps Exp $ */
+/*     $Id: mdoc_macro.c,v 1.52 2010/04/06 07:17:51 kristaps Exp $ */

 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *


@@ -14,18 +14,26 @@
  * 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"
+#endif
+

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

+#include <time.h>

 
 #include "libmdoc.h"
 
 
 #include "libmdoc.h"
 

-#define        REWIND_REWIND   (1 << 0)
-#define        REWIND_NOHALT   (1 << 1)
-#define        REWIND_HALT     (1 << 2)
+enum   rew {
+       REWIND_REWIND,
+       REWIND_NOHALT,
+       REWIND_HALT
+};

 
 

+static int       ctx_synopsis(MACRO_PROT_ARGS);

 static int       obsolete(MACRO_PROT_ARGS);
 static int       blk_part_exp(MACRO_PROT_ARGS);
 static int       in_line_eoln(MACRO_PROT_ARGS);
 static int       obsolete(MACRO_PROT_ARGS);
 static int       blk_part_exp(MACRO_PROT_ARGS);
 static int       in_line_eoln(MACRO_PROT_ARGS);


@@ -36,13 +44,13 @@ static      int       blk_exp_close(MACRO_PROT_ARGS);
 static int       blk_part_imp(MACRO_PROT_ARGS);
 
 static int       phrase(struct mdoc *, int, int, char *);
 static int       blk_part_imp(MACRO_PROT_ARGS);
 
 static int       phrase(struct mdoc *, int, int, char *);

-static int       rew_dohalt(int, enum mdoc_type, 
+static enum rew  rew_dohalt(enum mdoct, enum mdoc_type, 

                        const struct mdoc_node *);
                        const struct mdoc_node *);

-static int       rew_alt(int);
-static int       rew_dobreak(int, const struct mdoc_node *);
-static int       rew_elem(struct mdoc *, int);
+static enum mdoct rew_alt(enum mdoct);
+static int       rew_dobreak(enum mdoct, const struct mdoc_node *);
+static int       rew_elem(struct mdoc *, enum mdoct);

 static int       rew_sub(enum mdoc_type, struct mdoc *, 
 static int       rew_sub(enum mdoc_type, struct mdoc *, 

-                       int, int, int);
+                       enum mdoct, int, int);

 static int       rew_last(struct mdoc *, 
                        const struct mdoc_node *);
 static int       append_delims(struct mdoc *, int, int *, char *);
 static int       rew_last(struct mdoc *, 
                        const struct mdoc_node *);
 static int       append_delims(struct mdoc *, int, int *, char *);


@@ -93,8 +101,8 @@ const        struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
        { in_line_eoln, 0 }, /* Rv */
        { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* St */ 
        { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Va */
        { in_line_eoln, 0 }, /* Rv */
        { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* St */ 
        { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Va */

-       { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Vt */ 
-       { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Xr */
+       { ctx_synopsis, MDOC_CALLABLE | MDOC_PARSED }, /* Vt */ 
+       { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Xr */

        { in_line_eoln, 0 }, /* %A */
        { in_line_eoln, 0 }, /* %B */
        { in_line_eoln, 0 }, /* %D */
        { in_line_eoln, 0 }, /* %A */
        { in_line_eoln, 0 }, /* %B */
        { in_line_eoln, 0 }, /* %D */


@@ -131,7 +139,7 @@ const       struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
        { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Nx */
        { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ox */
        { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Pc */
        { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Nx */
        { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ox */
        { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Pc */

-       { in_line_argn, MDOC_PARSED | MDOC_IGNDELIM }, /* Pf */
+       { in_line_argn, MDOC_CALLABLE | MDOC_PARSED | MDOC_IGNDELIM }, /* Pf */

        { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Po */
        { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Pq */
        { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Qc */
        { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Po */
        { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Pq */
        { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Qc */


@@ -174,6 +182,7 @@ const       struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
        { in_line_eoln, 0 }, /* %Q */
        { in_line_eoln, 0 }, /* br */
        { in_line_eoln, 0 }, /* sp */
        { in_line_eoln, 0 }, /* %Q */
        { in_line_eoln, 0 }, /* br */
        { in_line_eoln, 0 }, /* sp */

+       { in_line_eoln, 0 }, /* %U */

 };
 
 const  struct mdoc_macro * const mdoc_macros = __mdoc_macros;
 };
 
 const  struct mdoc_macro * const mdoc_macros = __mdoc_macros;


@@ -311,8 +320,8 @@ rew_last(struct mdoc *mdoc, const struct mdoc_node *to)
  * Return the opening macro of a closing one, e.g., `Ec' has `Eo' as its
  * matching pair.
  */
  * Return the opening macro of a closing one, e.g., `Ec' has `Eo' as its
  * matching pair.
  */

-static int
-rew_alt(int tok)
+static enum mdoct
+rew_alt(enum mdoct tok)

 {
        switch (tok) {
        case (MDOC_Ac):
 {
        switch (tok) {
        case (MDOC_Ac):


@@ -361,8 +370,9 @@ rew_alt(int tok)
  * close our current scope (REWIND_REWIND), or continue (REWIND_NOHALT).
  * The scope-closing and so on occurs in the various rew_* routines.
  */
  * close our current scope (REWIND_REWIND), or continue (REWIND_NOHALT).
  * The scope-closing and so on occurs in the various rew_* routines.
  */

-static int 
-rew_dohalt(int tok, enum mdoc_type type, const struct mdoc_node *p)
+static enum rew
+rew_dohalt(enum mdoct tok, enum mdoc_type type, 
+               const struct mdoc_node *p)

 {
 
        if (MDOC_ROOT == p->type)
 {
 
        if (MDOC_ROOT == p->type)


@@ -392,6 +402,8 @@ rew_dohalt(int tok, enum mdoc_type type, const struct mdoc_node *p)
        case (MDOC_Qq):
                /* FALLTHROUGH */
        case (MDOC_Sq):
        case (MDOC_Qq):
                /* FALLTHROUGH */
        case (MDOC_Sq):

+               /* FALLTHROUGH */
+       case (MDOC_Vt):

                assert(MDOC_TAIL != type);
                if (type == p->type && tok == p->tok)
                        return(REWIND_REWIND);
                assert(MDOC_TAIL != type);
                if (type == p->type && tok == p->tok)
                        return(REWIND_REWIND);


@@ -499,7 +511,7 @@ rew_dohalt(int tok, enum mdoc_type type, const struct mdoc_node *p)
  * REWIND_NOHALT). 
  */
 static int
  * REWIND_NOHALT). 
  */
 static int

-rew_dobreak(int tok, const struct mdoc_node *p)
+rew_dobreak(enum mdoct tok, const struct mdoc_node *p)

 {
 
        assert(MDOC_ROOT != p->type);
 {
 
        assert(MDOC_ROOT != p->type);


@@ -528,7 +540,6 @@ rew_dobreak(int tok, const struct mdoc_node *p)
                        return(1);
                break;
        case (MDOC_Oc):
                        return(1);
                break;
        case (MDOC_Oc):

-               /* XXX - experimental! */

                if (MDOC_Op == p->tok)
                        return(1);
                break;
                if (MDOC_Op == p->tok)
                        return(1);
                break;


@@ -546,7 +557,7 @@ rew_dobreak(int tok, const struct mdoc_node *p)
 
 
 static int
 
 
 static int

-rew_elem(struct mdoc *mdoc, int tok)
+rew_elem(struct mdoc *mdoc, enum mdoct tok)

 {
        struct mdoc_node *n;
 
 {
        struct mdoc_node *n;
 


@@ -562,10 +573,10 @@ rew_elem(struct mdoc *mdoc, int tok)
 
 static int
 rew_sub(enum mdoc_type t, struct mdoc *m, 
 
 static int
 rew_sub(enum mdoc_type t, struct mdoc *m, 

-               int tok, int line, int ppos)
+               enum mdoct tok, int line, int ppos)

 {
        struct mdoc_node *n;
 {
        struct mdoc_node *n;

-       int               c;
+       enum rew          c;

 
        /* LINTED */
        for (n = m->last; n; n = n->parent) {
 
        /* LINTED */
        for (n = m->last; n; n = n->parent) {


@@ -586,7 +597,25 @@ rew_sub(enum mdoc_type t, struct mdoc *m,
        }
 
        assert(n);
        }
 
        assert(n);

-       return(rew_last(m, n));
+       if ( ! rew_last(m, n))
+               return(0);
+
+#ifdef UGLY
+       /*
+        * The current block extends an enclosing block beyond a line
+        * break.  Now that the current block ends, close the enclosing
+        * block, too.
+        */
+       if (NULL != (n = n->pending)) {
+               assert(MDOC_HEAD == n->type);
+               if ( ! rew_last(m, n))
+                       return(0);
+               if ( ! mdoc_body_alloc(m, n->line, n->pos, n->tok))
+                       return(0);
+       }
+#endif
+
+       return(1);

 }
 
 
 }
 
 


@@ -705,6 +734,7 @@ in_line(MACRO_PROT_ARGS)
         * Whether we allow ignored elements (those without content,
         * usually because of reserved words) to squeak by.
         */
         * Whether we allow ignored elements (those without content,
         * usually because of reserved words) to squeak by.
         */

+

        switch (tok) {
        case (MDOC_An):
                /* FALLTHROUGH */
        switch (tok) {
        case (MDOC_An):
                /* FALLTHROUGH */


@@ -790,7 +820,7 @@ in_line(MACRO_PROT_ARGS)
                 * the word. 
                 */
 
                 * the word. 
                 */
 

-               d = mdoc_isdelim(p);
+               d = ARGS_QWORD == w ? 0 : mdoc_isdelim(p);

 
                if (ARGS_QWORD != w && d) {
                        if (0 == lastpunct && ! rew_elem(m, tok))
 
                if (ARGS_QWORD != w && d) {
                        if (0 == lastpunct && ! rew_elem(m, tok))


@@ -806,6 +836,17 @@ in_line(MACRO_PROT_ARGS)
                        cnt++;
                if ( ! mdoc_word_alloc(m, line, la, p))
                        return(0);
                        cnt++;
                if ( ! mdoc_word_alloc(m, line, la, p))
                        return(0);

+
+               /*
+                * `Fl' macros have their scope re-opened with each new
+                * word so that the `-' can be added to each one without
+                * having to parse out spaces.
+                */
+               if (0 == lastpunct && MDOC_Fl == tok) {
+                       if ( ! rew_elem(m, tok))
+                               return(0);
+                       lastpunct = 1;
+               }

        }
 
        if (0 == lastpunct && ! rew_elem(m, tok))
        }
 
        if (0 == lastpunct && ! rew_elem(m, tok))


@@ -815,8 +856,8 @@ in_line(MACRO_PROT_ARGS)
         * If no elements have been collected and we're allowed to have
         * empties (nc), open a scope and close it out.  Otherwise,
         * raise a warning.
         * If no elements have been collected and we're allowed to have
         * empties (nc), open a scope and close it out.  Otherwise,
         * raise a warning.

-        *

         */
         */

+

        if (nc && 0 == cnt) {
                if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
                        return(0);
        if (nc && 0 == cnt) {
                if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
                        return(0);


@@ -837,25 +878,16 @@ in_line(MACRO_PROT_ARGS)
 static int
 blk_full(MACRO_PROT_ARGS)
 {
 static int
 blk_full(MACRO_PROT_ARGS)
 {

-       int               c, lastarg, reopen, dohead;
+       int               c, la;

        struct mdoc_arg  *arg;
        struct mdoc_arg  *arg;

+       struct mdoc_node *head; /* save of head macro */
+       struct mdoc_node *body; /* save of body macro */
+#ifdef UGLY
+       struct mdoc_node *n;
+#endif

        char             *p;
 
        char             *p;
 

-       /* 
-        * Whether to process a block-head section.  If this is
-        * non-zero, then a head will be opened for all line arguments.
-        * If not, then the head will always be empty and only a body
-        * will be opened, which will stay open at the eoln.
-        */
-
-       switch (tok) {
-       case (MDOC_Nd):
-               dohead = 0;
-               break;
-       default:
-               dohead = 1;
-               break;
-       }
+       /* Close out prior implicit scope. */

 
        if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {
                if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
 
        if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {
                if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))


@@ -864,12 +896,21 @@ blk_full(MACRO_PROT_ARGS)
                        return(0);
        }
 
                        return(0);
        }
 

+       /*
+        * This routine accomodates implicitly- and explicitly-scoped
+        * macro openings.  Implicit ones first close out prior scope
+        * (seen above).  Delay opening the head until necessary to
+        * allow leading punctuation to print.  Special consideration
+        * for `It -column', which has phrase-part syntax instead of
+        * regular child nodes.
+        */
+

        for (arg = NULL;; ) {
        for (arg = NULL;; ) {

-               lastarg = *pos;
+               la = *pos;

                c = mdoc_argv(m, line, tok, &arg, pos, buf);
 
                if (ARGV_WORD == c) {
                c = mdoc_argv(m, line, tok, &arg, pos, buf);
 
                if (ARGV_WORD == c) {

-                       *pos = lastarg;
+                       *pos = la;

                        break;
                } 
 
                        break;
                } 
 


@@ -885,72 +926,104 @@ blk_full(MACRO_PROT_ARGS)
        if ( ! mdoc_block_alloc(m, line, ppos, tok, arg))
                return(0);
 
        if ( ! mdoc_block_alloc(m, line, ppos, tok, arg))
                return(0);
 

-       if (0 == buf[*pos]) {
-               if ( ! mdoc_head_alloc(m, line, ppos, tok))
-                       return(0);
-               if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
-                       return(0);
-               if ( ! mdoc_body_alloc(m, line, ppos, tok))
-                       return(0);
-               return(1);
-       }
+       head = body = NULL;

 
 

-       if ( ! mdoc_head_alloc(m, line, ppos, tok))
-               return(0);
-
-       /* Immediately close out head and enter body, if applicable. */
+       /*
+        * The `Nd' macro has all arguments in its body: it's a hybrid
+        * of block partial-explicit and full-implicit.  Stupid.
+        */

 
 

-       if (0 == dohead) {
+       if (MDOC_Nd == tok) {
+               if ( ! mdoc_head_alloc(m, line, ppos, tok))
+                       return(0);
+               head = m->last;

                if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                        return(0);
                if ( ! mdoc_body_alloc(m, line, ppos, tok))
                        return(0);
                if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                        return(0);
                if ( ! mdoc_body_alloc(m, line, ppos, tok))
                        return(0);

+               body = m->last;

        } 
 
        } 
 

-       for (reopen = 0;; ) {
-               lastarg = *pos;
+       for (;;) {
+               la = *pos;

                c = mdoc_args(m, line, pos, buf, tok, &p);
 
                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_EOLN == c)
                        break;
                c = mdoc_args(m, line, pos, buf, tok, &p);
 
                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_EOLN == c)
                        break;

-               if (ARGS_PHRASE == c) {
-                       assert(dohead);
-                       if (reopen && ! mdoc_head_alloc(m, line, ppos, tok))
+
+               /* Don't emit leading punct. for phrases. */
+
+               if (NULL == head && ARGS_PHRASE != c &&
+                               ARGS_QWORD != c &&
+                               1 == mdoc_isdelim(p)) {
+                       if ( ! mdoc_word_alloc(m, line, la, p))

                                return(0);
                                return(0);

-                       /*
-                        * Phrases are self-contained macro phrases used
-                        * in the columnar output of a macro. They need
-                        * special handling.
-                        */
-                       if ( ! phrase(m, line, lastarg, buf))
+                       continue;
+               }
+
+               /* Always re-open head for phrases. */
+
+               if (NULL == head || ARGS_PHRASE == c) {
+                       if ( ! mdoc_head_alloc(m, line, ppos, tok))
+                               return(0);
+                       head = m->last;
+               }
+
+               if (ARGS_PHRASE == c) {
+                       if ( ! phrase(m, line, la, buf))

                                return(0);
                        if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                                return(0);
                                return(0);
                        if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                                return(0);

-
-                       reopen = 1;

                        continue;
                }
 
                        continue;
                }
 

-               if (MDOC_MAX == (c = lookup(tok, p))) {
-                       if ( ! mdoc_word_alloc(m, line, lastarg, p))
+               c = lookup(tok, p);
+               if (MDOC_MAX != c) {
+                       if ( ! mdoc_macro(m, c, line, la, pos, buf))

                                return(0);
                                return(0);

-                       continue;
-               } 
+                       break;
+               }
+               if ( ! mdoc_word_alloc(m, line, la, p))
+                       return(0);
+
+       }

 
 

-               if ( ! mdoc_macro(m, c, line, lastarg, pos, buf))
+       if (NULL == head) {
+               if ( ! mdoc_head_alloc(m, line, ppos, tok))

                        return(0);
                        return(0);

-               break;
+               head = m->last;

        }
        
        if (1 == ppos && ! append_delims(m, line, pos, buf))
                return(0);
 
        }
        
        if (1 == ppos && ! append_delims(m, line, pos, buf))
                return(0);
 

-       /* If the body's already open, then just return. */
-       if (0 == dohead) 
+       /* If we've already opened our body, exit now. */
+
+       if (NULL != body)

                return(1);
 
                return(1);
 

+#ifdef UGLY
+       /*
+        * If there is an open (i.e., unvalidated) sub-block requiring
+        * explicit close-out, postpone switching the current block from
+        * head to body until the rew_sub() call closing out that
+        * sub-block.
+        */
+       for (n = m->last; n && n != head; n = n->parent) {
+               if (MDOC_BLOCK == n->type && 
+                               MDOC_EXPLICIT & mdoc_macros[n->tok].flags &&
+                               ! (MDOC_VALID & n->flags)) {
+                       assert( ! (MDOC_ACTED & n->flags));
+                       n->pending = head;
+                       return(1);
+               }
+       }
+#endif
+
+       /* Close out scopes to remain in a consistent state. */
+

        if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                return(0);
        if ( ! mdoc_body_alloc(m, line, ppos, tok))
        if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                return(0);
        if ( ! mdoc_body_alloc(m, line, ppos, tok))


@@ -965,59 +1038,92 @@ blk_part_imp(MACRO_PROT_ARGS)
 {
        int               la, c;
        char             *p;
 {
        int               la, c;
        char             *p;

-       struct mdoc_node *blk, *body, *n;
+       struct mdoc_node *blk; /* saved block context */
+       struct mdoc_node *body; /* saved body context */
+       struct mdoc_node *n;

 
 

-       /* If applicable, close out prior scopes. */
+       /*
+        * A macro that spans to the end of the line.  This is generally
+        * (but not necessarily) called as the first macro.  The block
+        * has a head as the immediate child, which is always empty,
+        * followed by zero or more opening punctuation nodes, then the
+        * body (which may be empty, depending on the macro), then zero
+        * or more closing punctuation nodes.
+        */

 
        if ( ! mdoc_block_alloc(m, line, ppos, tok, NULL))
                return(0);
 
        if ( ! mdoc_block_alloc(m, line, ppos, tok, NULL))
                return(0);

-       /* Saved for later close-out. */
+

        blk = m->last;
        blk = m->last;

+

        if ( ! mdoc_head_alloc(m, line, ppos, tok))
                return(0);
        if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                return(0);
        if ( ! mdoc_head_alloc(m, line, ppos, tok))
                return(0);
        if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                return(0);

-       if ( ! mdoc_body_alloc(m, line, ppos, tok))
-               return(0);
-       /* Saved for later close-out. */
-       body = m->last;

 
 

-       /* Body argument processing. */
+       /*
+        * Open the body scope "on-demand", that is, after we've
+        * processed all our the leading delimiters (open parenthesis,
+        * etc.).
+        */

 
 

-       for (;;) {
+       for (body = NULL; ; ) {

                la = *pos;
                c = mdoc_args(m, line, pos, buf, tok, &p);
                la = *pos;
                c = mdoc_args(m, line, pos, buf, tok, &p);

+

                assert(ARGS_PHRASE != c);
 
                if (ARGS_ERROR == c)
                        return(0);
                assert(ARGS_PHRASE != c);
 
                if (ARGS_ERROR == c)
                        return(0);

-               if (ARGS_PUNCT == c)
-                       break;

                if (ARGS_EOLN == c)
                        break;
                if (ARGS_EOLN == c)
                        break;

+               if (ARGS_PUNCT == c)
+                       break;

 
 

-               if (MDOC_MAX == (c = lookup(tok, p))) {
+               if (NULL == body && ARGS_QWORD != c &&
+                               1 == mdoc_isdelim(p)) {

                        if ( ! mdoc_word_alloc(m, line, la, p))
                                return(0);
                        continue;
                } 
 
                        if ( ! mdoc_word_alloc(m, line, la, p))
                                return(0);
                        continue;
                } 
 

-               if ( ! mdoc_macro(m, c, line, la, pos, buf))
+               if (NULL == body) {
+                      if ( ! mdoc_body_alloc(m, line, ppos, tok))
+                              return(0);
+                       body = m->last;
+               }
+
+               if (MDOC_MAX != (c = lookup(tok, p))) {
+                       if ( ! mdoc_macro(m, c, line, la, pos, buf))
+                               return(0);
+                       break;
+               } 
+
+               if ( ! mdoc_word_alloc(m, line, la, p))

                        return(0);
                        return(0);

-               break;
+       }
+
+       /* Clean-ups to leave in a consistent state. */
+
+       if (NULL == body) {
+               if ( ! mdoc_body_alloc(m, line, ppos, tok))
+                       return(0);
+               body = m->last;

        }
 
        /* 
         * If we can't rewind to our body, then our scope has already
         * been closed by another macro (like `Oc' closing `Op').  This
         * is ugly behaviour nodding its head to OpenBSD's overwhelming
        }
 
        /* 
         * If we can't rewind to our body, then our scope has already
         * been closed by another macro (like `Oc' closing `Op').  This
         * is ugly behaviour nodding its head to OpenBSD's overwhelming

-        * crufty use of `Op' breakage--XXX, deprecate in time.
+        * crufty use of `Op' breakage.

         */
        for (n = m->last; n; n = n->parent)
                if (body == n)
                        break;
         */
        for (n = m->last; n; n = n->parent)
                if (body == n)
                        break;

+

        if (NULL == n && ! mdoc_nwarn(m, body, EIMPBRK))
                return(0);
        if (NULL == n && ! mdoc_nwarn(m, body, EIMPBRK))
                return(0);

+

        if (n && ! rew_last(m, body))
                return(0);
 
        if (n && ! rew_last(m, body))
                return(0);
 


@@ -1038,59 +1144,23 @@ blk_part_imp(MACRO_PROT_ARGS)
 static int
 blk_part_exp(MACRO_PROT_ARGS)
 {
 static int
 blk_part_exp(MACRO_PROT_ARGS)
 {

-       int               la, flushed, j, c, maxargs;
+       int               la, c;
+       struct mdoc_node *head; /* keep track of head */
+       struct mdoc_node *body; /* keep track of body */

        char             *p;
 
        char             *p;
 

-       /* Number of head arguments.  Only `Eo' has these, */
-
-       switch (tok) {
-       case (MDOC_Eo):
-               maxargs = 1;
-               break;
-       default:
-               maxargs = 0;
-               break;
-       }
-
-       /* Begin the block scope. */
+       /*
+        * The opening of an explicit macro having zero or more leading
+        * punctuation nodes; a head with optional single element (the
+        * case of `Eo'); and a body that may be empty.
+        */

 
        if ( ! mdoc_block_alloc(m, line, ppos, tok, NULL))
                return(0); 
 
 
        if ( ! mdoc_block_alloc(m, line, ppos, tok, NULL))
                return(0); 
 

-       /* 
-        * If no head arguments, open and then close out a head, noting
-        * that we've flushed our terms.  `flushed' means that we've
-        * flushed out the head and the body is open.
-        */
-
-       if (0 == maxargs) {
-               if ( ! mdoc_head_alloc(m, line, ppos, tok))
-                       return(0);
-               if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
-                       return(0);
-               if ( ! mdoc_body_alloc(m, line, ppos, tok))
-                       return(0);
-               flushed = 1;
-       } else {
-               if ( ! mdoc_head_alloc(m, line, ppos, tok))
-                       return(0);
-               flushed = 0;
-       }
-
-       /* Process the head/head+body line arguments. */
-
-       for (j = 0; ; j++) {
+       for (head = body = NULL; ; ) {

                la = *pos;
                la = *pos;

-               if (j == maxargs && ! flushed) {
-                       if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
-                               return(0);
-                       flushed = 1;
-                       if ( ! mdoc_body_alloc(m, line, ppos, tok))
-                               return(0);
-               }
-

                c = mdoc_args(m, line, pos, buf, tok, &p);
                c = mdoc_args(m, line, pos, buf, tok, &p);

-               assert(ARGS_PHRASE != c);

 
                if (ARGS_ERROR == c)
                        return(0);
 
                if (ARGS_ERROR == c)
                        return(0);


@@ -1099,44 +1169,80 @@ blk_part_exp(MACRO_PROT_ARGS)
                if (ARGS_EOLN == c)
                        break;
 
                if (ARGS_EOLN == c)
                        break;
 

-               if (MDOC_MAX != (c = lookup(tok, p))) {
-                       if ( ! flushed) {
-                               if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
-                                       return(0);
-                               flushed = 1;
-                               if ( ! mdoc_body_alloc(m, line, ppos, tok))
-                                       return(0);
-                       }
-                       if ( ! mdoc_macro(m, c, line, la, pos, buf))
+               assert(ARGS_PHRASE != c);
+
+               /* Flush out leading punctuation. */
+
+               if (NULL == head && ARGS_QWORD != c &&
+                               1 == mdoc_isdelim(p)) {
+                       assert(NULL == body);
+                       if ( ! mdoc_word_alloc(m, line, la, p))

                                return(0);
                                return(0);

-                       break;
+                       continue;
+               } 
+
+               if (NULL == head) {
+                       assert(NULL == body);
+                       if ( ! mdoc_head_alloc(m, line, ppos, tok))
+                               return(0);
+                       head = m->last;

                }
 
                }
 

-               if ( ! flushed && mdoc_isdelim(p)) {
+               /*
+                * `Eo' gobbles any data into the head, but most other
+                * macros just immediately close out and begin the body.
+                */
+
+               if (NULL == body) {
+                       assert(head);
+                       /* No check whether it's a macro! */
+                       if (MDOC_Eo == tok)
+                               if ( ! mdoc_word_alloc(m, line, la, p))
+                                       return(0);
+

                        if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                                return(0);
                        if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                                return(0);

-                       flushed = 1;

                        if ( ! mdoc_body_alloc(m, line, ppos, tok))
                                return(0);
                        if ( ! mdoc_body_alloc(m, line, ppos, tok))
                                return(0);

+                       body = m->last;
+
+                       if (MDOC_Eo == tok)
+                               continue;

                }
                }

-       
+
+               assert(NULL != head && NULL != body);
+
+               if (MDOC_MAX != (c = lookup(tok, p))) {
+                       if ( ! mdoc_macro(m, c, line, la, pos, buf))
+                               return(0);
+                       break;
+               }
+

                if ( ! mdoc_word_alloc(m, line, la, p))
                        return(0);
        }
 
                if ( ! mdoc_word_alloc(m, line, la, p))
                        return(0);
        }
 

-       /* Close the head and open the body, if applicable. */
+       /* Clean-up to leave in a consistent state. */
+
+       if (NULL == head) {
+               if ( ! mdoc_head_alloc(m, line, ppos, tok))
+                       return(0);
+               head = m->last;
+       }

 
 

-       if ( ! flushed) {
+       if (NULL == body) {

                if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                        return(0);
                if ( ! mdoc_body_alloc(m, line, ppos, tok))
                        return(0);
                if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
                        return(0);
                if ( ! mdoc_body_alloc(m, line, ppos, tok))
                        return(0);

+               body = m->last;

        }
 
        /* Standard appending of delimiters. */
 
        if (ppos > 1)
                return(1);
        }
 
        /* Standard appending of delimiters. */
 
        if (ppos > 1)
                return(1);

+

        return(append_delims(m, line, pos, buf));
 }
 
        return(append_delims(m, line, pos, buf));
 }
 


@@ -1148,7 +1254,13 @@ in_line_argn(MACRO_PROT_ARGS)
        struct mdoc_arg  *arg;
        char             *p;
 
        struct mdoc_arg  *arg;
        char             *p;
 

-       /* Fixed maximum arguments per macro, if applicable. */
+       /*
+        * A line macro that has a fixed number of arguments (maxargs).
+        * Only open the scope once the first non-leading-punctuation is
+        * found (unless MDOC_IGNDELIM is noted, like in `Pf'), then
+        * keep it open until the maximum number of arguments are
+        * exhausted.
+        */

 
        switch (tok) {
        case (MDOC_Ap):
 
        switch (tok) {
        case (MDOC_Ap):


@@ -1160,14 +1272,15 @@ in_line_argn(MACRO_PROT_ARGS)
        case (MDOC_Ux):
                maxargs = 0;
                break;
        case (MDOC_Ux):
                maxargs = 0;
                break;

+       case (MDOC_Xr):
+               maxargs = 2;
+               break;

        default:
                maxargs = 1;
                break;
        }
 
        default:
                maxargs = 1;
                break;
        }
 

-       /* Macro argument processing. */
-
-       for (arg = NULL;; ) {
+       for (arg = NULL; ; ) {

                la = *pos;
                c = mdoc_argv(m, line, tok, &arg, pos, buf);
 
                la = *pos;
                c = mdoc_argv(m, line, tok, &arg, pos, buf);
 


@@ -1185,22 +1298,8 @@ in_line_argn(MACRO_PROT_ARGS)
                return(0);
        }
 
                return(0);
        }
 

-       /* Open the element scope. */
-
-       if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
-               return(0);
-
-       /* Process element arguments. */
-
-       for (flushed = j = 0; ; j++) {
+       for (flushed = j = 0; ; ) {

                la = *pos;
                la = *pos;

-
-               if (j == maxargs && ! flushed) {
-                       if ( ! rew_elem(m, tok))
-                               return(0);
-                       flushed = 1;
-               }
-

                c = mdoc_args(m, line, pos, buf, tok, &p);
 
                if (ARGS_ERROR == c)
                c = mdoc_args(m, line, pos, buf, tok, &p);
 
                if (ARGS_ERROR == c)


@@ -1210,27 +1309,65 @@ in_line_argn(MACRO_PROT_ARGS)
                if (ARGS_EOLN == c)
                        break;
 
                if (ARGS_EOLN == c)
                        break;
 

+               if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) && 
+                               ARGS_QWORD != c &&
+                               0 == j && 1 == mdoc_isdelim(p)) {
+                       if ( ! mdoc_word_alloc(m, line, la, p))
+                               return(0);
+                       continue;
+               } else if (0 == j)
+                      if ( ! mdoc_elem_alloc(m, line, la, tok, arg))
+                              return(0);
+
+               if (j == maxargs && ! flushed) {
+                       if ( ! rew_elem(m, tok))
+                               return(0);
+                       flushed = 1;
+               }
+

                if (MDOC_MAX != (c = lookup(tok, p))) {
                        if ( ! flushed && ! rew_elem(m, tok))
                                return(0);
                        flushed = 1;
                        if ( ! mdoc_macro(m, c, line, la, pos, buf))
                                return(0);
                if (MDOC_MAX != (c = lookup(tok, p))) {
                        if ( ! flushed && ! rew_elem(m, tok))
                                return(0);
                        flushed = 1;
                        if ( ! mdoc_macro(m, c, line, la, pos, buf))
                                return(0);

+                       j++;

                        break;
                }
 
                if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&
                        break;
                }
 
                if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&

+                               ARGS_QWORD != c &&

                                ! flushed && mdoc_isdelim(p)) {
                        if ( ! rew_elem(m, tok))
                                return(0);
                        flushed = 1;
                }
                                ! flushed && mdoc_isdelim(p)) {
                        if ( ! rew_elem(m, tok))
                                return(0);
                        flushed = 1;
                }

-       
+
+               /* 
+                * XXX: this is a hack to work around groff's ugliness
+                * as regards `Xr' and extraneous arguments.  It should
+                * ideally be deprecated behaviour, but because this is
+                * code is no here, it's unlikely to be removed.
+                */
+
+#ifdef __OpenBSD__
+               if (MDOC_Xr == tok && j == maxargs) {
+                       if ( ! mdoc_elem_alloc(m, line, la, MDOC_Ns, NULL))
+                               return(0);
+                       if ( ! rew_elem(m, MDOC_Ns))
+                               return(0);
+               }
+#endif
+

                if ( ! mdoc_word_alloc(m, line, la, p))
                        return(0);
                if ( ! mdoc_word_alloc(m, line, la, p))
                        return(0);

+               j++;

        }
 
        }
 

-       /* Close out and append delimiters. */
+       if (0 == j && ! mdoc_elem_alloc(m, line, la, tok, arg))
+              return(0);
+
+       /* Close out in a consistent state. */

 
        if ( ! flushed && ! rew_elem(m, tok))
                return(0);
 
        if ( ! flushed && ! rew_elem(m, tok))
                return(0);


@@ -1303,6 +1440,29 @@ in_line_eoln(MACRO_PROT_ARGS)
 }
 
 
 }
 
 

+/* ARGSUSED */
+static int
+ctx_synopsis(MACRO_PROT_ARGS)
+{
+
+       /* If we're not in the SYNOPSIS, go straight to in-line. */
+       if (SEC_SYNOPSIS != m->lastsec)
+               return(in_line(m, tok, line, ppos, pos, buf));
+
+       /* If we're a nested call, same place. */
+       if (ppos > 1)
+               return(in_line(m, tok, line, ppos, pos, buf));
+
+       /*
+        * XXX: this will open a block scope; however, if later we end
+        * up formatting the block scope, then child nodes will inherit
+        * the formatting.  Be careful.
+        */
+
+       return(blk_part_imp(m, tok, line, ppos, pos, buf));
+}
+
+

 /* ARGSUSED */
 static int
 obsolete(MACRO_PROT_ARGS)
 /* ARGSUSED */
 static int
 obsolete(MACRO_PROT_ARGS)