libmdoc accepts whitespace following control character.

[mandoc.git] / mdoc_term.c

diff --git a/mdoc_term.c b/mdoc_term.c
index 41338aa576cd5317de9720790796fec4060206b6..52d770b8e147d386241bb3bcf327089347ccc12a 100644 (file)
--- a/mdoc_term.c
+++ b/mdoc_term.c
@@ -1,4 +1,4 @@
-/*     $Id: mdoc_term.c,v 1.44 2009/07/17 10:56:57 kristaps Exp $ */
+/*     $Id: mdoc_term.c,v 1.66 2009/08/10 10:09:51 kristaps Exp $ */

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


@@ -26,8 +26,10 @@
 #include "term.h"
 #include "mdoc.h"
 
 #include "term.h"
 #include "mdoc.h"
 

+#define        INDENT            5
+#define        HALFINDENT        3
+

 /* FIXME: macro arguments can be escaped. */
 /* FIXME: macro arguments can be escaped. */

-/* FIXME: support more offset/width tokens. */

 
 #define        TTYPE_PROG        0
 #define        TTYPE_CMD_FLAG    1
 
 #define        TTYPE_PROG        0
 #define        TTYPE_CMD_FLAG    1


@@ -51,8 +53,9 @@
 #define        TTYPE_LINK_ANCHOR 19
 #define        TTYPE_LINK_TEXT   20
 #define        TTYPE_REF_JOURNAL 21
 #define        TTYPE_LINK_ANCHOR 19
 #define        TTYPE_LINK_TEXT   20
 #define        TTYPE_REF_JOURNAL 21

