Missing prototype for getsubopt() on NetBSD fixed.

[mandoc.git] / mdoc_macro.c

diff --git a/mdoc_macro.c b/mdoc_macro.c
index d0b5368305a20e1a801602488ab3402579af0f0f..d4c8dd140bf0fa3b1a0294a96bc6effe188b58cc 100644 (file)
--- a/mdoc_macro.c
+++ b/mdoc_macro.c
@@ -1,4 +1,4 @@
-/*     $Id: mdoc_macro.c,v 1.54 2010/05/07 05:39:35 kristaps Exp $ */
+/*     $Id: mdoc_macro.c,v 1.79 2010/05/31 23:49:16 kristaps Exp $ */

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


@@ -25,7 +25,9 @@
 #include <string.h>
 #include <time.h>
 
 #include <string.h>
 #include <time.h>
 

+#include "mandoc.h"

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

+#include "libmandoc.h"

 
 enum   rew {
        REWIND_REWIND,
 
 enum   rew {
        REWIND_REWIND,


@@ -42,10 +44,11 @@ static      int             in_line_eoln(MACRO_PROT_ARGS);
 static int             in_line_argn(MACRO_PROT_ARGS);
 static int             in_line(MACRO_PROT_ARGS);
 static int             obsolete(MACRO_PROT_ARGS);
 static int             in_line_argn(MACRO_PROT_ARGS);
 static int             in_line(MACRO_PROT_ARGS);
 static int             obsolete(MACRO_PROT_ARGS);

+static int             phrase_ta(MACRO_PROT_ARGS);

 
 static int             append_delims(struct mdoc *, 
                                int, int *, char *);
 
 static int             append_delims(struct mdoc *, 
                                int, int *, char *);

-static enum mdoct      lookup(int, const char *);
+static enum mdoct      lookup(enum mdoct, const char *);

 static enum mdoct      lookup_raw(const char *);
 static int             phrase(struct mdoc *, int, int, char *);
 static enum mdoct      rew_alt(enum mdoct);
 static enum mdoct      lookup_raw(const char *);
 static int             phrase(struct mdoc *, int, int, char *);
 static enum mdoct      rew_alt(enum mdoct);


@@ -168,7 +171,7 @@ const       struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
        { in_line_eoln, 0 }, /* Hf */
        { obsolete, 0 }, /* Fr */
        { in_line_eoln, 0 }, /* Ud */
        { in_line_eoln, 0 }, /* Hf */
        { obsolete, 0 }, /* Fr */
        { in_line_eoln, 0 }, /* Ud */

-       { in_line_eoln, 0 }, /* Lb */
+       { in_line, 0 }, /* Lb */

        { in_line_eoln, 0 }, /* Lp */ 
        { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Lk */ 
        { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Mt */ 
        { in_line_eoln, 0 }, /* Lp */ 
        { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Lk */ 
        { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Mt */ 


@@ -183,6 +186,7 @@ const       struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
        { in_line_eoln, 0 }, /* br */
        { in_line_eoln, 0 }, /* sp */
        { in_line_eoln, 0 }, /* %U */
        { in_line_eoln, 0 }, /* br */
        { in_line_eoln, 0 }, /* sp */
        { in_line_eoln, 0 }, /* %U */

+       { phrase_ta, MDOC_CALLABLE | MDOC_PARSED }, /* Ta */

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


@@ -193,6 +197,7 @@ swarn(struct mdoc *mdoc, enum mdoc_type type,
                int line, int pos, const struct mdoc_node *p)
 {
        const char      *n, *t, *tt;
                int line, int pos, const struct mdoc_node *p)
 {
        const char      *n, *t, *tt;

+       enum mandocerr   ec;

 
        n = t = "<root>";
        tt = "block";
 
        n = t = "<root>";
        tt = "block";


@@ -225,12 +230,11 @@ swarn(struct mdoc *mdoc, enum mdoc_type type,
                break;
        }
 
                break;
        }
 

-       if ( ! (MDOC_IGN_SCOPE & mdoc->pflags))
-               return(mdoc_verr(mdoc, line, pos, 
-                               "%s scope breaks %s scope of %s", 
-                               tt, t, n));
-       return(mdoc_vwarn(mdoc, line, pos, 
-                               "%s scope breaks %s scope of %s", 
+       ec = (MDOC_IGN_SCOPE & mdoc->pflags) ?
+               MANDOCERR_SCOPE : MANDOCERR_SYNTSCOPE;
+
+       return(mdoc_vmsg(mdoc, ec, line, pos, 
+                               "%s scope breaks %s of %s", 

                                tt, t, n));
 }
 
                                tt, t, n));
 }
 


@@ -254,7 +258,8 @@ mdoc_macroend(struct mdoc *m)
                        continue;
                if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags))
                        continue;
                        continue;
                if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags))
                        continue;