-#define        TTYPE_LIST        22
-#define        TTYPE_NMAX        23
+#define        TTYPE_REF_TITLE   22
+#define        TTYPE_LIST        23
+#define        TTYPE_NMAX        24

 
 const  int ttypes[TTYPE_NMAX] = {
        TERMP_BOLD,             /* TTYPE_PROG */
 
 const  int ttypes[TTYPE_NMAX] = {
        TERMP_BOLD,             /* TTYPE_PROG */


@@ -66,7 +69,7 @@ const int ttypes[TTYPE_NMAX] = {
        TERMP_UNDER,            /* TTYPE_FUNC_ARG */
        TERMP_UNDER,            /* TTYPE_LINK */
        TERMP_BOLD,             /* TTYPE_SSECTION */
        TERMP_UNDER,            /* TTYPE_FUNC_ARG */
        TERMP_UNDER,            /* TTYPE_LINK */
        TERMP_BOLD,             /* TTYPE_SSECTION */

-       TERMP_UNDER,            /* TTYPE_FILE */
+       TERMP_UNDER,            /* TTYPE_FILE */

        TERMP_UNDER,            /* TTYPE_EMPH */
        TERMP_BOLD,             /* TTYPE_CONFIG */
        TERMP_BOLD,             /* TTYPE_CMD */
        TERMP_UNDER,            /* TTYPE_EMPH */
        TERMP_BOLD,             /* TTYPE_CONFIG */
        TERMP_BOLD,             /* TTYPE_CMD */


@@ -77,6 +80,7 @@ const int ttypes[TTYPE_NMAX] = {
        TERMP_UNDER,            /* TTYPE_LINK_ANCHOR */
        TERMP_BOLD,             /* TTYPE_LINK_TEXT */
        TERMP_UNDER,            /* TTYPE_REF_JOURNAL */
        TERMP_UNDER,            /* TTYPE_LINK_ANCHOR */
        TERMP_BOLD,             /* TTYPE_LINK_TEXT */
        TERMP_UNDER,            /* TTYPE_REF_JOURNAL */

+       TERMP_UNDER,            /* TTYPE_REF_TITLE */

        TERMP_BOLD              /* TTYPE_LIST */
 };
 
        TERMP_BOLD              /* TTYPE_LIST */
 };
 


@@ -97,7 +101,7 @@ struct       termact {
 };
 
 static void      termp____post(DECL_ARGS);
 };
 
 static void      termp____post(DECL_ARGS);

-static void      termp__t_post(DECL_ARGS);
+static void      termp_an_post(DECL_ARGS);

 static void      termp_aq_post(DECL_ARGS);
 static void      termp_bd_post(DECL_ARGS);
 static void      termp_bl_post(DECL_ARGS);
 static void      termp_aq_post(DECL_ARGS);
 static void      termp_bd_post(DECL_ARGS);
 static void      termp_bl_post(DECL_ARGS);


@@ -124,6 +128,7 @@ static      void      termp_vt_post(DECL_ARGS);
 
 static int       termp__j_pre(DECL_ARGS);
 static int       termp__t_pre(DECL_ARGS);
 
 static int       termp__j_pre(DECL_ARGS);
 static int       termp__t_pre(DECL_ARGS);

+static int       termp_an_pre(DECL_ARGS);

 static int       termp_ap_pre(DECL_ARGS);
 static int       termp_aq_pre(DECL_ARGS);
 static int       termp_ar_pre(DECL_ARGS);
 static int       termp_ap_pre(DECL_ARGS);
 static int       termp_aq_pre(DECL_ARGS);
 static int       termp_ar_pre(DECL_ARGS);


@@ -164,6 +169,7 @@ static      int       termp_rs_pre(DECL_ARGS);
 static int       termp_rv_pre(DECL_ARGS);
 static int       termp_sh_pre(DECL_ARGS);
 static int       termp_sm_pre(DECL_ARGS);
 static int       termp_rv_pre(DECL_ARGS);
 static int       termp_sh_pre(DECL_ARGS);
 static int       termp_sm_pre(DECL_ARGS);

+static int       termp_sp_pre(DECL_ARGS);

 static int       termp_sq_pre(DECL_ARGS);
 static int       termp_ss_pre(DECL_ARGS);
 static int       termp_sx_pre(DECL_ARGS);
 static int       termp_sq_pre(DECL_ARGS);
 static int       termp_ss_pre(DECL_ARGS);
 static int       termp_sx_pre(DECL_ARGS);


@@ -190,7 +196,7 @@ static const struct termact termacts[MDOC_MAX] = {
        { NULL, NULL }, /* El */
        { termp_it_pre, termp_it_post }, /* It */
        { NULL, NULL }, /* Ad */ 
        { NULL, NULL }, /* El */
        { termp_it_pre, termp_it_post }, /* It */
        { NULL, NULL }, /* Ad */ 

-       { NULL, NULL }, /* An */
+       { termp_an_pre, termp_an_post }, /* An */

        { termp_ar_pre, NULL }, /* Ar */
        { termp_cd_pre, NULL }, /* Cd */
        { termp_cm_pre, NULL }, /* Cm */
        { termp_ar_pre, NULL }, /* Ar */
        { termp_cd_pre, NULL }, /* Cd */
        { termp_cm_pre, NULL }, /* Cm */


@@ -225,7 +231,7 @@ static const struct termact termacts[MDOC_MAX] = {
        { NULL, termp____post }, /* %O */
        { NULL, termp____post }, /* %P */
        { NULL, termp____post }, /* %R */
        { NULL, termp____post }, /* %O */
        { NULL, termp____post }, /* %P */
        { NULL, termp____post }, /* %R */

-       { termp__t_pre, termp__t_post }, /* %T */
+       { termp__t_pre, termp____post }, /* %T */

        { NULL, termp____post }, /* %V */
        { NULL, NULL }, /* Ac */
        { termp_aq_pre, termp_aq_post }, /* Ao */
        { NULL, termp____post }, /* %V */
        { NULL, NULL }, /* Ac */
        { termp_aq_pre, termp_aq_post }, /* Ao */


@@ -294,7 +300,7 @@ static const struct termact termacts[MDOC_MAX] = {
        { termp_xx_pre, NULL }, /* Dx */ 
        { NULL, NULL }, /* %Q */ 
        { termp_br_pre, NULL }, /* br */
        { termp_xx_pre, NULL }, /* Dx */ 
        { NULL, NULL }, /* %Q */ 
        { termp_br_pre, NULL }, /* br */

-       { NULL, NULL }, /* sp */ 
+       { termp_sp_pre, NULL }, /* sp */ 

 };
 
 #ifdef __linux__
 };
 
 #ifdef __linux__


@@ -309,7 +315,7 @@ static      int       arg_getattr(int, const struct mdoc_node *);
 static size_t    arg_offset(const struct mdoc_argv *);
 static size_t    arg_width(const struct mdoc_argv *, int);
 static int       arg_listtype(const struct mdoc_node *);
 static size_t    arg_offset(const struct mdoc_argv *);
 static size_t    arg_width(const struct mdoc_argv *, int);
 static int       arg_listtype(const struct mdoc_node *);

-static int       fmt_block_vspace(struct termp *,
+static void      fmt_block_vspace(struct termp *,

                        const struct mdoc_node *,
                        const struct mdoc_node *);
 static void      print_node(DECL_ARGS);
                        const struct mdoc_node *,
                        const struct mdoc_node *);
 static void      print_node(DECL_ARGS);


@@ -363,6 +369,13 @@ print_node(DECL_ARGS)
        npair.flag = 0;
        npair.count = 0;
 
        npair.flag = 0;
        npair.count = 0;
 

+       /*
+        * Note on termpair.  This allows a pre function to set a termp
+        * flag that is automatically unset after the body, but before
+        * the post function.  Thus, if a pre uses a termpair flag, it
+        * must be reapplied in the post for use.
+        */
+

        if (MDOC_TEXT != node->type) {
                if (termacts[node->tok].pre)
                        if ( ! (*termacts[node->tok].pre)(p, &npair, meta, node))
        if (MDOC_TEXT != node->type) {
                if (termacts[node->tok].pre)
                        if ( ! (*termacts[node->tok].pre)(p, &npair, meta, node))


@@ -377,6 +390,8 @@ print_node(DECL_ARGS)
        if (dochild && node->child)
                print_body(p, &npair, meta, node->child);
 
        if (dochild && node->child)
                print_body(p, &npair, meta, node->child);
 

+       p->flags &= ~npair.flag;
+

        /* Post-processing. */
 
        if (MDOC_TEXT != node->type)
        /* Post-processing. */
 
        if (MDOC_TEXT != node->type)


@@ -385,7 +400,6 @@ print_node(DECL_ARGS)
 
        p->offset = offset;
        p->rmargin = rmargin;
 
        p->offset = offset;
        p->rmargin = rmargin;

-       p->flags &= ~npair.flag;

 }
 
 
 }
 
 


@@ -652,7 +666,7 @@ arg_getattrs(const int *keys, int *vals,
 
 
 /* ARGSUSED */
 
 
 /* ARGSUSED */

-static int
+static void

 fmt_block_vspace(struct termp *p, 
                const struct mdoc_node *bl, 
                const struct mdoc_node *node)
 fmt_block_vspace(struct termp *p, 
                const struct mdoc_node *bl, 
                const struct mdoc_node *node)


@@ -661,23 +675,48 @@ fmt_block_vspace(struct termp *p,
 
        term_newln(p);
 
 
        term_newln(p);
 

-       if (arg_hasattr(MDOC_Compact, bl))
-               return(1);
+       if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Compact, bl))
+               return;
+       assert(node);
+
+       /*
+        * Search through our prior nodes.  If we follow a `Ss' or `Sh',
+        * then don't vspace.
+        */

 
        for (n = node; n; n = n->parent) {
                if (MDOC_BLOCK != n->type)
                        continue;
                if (MDOC_Ss == n->tok)
 
        for (n = node; n; n = n->parent) {
                if (MDOC_BLOCK != n->type)
                        continue;
                if (MDOC_Ss == n->tok)

-                       break;
+                       return;

                if (MDOC_Sh == n->tok)
                if (MDOC_Sh == n->tok)

-                       break;
+                       return;

                if (NULL == n->prev)
                        continue;
                if (NULL == n->prev)
                        continue;

-               term_vspace(p);

                break;
        }
 
                break;
        }
 

-       return(1);
+       /* 
+        * XXX - not documented: a `-column' does not ever assert vspace
+        * within the list.
+        */
+
+       if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Column, bl))
+               if (node->prev && MDOC_It == node->prev->tok)
+                       return;
+
+       /*
+        * XXX - not documented: a `-diag' without a body does not
+        * assert a vspace prior to the next element. 
+        */
+       if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Diag, bl)) 
+               if (node->prev && MDOC_It == node->prev->tok) {
+                       assert(node->prev->body);
+                       if (NULL == node->prev->body->child)
+                               return;
+               }
+
+       term_vspace(p);

 }
 
 
 }
 
 