-               return(mdoc_nerr(m, n, EOPEN));
+               mdoc_nmsg(m, n, MANDOCERR_SYNTSCOPE);
+               return(0);

        }
 
        /* Rewind to the first. */
        }
 
        /* Rewind to the first. */


@@ -267,7 +272,7 @@ mdoc_macroend(struct mdoc *m)
  * Look up a macro from within a subsequent context.
  */
 static enum mdoct
  * Look up a macro from within a subsequent context.
  */
 static enum mdoct

-lookup(int from, const char *p)
+lookup(enum mdoct from, const char *p)

 {
        /* FIXME: make -diag lists be un-PARSED. */
 
 {
        /* FIXME: make -diag lists be un-PARSED. */
 


@@ -283,7 +288,7 @@ lookup(int from, const char *p)
 static enum mdoct
 lookup_raw(const char *p)
 {
 static enum mdoct
 lookup_raw(const char *p)
 {

-       int              res;
+       enum mdoct       res;

 
        if (MDOC_MAX == (res = mdoc_hash_find(p)))
                return(MDOC_MAX);
 
        if (MDOC_MAX == (res = mdoc_hash_find(p)))
                return(MDOC_MAX);


@@ -586,7 +591,9 @@ rew_sub(enum mdoc_type t, struct mdoc *m,
                                return(1);
                        if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags))
                                return(1);
                                return(1);
                        if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags))
                                return(1);

-                       return(mdoc_perr(m, line, ppos, ENOCTX));
+                       /* FIXME: shouldn't raise an error */
+                       mdoc_pmsg(m, line, ppos, MANDOCERR_SYNTNOSCOPE);
+                       return(0);

                }
                if (REWIND_REWIND == c)
                        break;
                }
                if (REWIND_REWIND == c)
                        break;