@@ -717,8 +756,10 @@ termp_it_pre(DECL_ARGS)
        int                     i, type, keys[3], vals[3];
        size_t                  width, offset;
 
        int                     i, type, keys[3], vals[3];
        size_t                  width, offset;
 

-       if (MDOC_BLOCK == node->type)
-               return(fmt_block_vspace(p, node->parent->parent, node));
+       if (MDOC_BLOCK == node->type) {
+               fmt_block_vspace(p, node->parent->parent, node);
+               return(1);
+       }

 
        bl = node->parent->parent->parent;
 
 
        bl = node->parent->parent->parent;
 


@@ -747,11 +788,27 @@ termp_it_pre(DECL_ARGS)
        case (MDOC_Column):
                if (MDOC_BODY == node->type)
                        break;
        case (MDOC_Column):
                if (MDOC_BODY == node->type)
                        break;

-               for (i = 0, n = node->prev; n; n = n->prev, i++)
+               /* 
+                * Work around groff's column handling.  The offset is
+                * equal to the sum of all widths leading to the current
+                * column (plus the -offset value).  If this column
+                * exceeds the stated number of columns, the width is
+                * set as 0, else it's the stated column width (later
+                * the 0 will be adjusted to default 10 or, if in the
+                * last column case, set to stretch to the margin).
+                */
+               for (i = 0, n = node->prev; n && n && 
+                               i < (int)bl->args[vals[2]].argv->sz; 
+                               n = n->prev, i++)

                        offset += arg_width 
                                (&bl->args->argv[vals[2]], i);
                        offset += arg_width 
                                (&bl->args->argv[vals[2]], i);

-               assert(i < (int)bl->args->argv[vals[2]].sz);
-               width = arg_width(&bl->args->argv[vals[2]], i);
+
+               /* Whether exceeds maximum column. */
+               if (i < (int)bl->args[vals[2]].argv->sz)
+                       width = arg_width(&bl->args->argv[vals[2]], i);
+               else
+                       width = 0;
+

                if (vals[1] >= 0) 
                        offset += arg_offset(&bl->args->argv[vals[1]]);
                break;
                if (vals[1] >= 0) 
                        offset += arg_offset(&bl->args->argv[vals[1]]);
                break;


@@ -786,6 +843,8 @@ termp_it_pre(DECL_ARGS)
                if (0 == width)
                        width = 8;
                break;
                if (0 == width)
                        width = 8;
                break;

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

        case (MDOC_Tag):
                if (0 == width)
                        width = 10;
        case (MDOC_Tag):
                if (0 == width)
                        width = 10;


@@ -799,18 +858,23 @@ termp_it_pre(DECL_ARGS)
         * while diagonal bodies need two.
         */
 
         * while diagonal bodies need two.
         */
 

+       p->flags |= TERMP_NOSPACE;
+

        switch (type) {
        switch (type) {

+       case (MDOC_Diag):
+               if (MDOC_BODY == node->type)
+                       term_word(p, "\\ \\ ");
+               break;

        case (MDOC_Inset):
                if (MDOC_BODY == node->type) 
        case (MDOC_Inset):
                if (MDOC_BODY == node->type) 

-                       p->flags &= ~TERMP_NOSPACE;
-               else
-                       p->flags |= TERMP_NOSPACE;
+                       term_word(p, "\\ ");

                break;
        default:
                break;
        default:

-               p->flags |= TERMP_NOSPACE;

                break;
        }
 
                break;
        }
 

+       p->flags |= TERMP_NOSPACE;
+

        /*
         * Style flags.  Diagnostic heads need TTYPE_DIAG.
         */
        /*
         * Style flags.  Diagnostic heads need TTYPE_DIAG.
         */


@@ -851,12 +915,26 @@ termp_it_pre(DECL_ARGS)
                else
                        p->flags |= TERMP_NOLPAD;
 
                else
                        p->flags |= TERMP_NOLPAD;
 

-               if (MDOC_HEAD == node->type)
+               if (MDOC_HEAD != node->type)
+                       break;
+
+               /*
+                * This is ugly.  If `-hang' is specified and the body
+                * is a `Bl' or `Bd', then we want basically to nullify
+                * the "overstep" effect in term_flushln() and treat
+                * this as a `-ohang' list instead.
+                */
+               if (node->next->child && 
+                               (MDOC_Bl == node->next->child->tok ||
+                                MDOC_Bd == node->next->child->tok)) {
+                       p->flags &= ~TERMP_NOBREAK;
+                       p->flags &= ~TERMP_NOLPAD;
+               } else

                        p->flags |= TERMP_HANG;
                break;
        case (MDOC_Tag):
                if (MDOC_HEAD == node->type)
                        p->flags |= TERMP_HANG;
                break;
        case (MDOC_Tag):
                if (MDOC_HEAD == node->type)