@@ -620,27 +627,41 @@ rew_sub(enum mdoc_type t, struct mdoc *m,
 
 
 static int
 
 
 static int

-append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
+append_delims(struct mdoc *m, int line, int *pos, char *buf)

 {
 {

-       int              lastarg;
-       enum margerr     ac;
+       int              la;
+       enum margserr    ac;

        char            *p;
 
        char            *p;
 

-       if (0 == buf[*pos])
+       if ('\0' == buf[*pos])

                return(1);
 
        for (;;) {
                return(1);
 
        for (;;) {

-               lastarg = *pos;
-               ac = mdoc_zargs(mdoc, line, pos, buf, ARGS_NOWARN, &p);
-               assert(ARGS_PHRASE != ac);
+               la = *pos;
+               ac = mdoc_zargs(m, line, pos, buf, ARGS_NOWARN, &p);

 
                if (ARGS_ERROR == ac)
                        return(0);
                else if (ARGS_EOLN == ac)
                        break;
 
                if (ARGS_ERROR == ac)
                        return(0);
                else if (ARGS_EOLN == ac)
                        break;

-               assert(mdoc_isdelim(p));
-               if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
+
+               assert(DELIM_NONE != mdoc_isdelim(p));
+               if ( ! mdoc_word_alloc(m, line, la, p))

                        return(0);
                        return(0);

+
+               /*
+                * If we encounter end-of-sentence symbols, then trigger
+                * the double-space.
+                *
+                * XXX: it's easy to allow this to propogate outward to
+                * the last symbol, such that `. )' will cause the
+                * correct double-spacing.  However, (1) groff isn't
+                * smart enough to do this and (2) it would require
+                * knowing which symbols break this behaviour, for
+                * example, `.  ;' shouldn't propogate the double-space.
+                */
+               if (mandoc_eos(p, strlen(p)))
+                       m->last->flags |= MDOC_EOS;

        }
 
        return(1);
        }
 
        return(1);


@@ -653,11 +674,13 @@ append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
 static int
 blk_exp_close(MACRO_PROT_ARGS)
 {
 static int
 blk_exp_close(MACRO_PROT_ARGS)
 {

-       int              j, lastarg, maxargs, flushed;
-       enum margerr     ac;
+       int              j, lastarg, maxargs, flushed, nl;
+       enum margserr    ac;

        enum mdoct       ntok;
        char            *p;
 
        enum mdoct       ntok;
        char            *p;
 

+       nl = MDOC_NEWLINE & m->flags;
+

        switch (tok) {
        case (MDOC_Ec):
                maxargs = 1;
        switch (tok) {
        case (MDOC_Ec):
                maxargs = 1;


@@ -668,8 +691,9 @@ blk_exp_close(MACRO_PROT_ARGS)
        }
 
        if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {
        }
 
        if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {

+               /* FIXME: do this in validate */

                if (buf[*pos]) 
                if (buf[*pos]) 

-                       if ( ! mdoc_pwarn(m, line, ppos, ENOLINE))
+                       if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_ARGSLOST))

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


@@ -723,7 +747,7 @@ blk_exp_close(MACRO_PROT_ARGS)
        if ( ! flushed && ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
                return(0);
 
        if ( ! flushed && ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
                return(0);
 

-       if (ppos > 1)
+       if ( ! nl)

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


@@ -732,12 +756,16 @@ blk_exp_close(MACRO_PROT_ARGS)
 static int
 in_line(MACRO_PROT_ARGS)
 {
 static int
 in_line(MACRO_PROT_ARGS)
 {

-       int              la, lastpunct, c, cnt, d, nc;
+       int              la, scope, cnt, nc, nl;
+       enum margverr    av;

        enum mdoct       ntok;
        enum mdoct       ntok;

-       enum margerr     ac;
+       enum margserr    ac;
+       enum mdelim      d;

        struct mdoc_arg *arg;
        char            *p;
 
        struct mdoc_arg *arg;
        char            *p;
 

+       nl = MDOC_NEWLINE & m->flags;
+

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


@@ -764,22 +792,22 @@ in_line(MACRO_PROT_ARGS)
 
        for (arg = NULL;; ) {
                la = *pos;
 
        for (arg = NULL;; ) {
                la = *pos;

-               c = mdoc_argv(m, line, tok, &arg, pos, buf);
+               av = mdoc_argv(m, line, tok, &arg, pos, buf);

 
 

-               if (ARGV_WORD == c) {
+               if (ARGV_WORD == av) {

                        *pos = la;
                        break;
                } 
                        *pos = la;
                        break;
                } 

-               if (ARGV_EOLN == c)
+               if (ARGV_EOLN == av)

                        break;
                        break;

-               if (ARGV_ARG == c)
+               if (ARGV_ARG == av)

                        continue;
 
                mdoc_argv_free(arg);
                return(0);
        }
 
                        continue;
 
                mdoc_argv_free(arg);
                return(0);
        }
 

-       for (cnt = 0, lastpunct = 1;; ) {
+       for (cnt = scope = 0;; ) {

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


@@ -800,7 +828,7 @@ in_line(MACRO_PROT_ARGS)
                 */
 
                if (MDOC_MAX != ntok) {
                 */
 
                if (MDOC_MAX != ntok) {

-                       if (0 == lastpunct && ! rew_elem(m, tok))
+                       if (scope && ! rew_elem(m, tok))

                                return(0);
                        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))


@@ -809,12 +837,12 @@ in_line(MACRO_PROT_ARGS)
                                        return(0);
                        } else if ( ! nc && 0 == cnt) {
                                mdoc_argv_free(arg);
                                        return(0);
                        } else if ( ! nc && 0 == cnt) {
                                mdoc_argv_free(arg);

-                               if ( ! mdoc_pwarn(m, line, ppos, EIGNE))
+                               if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_MACROEMPTY))

                                        return(0);
                        }
                        if ( ! mdoc_macro(m, ntok, line, la, pos, buf))
                                return(0);
                                        return(0);
                        }
                        if ( ! mdoc_macro(m, ntok, line, la, pos, buf))
                                return(0);

-                       if (ppos > 1)
+                       if ( ! nl)

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


@@ -825,19 +853,40 @@ in_line(MACRO_PROT_ARGS)
                 * the word. 
                 */
 
                 * the word. 
                 */
 

-               d = ARGS_QWORD == ac ? 0 : mdoc_isdelim(p);
-
-               if (ARGS_QWORD != ac && d) {
-                       if (0 == lastpunct && ! rew_elem(m, tok))
+               d = ARGS_QWORD == ac ? DELIM_NONE : mdoc_isdelim(p);
+
+               if (DELIM_NONE != d) {
+                       /*
+                        * If we encounter closing punctuation, no word
+                        * has been omitted, no scope is open, and we're
+                        * allowed to have an empty element, then start
+                        * a new scope.  `Ar', `Fl', and `Li', only do
+                        * this once per invocation.  There may be more
+                        * of these (all of them?).
+                        */
+                       if (0 == cnt && (nc || MDOC_Li == tok) && 
+                                       DELIM_CLOSE == d && ! scope) {
+                               if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
+                                       return(0);
+                               if (MDOC_Ar == tok || MDOC_Li == tok || 
+                                               MDOC_Fl == tok)
+                                       cnt++;
+                               scope = 1;
+                       }
+                       /*
+                        * Close out our scope, if one is open, before
+                        * any punctuation.
+                        */
+                       if (scope && ! rew_elem(m, tok))

                                return(0);
                                return(0);

-                       lastpunct = 1;
-               } else if (lastpunct) {
+                       scope = 0;
+               } else if ( ! scope) {

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

-                       lastpunct = 0;
+                       scope = 1;

                }
 
                }
 

-               if ( ! d)
+               if (DELIM_NONE == d)

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


@@ -847,14 +896,14 @@ in_line(MACRO_PROT_ARGS)
                 * word so that the `-' can be added to each one without
                 * having to parse out spaces.
                 */
                 * word so that the `-' can be added to each one without
                 * having to parse out spaces.
                 */

-               if (0 == lastpunct && MDOC_Fl == tok) {
+               if (scope && MDOC_Fl == tok) {

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

-                       lastpunct = 1;
+                       scope = 0;

                }
        }
 
                }
        }
 

-       if (0 == lastpunct && ! rew_elem(m, tok))
+       if (scope && ! rew_elem(m, tok))

                return(0);
 
        /*
                return(0);
 
        /*


@@ -870,11 +919,11 @@ in_line(MACRO_PROT_ARGS)
                        return(0);
        } else if ( ! nc && 0 == cnt) {
                mdoc_argv_free(arg);
                        return(0);
        } else if ( ! nc && 0 == cnt) {
                mdoc_argv_free(arg);

-               if ( ! mdoc_pwarn(m, line, ppos, EIGNE))
+               if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_MACROEMPTY))

                        return(0);
        }
 
                        return(0);
        }
 

-       if (ppos > 1)
+       if ( ! nl)

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


@@ -883,17 +932,21 @@ in_line(MACRO_PROT_ARGS)
 static int
 blk_full(MACRO_PROT_ARGS)
 {
 static int
 blk_full(MACRO_PROT_ARGS)
 {

-       int               c, la;
+       int               la, nl;

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

+       enum mdoc_type    mtt;

        enum mdoct        ntok;
        enum mdoct        ntok;

-       enum margerr      ac;
+       enum margserr     ac, lac;
+       enum margverr     av;

        char             *p;
 
        char             *p;
 

+       nl = MDOC_NEWLINE & m->flags;
+

        /* Close out prior implicit scope. */
 
        if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {
        /* Close out prior implicit scope. */
 
        if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {


@@ -914,16 +967,16 @@ blk_full(MACRO_PROT_ARGS)
 
        for (arg = NULL;; ) {
                la = *pos;
 
        for (arg = NULL;; ) {
                la = *pos;

-               c = mdoc_argv(m, line, tok, &arg, pos, buf);
+               av = mdoc_argv(m, line, tok, &arg, pos, buf);

 
 

-               if (ARGV_WORD == c) {
+               if (ARGV_WORD == av) {

                        *pos = la;
                        break;
                } 
 
                        *pos = la;
                        break;
                } 
 

-               if (ARGV_EOLN == c)
+               if (ARGV_EOLN == av)

                        break;
                        break;

-               if (ARGV_ARG == c)
+               if (ARGV_ARG == av)

                        continue;
 
                mdoc_argv_free(arg);
                        continue;
 
                mdoc_argv_free(arg);


@@ -951,38 +1004,92 @@ blk_full(MACRO_PROT_ARGS)
                body = m->last;
        } 
 
                body = m->last;
        } 
 

-       for (;;) {
+       ac = ARGS_ERROR;
+
+       for ( ; ; ) {

                la = *pos;
                la = *pos;

+               /* Initialise last-phrase-type with ARGS_PEND. */
+               lac = ARGS_ERROR == ac ? ARGS_PEND : ac;

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

-               if (ARGS_EOLN == ac)
+
+               if (ARGS_EOLN == ac) {
+                       if (ARGS_PPHRASE != lac && ARGS_PHRASE != lac)
+                               break;
+                       /*
+                        * This is necessary: if the last token on a
+                        * line is a `Ta' or tab, then we'll get
+                        * ARGS_EOLN, so we must be smart enough to
+                        * reopen our scope if the last parse was a
+                        * phrase or partial phrase.
+                        */
+                       if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
+                               return(0);
+                       if ( ! mdoc_body_alloc(m, line, ppos, tok))
+                               return(0);
+                       body = m->last;

                        break;
                        break;

+               }

 
 

-               /* Don't emit leading punct. for phrases. */
+               /* 
+                * Emit leading punctuation (i.e., punctuation before
+                * the MDOC_HEAD) for non-phrase types.
+                */

 
 

-               if (NULL == head && ARGS_PHRASE != ac &&
+               if (NULL == head && 
+                               ARGS_PEND != ac &&
+                               ARGS_PHRASE != ac &&
+                               ARGS_PPHRASE != ac &&

                                ARGS_QWORD != ac &&
                                ARGS_QWORD != ac &&

-                               1 == mdoc_isdelim(p)) {
+                               DELIM_OPEN == 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;
                }
 

-               /* Always re-open head for phrases. */
+               /* Open a head if one hasn't been opened. */

 
 

-               if (NULL == head || ARGS_PHRASE == ac) {
+               if (NULL == head) {

                        if ( ! mdoc_head_alloc(m, line, ppos, tok))
                                return(0);
                        head = m->last;
                }
 
                        if ( ! mdoc_head_alloc(m, line, ppos, tok))
                                return(0);
                        head = m->last;
                }
 

-               if (ARGS_PHRASE == ac) {
-                       if ( ! phrase(m, line, la, buf))
+               if (ARGS_PHRASE == ac || 
+                               ARGS_PEND == ac ||
+                               ARGS_PPHRASE == ac) {
+                       /*
+                        * If we haven't opened a body yet, rewind the
+                        * head; if we have, rewind that instead.
+                        */
+
+                       mtt = body ? MDOC_BODY : MDOC_HEAD;
+                       if ( ! rew_sub(mtt, m, tok, line, ppos))

                                return(0);
                                return(0);

-                       if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
+                       
+                       /* Then allocate our body context. */
+
+                       if ( ! mdoc_body_alloc(m, line, ppos, tok))
+                               return(0);
+                       body = m->last;
+
+                       /*
+                        * Process phrases: set whether we're in a
+                        * partial-phrase (this effects line handling)
+                        * then call down into the phrase parser.
+                        */
+
+                       if (ARGS_PPHRASE == ac)
+                               m->flags |= MDOC_PPHRASE;
+                       if (ARGS_PEND == ac && ARGS_PPHRASE == lac)
+                               m->flags |= MDOC_PPHRASE;
+
+                       if ( ! phrase(m, line, la, buf))

                                return(0);
                                return(0);

+
+                       m->flags &= ~MDOC_PPHRASE;

                        continue;
                }
 
                        continue;
                }
 


@@ -1005,13 +1112,13 @@ blk_full(MACRO_PROT_ARGS)
                head = m->last;
        }
        
                head = m->last;
        }
        

-       if (1 == ppos && ! append_delims(m, line, pos, buf))
+       if (nl && ! append_delims(m, line, pos, buf))

                return(0);
 
        /* If we've already opened our body, exit now. */
 
        if (NULL != body)
                return(0);
 
        /* If we've already opened our body, exit now. */
 
        if (NULL != body)

-               return(1);
+               goto out;

 
 #ifdef UGLY
        /*
 
 #ifdef UGLY
        /*


@@ -1038,6 +1145,16 @@ blk_full(MACRO_PROT_ARGS)
        if ( ! mdoc_body_alloc(m, line, ppos, tok))
                return(0);
 
        if ( ! mdoc_body_alloc(m, line, ppos, tok))
                return(0);
 

+out:
+       if ( ! (MDOC_FREECOL & m->flags))
+               return(1);
+
+       if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
+               return(0);
+       if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
+               return(0);
+
+       m->flags &= ~MDOC_FREECOL;

        return(1);
 }
 
        return(1);
 }
 


@@ -1045,14 +1162,16 @@ blk_full(MACRO_PROT_ARGS)
 static int
 blk_part_imp(MACRO_PROT_ARGS)
 {
 static int
 blk_part_imp(MACRO_PROT_ARGS)
 {

-       int               la;
+       int               la, nl;

        enum mdoct        ntok;
        enum mdoct        ntok;

-       enum margerr      ac;
+       enum margserr     ac;

        char             *p;
        struct mdoc_node *blk; /* saved block context */
        struct mdoc_node *body; /* saved body context */
        struct mdoc_node *n;
 
        char             *p;
        struct mdoc_node *blk; /* saved block context */
        struct mdoc_node *body; /* saved body context */
        struct mdoc_node *n;
 

+       nl = MDOC_NEWLINE & m->flags;
+

        /*
         * A macro that spans to the end of the line.  This is generally
         * (but not necessarily) called as the first macro.  The block
        /*
         * A macro that spans to the end of the line.  This is generally
         * (but not necessarily) called as the first macro.  The block


@@ -1082,8 +1201,6 @@ blk_part_imp(MACRO_PROT_ARGS)
                la = *pos;
                ac = mdoc_args(m, line, pos, buf, tok, &p);
 
                la = *pos;
                ac = mdoc_args(m, line, pos, buf, tok, &p);
 

-               assert(ARGS_PHRASE != ac);
-

                if (ARGS_ERROR == ac)
                        return(0);
                if (ARGS_EOLN == ac)
                if (ARGS_ERROR == ac)
                        return(0);
                if (ARGS_EOLN == ac)


@@ -1092,7 +1209,7 @@ blk_part_imp(MACRO_PROT_ARGS)
                        break;
 
                if (NULL == body && ARGS_QWORD != ac &&
                        break;
 
                if (NULL == body && ARGS_QWORD != ac &&

-                               1 == mdoc_isdelim(p)) {
+                   DELIM_OPEN == 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;


@@ -1125,17 +1242,38 @@ blk_part_imp(MACRO_PROT_ARGS)
                body = m->last;
        }
 
                body = m->last;
        }
 

+       for (n = body->child; n && n->next; n = n->next)
+               /* Do nothing. */ ;
+       
+       /* 
+        * End of sentence spacing: if the last node is a text node and
+        * has a trailing period, then mark it as being end-of-sentence.
+        */
+
+       if (n && MDOC_TEXT == n->type && n->string)
+               if (mandoc_eos(n->string, strlen(n->string)))
+                       n->flags |= MDOC_EOS;
+
+       /* Up-propogate the end-of-space flag. */
+
+       if (n && (MDOC_EOS & n->flags)) {
+               body->flags |= MDOC_EOS;
+               body->parent->flags |= MDOC_EOS;
+       }
+

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

+        *
+        * FIXME - this should be ifdef'd OpenBSD?

         */
        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))
+       if (NULL == n && ! mdoc_nmsg(m, body, MANDOCERR_SCOPE))

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


@@ -1143,7 +1281,7 @@ blk_part_imp(MACRO_PROT_ARGS)
 
        /* Standard appending of delimiters. */
 
 
        /* Standard appending of delimiters. */
 

-       if (1 == ppos && ! append_delims(m, line, pos, buf))
+       if (nl && ! append_delims(m, line, pos, buf))

                return(0);
 
        /* Rewind scope, if applicable. */
                return(0);
 
        /* Rewind scope, if applicable. */


@@ -1158,13 +1296,15 @@ blk_part_imp(MACRO_PROT_ARGS)
 static int
 blk_part_exp(MACRO_PROT_ARGS)
 {
 static int
 blk_part_exp(MACRO_PROT_ARGS)
 {

-       int               la;
-       enum margerr      ac;
+       int               la, nl;
+       enum margserr     ac;

        struct mdoc_node *head; /* keep track of head */
        struct mdoc_node *body; /* keep track of body */
        char             *p;
        enum mdoct        ntok;
 
        struct mdoc_node *head; /* keep track of head */
        struct mdoc_node *body; /* keep track of body */
        char             *p;
        enum mdoct        ntok;
 

+       nl = MDOC_NEWLINE & m->flags;
+

        /*
         * The opening of an explicit macro having zero or more leading
         * punctuation nodes; a head with optional single element (the
        /*
         * The opening of an explicit macro having zero or more leading
         * punctuation nodes; a head with optional single element (the


@@ -1185,12 +1325,10 @@ blk_part_exp(MACRO_PROT_ARGS)
                if (ARGS_EOLN == ac)
                        break;
 
                if (ARGS_EOLN == ac)
                        break;
 

-               assert(ARGS_PHRASE != ac);
-

                /* Flush out leading punctuation. */
 
                if (NULL == head && ARGS_QWORD != ac &&
                /* Flush out leading punctuation. */
 
                if (NULL == head && ARGS_QWORD != ac &&

-                               1 == mdoc_isdelim(p)) {
+                   DELIM_OPEN == mdoc_isdelim(p)) {

                        assert(NULL == body);
                        if ( ! mdoc_word_alloc(m, line, la, p))
                                return(0);
                        assert(NULL == body);
                        if ( ! mdoc_word_alloc(m, line, la, p))
                                return(0);


@@ -1259,22 +1397,25 @@ blk_part_exp(MACRO_PROT_ARGS)
 
        /* Standard appending of delimiters. */
 
 
        /* Standard appending of delimiters. */
 

-       if (ppos > 1)
+       if ( ! nl)

                return(1);
                return(1);

-

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

+/* ARGSUSED */

 static int
 in_line_argn(MACRO_PROT_ARGS)
 {
 static int
 in_line_argn(MACRO_PROT_ARGS)
 {

-       int              la, flushed, j, c, maxargs;
-       enum margerr     ac;
+       int              la, flushed, j, maxargs, nl;
+       enum margserr    ac;
+       enum margverr    av;

        struct mdoc_arg *arg;
        char            *p;
        enum mdoct       ntok;
 
        struct mdoc_arg *arg;
        char            *p;
        enum mdoct       ntok;
 

+       nl = MDOC_NEWLINE & m->flags;
+

        /*
         * A line macro that has a fixed number of arguments (maxargs).
         * Only open the scope once the first non-leading-punctuation is
        /*
         * A line macro that has a fixed number of arguments (maxargs).
         * Only open the scope once the first non-leading-punctuation is


@@ -1303,16 +1444,16 @@ in_line_argn(MACRO_PROT_ARGS)
 
        for (arg = NULL; ; ) {
                la = *pos;
 
        for (arg = NULL; ; ) {
                la = *pos;

-               c = mdoc_argv(m, line, tok, &arg, pos, buf);
+               av = mdoc_argv(m, line, tok, &arg, pos, buf);

 
 

-               if (ARGV_WORD == c) {
+               if (ARGV_WORD == av) {

                        *pos = la;
                        break;
                } 
 
                        *pos = la;
                        break;
                } 
 

-               if (ARGV_EOLN == c)
+               if (ARGV_EOLN == av)

                        break;
                        break;

-               if (ARGV_ARG == c)
+               if (ARGV_ARG == av)

                        continue;
 
                mdoc_argv_free(arg);
                        continue;
 
                mdoc_argv_free(arg);


@@ -1332,7 +1473,7 @@ in_line_argn(MACRO_PROT_ARGS)
 
                if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) && 
                                ARGS_QWORD != ac &&
 
                if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) && 
                                ARGS_QWORD != ac &&

-                               0 == j && 1 == mdoc_isdelim(p)) {
+                               0 == j && DELIM_OPEN == 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;


@@ -1360,7 +1501,8 @@ in_line_argn(MACRO_PROT_ARGS)
 
                if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&
                                ARGS_QWORD != ac &&
 
                if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&
                                ARGS_QWORD != ac &&

-                               ! flushed && mdoc_isdelim(p)) {
+                               ! flushed &&
+                               DELIM_NONE != mdoc_isdelim(p)) {

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


@@ -1394,8 +1536,7 @@ in_line_argn(MACRO_PROT_ARGS)
 
        if ( ! flushed && ! rew_elem(m, tok))
                return(0);
 
        if ( ! flushed && ! rew_elem(m, tok))
                return(0);

-
-       if (ppos > 1)
+       if ( ! nl)

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


@@ -1404,8 +1545,9 @@ in_line_argn(MACRO_PROT_ARGS)
 static int
 in_line_eoln(MACRO_PROT_ARGS)
 {
 static int
 in_line_eoln(MACRO_PROT_ARGS)
 {

-       int              c, la;
-       enum margerr     ac;
+       int              la;
+       enum margserr    ac;
+       enum margverr    av;

        struct mdoc_arg *arg;
        char            *p;
        enum mdoct       ntok;
        struct mdoc_arg *arg;
        char            *p;
        enum mdoct       ntok;


@@ -1416,15 +1558,15 @@ in_line_eoln(MACRO_PROT_ARGS)
 
        for (arg = NULL; ; ) {
                la = *pos;
 
        for (arg = NULL; ; ) {
                la = *pos;

-               c = mdoc_argv(m, line, tok, &arg, pos, buf);
+               av = mdoc_argv(m, line, tok, &arg, pos, buf);

 
 

-               if (ARGV_WORD == c) {
+               if (ARGV_WORD == av) {

                        *pos = la;
                        break;
                }
                        *pos = la;
                        break;
                }

-               if (ARGV_EOLN == c) 
+               if (ARGV_EOLN == av) 

                        break;
                        break;

-               if (ARGV_ARG == c)
+               if (ARGV_ARG == av)

                        continue;
 
                mdoc_argv_free(arg);
                        continue;
 
                mdoc_argv_free(arg);


@@ -1470,13 +1612,16 @@ in_line_eoln(MACRO_PROT_ARGS)
 static int
 ctx_synopsis(MACRO_PROT_ARGS)
 {
 static int
 ctx_synopsis(MACRO_PROT_ARGS)
 {

+       int              nl;
+
+       nl = MDOC_NEWLINE & m->flags;

 
        /* 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 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)
+       if ( ! nl)

                return(in_line(m, tok, line, ppos, pos, buf));
 
        /*
                return(in_line(m, tok, line, ppos, pos, buf));
 
        /*


@@ -1494,7 +1639,7 @@ static int
 obsolete(MACRO_PROT_ARGS)
 {
 
 obsolete(MACRO_PROT_ARGS)
 {
 

-       return(mdoc_pwarn(m, line, ppos, EOBS));
+       return(mdoc_pmsg(m, line, ppos, MANDOCERR_MACROOBS));

 }
 
 
 }
 
 


@@ -1507,14 +1652,13 @@ static int
 phrase(struct mdoc *m, int line, int ppos, char *buf)
 {
        int              la, pos;
 phrase(struct mdoc *m, int line, int ppos, char *buf)
 {
        int              la, pos;

-       enum margerr     ac;
+       enum margserr    ac;

        enum mdoct       ntok;
        char            *p;
 
        for (pos = ppos; ; ) {
                la = pos;
 
        enum mdoct       ntok;
        char            *p;
 
        for (pos = ppos; ; ) {
                la = pos;
 

-               /* Note: no calling context! */

                ac = mdoc_zargs(m, line, &pos, buf, 0, &p);
 
                if (ARGS_ERROR == ac)
                ac = mdoc_zargs(m, line, &pos, buf, 0, &p);
 
                if (ARGS_ERROR == ac)


@@ -1539,3 +1683,46 @@ phrase(struct mdoc *m, int line, int ppos, char *buf)
 }
 
 
 }
 
 

+/* ARGSUSED */
+static int
+phrase_ta(MACRO_PROT_ARGS)
+{
+       int               la;
+       enum mdoct        ntok;
+       enum margserr     ac;
+       char             *p;
+
+       /*
+        * FIXME: this is overly restrictive: if the `Ta' is unexpected,
+        * it should simply error out with ARGSLOST.
+        */
+
+       if ( ! rew_sub(MDOC_BODY, m, MDOC_It, line, ppos))
+               return(0);
+       if ( ! mdoc_body_alloc(m, line, ppos, MDOC_It))
+               return(0);
+
+       for (;;) {
+               la = *pos;
+               ac = mdoc_zargs(m, line, pos, buf, 0, &p);
+
+               if (ARGS_ERROR == ac)
+                       return(0);
+               if (ARGS_EOLN == ac)
+                       break;
+
+               ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup_raw(p);
+
+               if (MDOC_MAX == ntok) {
+                       if ( ! mdoc_word_alloc(m, line, la, p))
+                               return(0);
+                       continue;
+               }
+
+               if ( ! mdoc_macro(m, ntok, line, la, pos, buf))
+                       return(0);
+               return(append_delims(m, line, pos, buf));
+       }
+
+       return(1);
+}