-                       p->flags |= TERMP_NOBREAK;
+                       p->flags |= TERMP_NOBREAK | TERMP_TWOSPACE;

                else
                        p->flags |= TERMP_NOLPAD;
 
                else
                        p->flags |= TERMP_NOLPAD;
 


@@ -893,6 +971,17 @@ termp_it_pre(DECL_ARGS)
        p->offset += offset;
 
        switch (type) {
        p->offset += offset;
 
        switch (type) {

+       case (MDOC_Hang):
+               /*
+                * Same stipulation as above, regarding `-hang'.  We
+                * don't want to recalculate rmargin and offsets when
+                * using `Bd' or `Bl' within `-hang' overstep lists.
+                */
+               if (MDOC_HEAD == node->type && node->next->child &&
+                               (MDOC_Bl == node->next->child->tok || 
+                                MDOC_Bd == node->next->child->tok))
+                       break;
+               /* FALLTHROUGH */

        case (MDOC_Bullet):
                /* FALLTHROUGH */
        case (MDOC_Dash):
        case (MDOC_Bullet):
                /* FALLTHROUGH */
        case (MDOC_Dash):


@@ -901,16 +990,23 @@ termp_it_pre(DECL_ARGS)
                /* FALLTHROUGH */
        case (MDOC_Hyphen):
                /* FALLTHROUGH */
                /* FALLTHROUGH */
        case (MDOC_Hyphen):
                /* FALLTHROUGH */

-       case (MDOC_Hang):
-               /* FALLTHROUGH */

        case (MDOC_Tag):
        case (MDOC_Tag):

+               assert(width);

                if (MDOC_HEAD == node->type)
                        p->rmargin = p->offset + width;
                else 
                        p->offset += width;
                break;
        case (MDOC_Column):
                if (MDOC_HEAD == node->type)
                        p->rmargin = p->offset + width;
                else 
                        p->offset += width;
                break;
        case (MDOC_Column):

+               assert(width);

                p->rmargin = p->offset + width;
                p->rmargin = p->offset + width;

+               /* 
+                * XXX - this behaviour is not documented: the
+                * right-most column is filled to the right margin.
+                */
+               if (MDOC_HEAD == node->type &&
+                               MDOC_BODY == node->next->type)
+                       p->rmargin = p->maxrmargin;

                break;
        default:
                break;
                break;
        default:
                break;


@@ -987,11 +1083,10 @@ termp_it_post(DECL_ARGS)
        assert(-1 != type);
 
        switch (type) {
        assert(-1 != type);
 
        switch (type) {

-       case (MDOC_Diag):
-               term_word(p, "\\ ");
-               /* FALLTHROUGH */

        case (MDOC_Item):
                /* FALLTHROUGH */
        case (MDOC_Item):
                /* FALLTHROUGH */

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

        case (MDOC_Inset):
                if (MDOC_BODY == node->type)
                        term_flushln(p);
        case (MDOC_Inset):
                if (MDOC_BODY == node->type)
                        term_flushln(p);


@@ -1040,6 +1135,65 @@ termp_fl_pre(DECL_ARGS)
 }
 
 
 }
 
 

+/* ARGSUSED */
+static int
+termp_an_pre(DECL_ARGS)
+{
+
+       if (NULL == node->child)
+               return(1);
+
+       /*
+        * XXX: this is poorly documented.  If not in the AUTHORS
+        * section, `An -split' will cause newlines to occur before the
+        * author name.  If in the AUTHORS section, by default, the
+        * first `An' invocation is nosplit, then all subsequent ones,
+        * regardless of whether interspersed with other macros/text,
+        * are split.  -split, in this case, will override the condition
+        * of the implied first -nosplit.
+        */
+       
+       if (node->sec == SEC_AUTHORS) {
+               if ( ! (TERMP_ANPREC & p->flags)) {
+                       if (TERMP_SPLIT & p->flags)
+                               term_newln(p);
+                       return(1);
+               }
+               if (TERMP_NOSPLIT & p->flags)
+                       return(1);
+               term_newln(p);
+               return(1);
+       }
+
+       if (TERMP_SPLIT & p->flags)
+               term_newln(p);
+
+       return(1);
+}
+
+
+/* ARGSUSED */
+static void
+termp_an_post(DECL_ARGS)
+{
+
+       if (node->child) {
+               if (SEC_AUTHORS == node->sec)
+                       p->flags |= TERMP_ANPREC;
+               return;
+       }
+
+       if (arg_getattr(MDOC_Split, node) > -1) {
+               p->flags &= ~TERMP_NOSPLIT;
+               p->flags |= TERMP_SPLIT;
+       } else {
+               p->flags &= ~TERMP_SPLIT;
+               p->flags |= TERMP_NOSPLIT;
+       }
+
+}
+
+

 /* ARGSUSED */
 static int
 termp_ar_pre(DECL_ARGS)
 /* ARGSUSED */
 static int
 termp_ar_pre(DECL_ARGS)


@@ -1247,10 +1401,18 @@ termp_fd_post(DECL_ARGS)
 static int
 termp_sh_pre(DECL_ARGS)
 {
 static int
 termp_sh_pre(DECL_ARGS)
 {

-
+       /* 
+        * XXX: undocumented: using two `Sh' macros in sequence has no
+        * vspace between calls, only a newline.
+        */

        switch (node->type) {
        switch (node->type) {

-       case (MDOC_HEAD):
+       case (MDOC_BLOCK):
+               if (node->prev && MDOC_Sh == node->prev->tok)
+                       if (NULL == node->prev->body->child)
+                               break;

                term_vspace(p);
                term_vspace(p);

+               break;
+       case (MDOC_HEAD):

                pair->flag |= ttypes[TTYPE_SECTION];
                break;
        case (MDOC_BODY):
                pair->flag |= ttypes[TTYPE_SECTION];
                break;
        case (MDOC_BODY):


@@ -1494,7 +1656,7 @@ termp_va_pre(DECL_ARGS)
 static int
 termp_bd_pre(DECL_ARGS)
 {
 static int
 termp_bd_pre(DECL_ARGS)
 {

-       int              i, type, ln;
+       int              i, type;

 
        /*
         * This is fairly tricky due primarily to crappy documentation.
 
        /*
         * This is fairly tricky due primarily to crappy documentation.


@@ -1507,17 +1669,15 @@ termp_bd_pre(DECL_ARGS)
         * line.  Blank lines are allowed.
         */
 
         * line.  Blank lines are allowed.
         */
 

-       if (MDOC_BLOCK == node->type)
-               return(fmt_block_vspace(p, node, node));
-       else if (MDOC_BODY != node->type)
+       if (MDOC_BLOCK == node->type) {
+               fmt_block_vspace(p, node, node);
+               return(1);
+       } else if (MDOC_BODY != node->type)

                return(1);
 
                return(1);
 

-       /* FIXME: display type should be mandated by parser. */
-
-       if (NULL == node->parent->args)
-               errx(1, "missing display type");
+       assert(node->parent->args);

 
 

-       for (type = -1, i = 0; 
+       for (type = -1, i = 0; -1 == type && 

                        i < (int)node->parent->args->argc; i++) {
                switch (node->parent->args->argv[i].arg) {
                case (MDOC_Ragged):
                        i < (int)node->parent->args->argc; i++) {
                switch (node->parent->args->argv[i].arg) {
                case (MDOC_Ragged):


@@ -1528,22 +1688,17 @@ termp_bd_pre(DECL_ARGS)
                        /* FALLTHROUGH */
                case (MDOC_Literal):
                        type = node->parent->args->argv[i].arg;
                        /* FALLTHROUGH */
                case (MDOC_Literal):
                        type = node->parent->args->argv[i].arg;

-                       i = (int)node->parent->args->argc;

                        break;
                default:
                        break;
                }
        }
                        break;
                default:
                        break;
                }
        }

-
-       if (NULL == node->parent->args)
-               errx(1, "missing display type");
+       
+       assert(type > -1);

 
        i = arg_getattr(MDOC_Offset, node->parent);
 
        i = arg_getattr(MDOC_Offset, node->parent);

-       if (-1 != i) {
-               if (1 != node->parent->args->argv[i].sz)
-                       errx(1, "expected single value");
+       if (-1 != i)

                p->offset += arg_offset(&node->parent->args->argv[i]);
                p->offset += arg_offset(&node->parent->args->argv[i]);

-       }

 
        switch (type) {
        case (MDOC_Literal):
 
        switch (type) {
        case (MDOC_Literal):


@@ -1554,22 +1709,11 @@ termp_bd_pre(DECL_ARGS)
                return(1);
        }
 
                return(1);
        }
 

-       /*
-        * Tricky.  Iterate through all children.  If we're on a
-        * different parse line, append a newline and then the contents.
-        * Ew.
-        */
-
-       p->flags |= TERMP_LITERAL;
-       ln = node->child ? node->child->line : 0;
-

        for (node = node->child; node; node = node->next) {
        for (node = node->child; node; node = node->next) {

-               if (ln < node->line) {
-                       term_flushln(p);
-                       p->flags |= TERMP_NOSPACE;
-               }
-               ln = node->line;
+               p->flags |= TERMP_NOSPACE;

                print_node(p, pair, meta, node);
                print_node(p, pair, meta, node);

+               if (node->next)
+                       term_flushln(p);

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


@@ -1583,10 +1727,8 @@ termp_bd_post(DECL_ARGS)
 
        if (MDOC_BODY != node->type) 
                return;
 
        if (MDOC_BODY != node->type) 
                return;

-
-       term_flushln(p);
-       p->flags &= ~TERMP_LITERAL;

        p->flags |= TERMP_NOSPACE;
        p->flags |= TERMP_NOSPACE;

+       term_flushln(p);

 }
 
 
 }
 
 


@@ -1687,6 +1829,16 @@ termp_sq_post(DECL_ARGS)
 }
 
 
 }
 
 

+/* ARGSUSED */
+static int
+termp_pa_pre(DECL_ARGS)
+{
+
+       pair->flag |= ttypes[TTYPE_FILE];
+       return(1);
+}
+
+

 /* ARGSUSED */
 static int
 termp_pf_pre(DECL_ARGS)
 /* ARGSUSED */
 static int
 termp_pf_pre(DECL_ARGS)


@@ -1740,16 +1892,6 @@ termp_ss_post(DECL_ARGS)
 }
 
 
 }
 
 

-/* ARGSUSED */
-static int
-termp_pa_pre(DECL_ARGS)
-{
-
-       pair->flag |= ttypes[TTYPE_FILE];
-       return(1);
-}
-
-

 /* ARGSUSED */
 static int
 termp_em_pre(DECL_ARGS)
 /* ARGSUSED */
 static int
 termp_em_pre(DECL_ARGS)


@@ -1813,8 +1955,9 @@ static void
 termp_in_post(DECL_ARGS)
 {
 
 termp_in_post(DECL_ARGS)
 {
 

-       p->flags |= TERMP_NOSPACE;
+       p->flags |= TERMP_NOSPACE | ttypes[TTYPE_INCLUDE];

        term_word(p, ">");
        term_word(p, ">");

+       p->flags &= ~ttypes[TTYPE_INCLUDE];

 
        if (SEC_SYNOPSIS != node->sec)
                return;
 
        if (SEC_SYNOPSIS != node->sec)
                return;


@@ -1831,6 +1974,27 @@ termp_in_post(DECL_ARGS)
 }
 
 
 }
 
 

+/* ARGSUSED */
+static int
+termp_sp_pre(DECL_ARGS)
+{
+       int              i, len;
+
+       if (NULL == node->child) {
+               term_vspace(p);
+               return(0);
+       }
+
+       len = atoi(node->child->string);
+       if (0 == len)
+               term_newln(p);
+       for (i = 0; i < len; i++)
+               term_vspace(p);
+
+       return(0);
+}
+
+

 /* ARGSUSED */
 static int
 termp_br_pre(DECL_ARGS)
 /* ARGSUSED */
 static int
 termp_br_pre(DECL_ARGS)


@@ -2049,23 +2213,11 @@ static int
 termp__t_pre(DECL_ARGS)
 {
 
 termp__t_pre(DECL_ARGS)
 {
 

-       term_word(p, "\"");
-       p->flags |= TERMP_NOSPACE;
+       pair->flag |= ttypes[TTYPE_REF_TITLE];

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

-/* ARGSUSED */
-static void
-termp__t_post(DECL_ARGS)
-{
-
-       p->flags |= TERMP_NOSPACE;
-       term_word(p, "\"");
-       termp____post(p, pair, meta, node);
-}
-
-

 /* ARGSUSED */
 static void
 termp____post(DECL_ARGS)
 /* ARGSUSED */
 static void
 termp____post(DECL_ARGS)