White-space churn.

[mandoc.git] / mdocterm.c

diff --git a/mdocterm.c b/mdocterm.c
index 0995da7df9120f8992d4cb9438c8d8e5f6977f4d..02c80e6c1dc17df05b4bf52624bbdc76276e59d1 100644 (file)
--- a/mdocterm.c
+++ b/mdocterm.c
@@ -1,4 +1,4 @@
-       /* $Id: mdocterm.c,v 1.7 2009/02/23 15:34:53 kristaps Exp $ */
+/* $Id: mdocterm.c,v 1.21 2009/02/28 21:31:13 kristaps Exp $ */

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


@@ -16,6 +16,8 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */

+#include <sys/utsname.h>
+

 #include <assert.h>
 #include <ctype.h>
 #include <err.h>
 #include <assert.h>
 #include <ctype.h>
 #include <err.h>


@@ -31,6 +33,34 @@
 #include "mmain.h"
 #include "term.h"
 
 #include "mmain.h"
 #include "term.h"
 

+#define        TERMSYM_RBRACK          "]"
+#define        TERMSYM_LBRACK          "["
+#define        TERMSYM_LARROW          "<-"
+#define        TERMSYM_RARROW          "->"
+#define        TERMSYM_UARROW          "^"
+#define        TERMSYM_DARROW          "v"
+#define        TERMSYM_LSQUOTE         "`"
+#define        TERMSYM_RSQUOTE         "\'"
+#define        TERMSYM_SQUOTE          "\'"
+#define        TERMSYM_LDQUOTE         "``"
+#define        TERMSYM_RDQUOTE         "\'\'"
+#define        TERMSYM_DQUOTE          "\""
+#define        TERMSYM_LT              "<"
+#define        TERMSYM_GT              ">"
+#define        TERMSYM_LE              "<="
+#define        TERMSYM_GE              ">="
+#define        TERMSYM_EQ              "=="
+#define        TERMSYM_NEQ             "!="
+#define        TERMSYM_ACUTE           "\'"
+#define        TERMSYM_GRAVE           "`"
+#define        TERMSYM_PI              "pi"
+#define        TERMSYM_PLUSMINUS       "+="
+#define        TERMSYM_INF             "oo"
+#define        TERMSYM_INF2            "infinity"
+#define        TERMSYM_NAN             "NaN"
+#define        TERMSYM_BAR             "|"
+#define        TERMSYM_BULLET          "o"
+

 #ifdef __NetBSD__
 #define xisspace(x) isspace((int)(x))
 #else
 #ifdef __NetBSD__
 #define xisspace(x) isspace((int)(x))
 #else


@@ -44,6 +74,7 @@ enum  termstyle {
 };
 
 static void              body(struct termp *,
 };
 
 static void              body(struct termp *,

+                               struct termpair *,

                                const struct mdoc_meta *,
                                const struct mdoc_node *);
 static void              header(struct termp *,
                                const struct mdoc_meta *,
                                const struct mdoc_node *);
 static void              header(struct termp *,


@@ -54,6 +85,8 @@ static        void              footer(struct termp *,
 static void              pword(struct termp *, const char *, size_t);
 static void              pescape(struct termp *, 
                                const char *, size_t *, size_t);
 static void              pword(struct termp *, const char *, size_t);
 static void              pescape(struct termp *, 
                                const char *, size_t *, size_t);

+static void              nescape(struct termp *, 
+                               const char *, size_t);

 static void              chara(struct termp *, char);
 static void              stringa(struct termp *, const char *);
 static void              style(struct termp *, enum termstyle);
 static void              chara(struct termp *, char);
 static void              stringa(struct termp *, const char *);
 static void              style(struct termp *, enum termstyle);


@@ -79,7 +112,7 @@ main(int argc, char *argv[])
        if (NULL == (mdoc = mmain_mdoc(p)))
                mmain_exit(p, 1);
 
        if (NULL == (mdoc = mmain_mdoc(p)))
                mmain_exit(p, 1);
 

-       termp.maxrmargin = 80; /* XXX */
+       termp.maxrmargin = 78; /* XXX */

        termp.rmargin = termp.maxrmargin;
        termp.maxcols = 1024;
        termp.offset = termp.col = 0;
        termp.rmargin = termp.maxrmargin;
        termp.maxcols = 1024;
        termp.offset = termp.col = 0;


@@ -89,7 +122,7 @@ main(int argc, char *argv[])
                err(1, "malloc");
 
        header(&termp, mdoc_meta(mdoc));
                err(1, "malloc");
 
        header(&termp, mdoc_meta(mdoc));

-       body(&termp, mdoc_meta(mdoc), mdoc_node(mdoc));
+       body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc));

        footer(&termp, mdoc_meta(mdoc));
 
        free(termp.buf);
        footer(&termp, mdoc_meta(mdoc));
 
        free(termp.buf);


@@ -130,7 +163,6 @@ flushln(struct termp *p)
         * If we're literal, print out verbatim.
         */
        if (p->flags & TERMP_LITERAL) {
         * If we're literal, print out verbatim.
         */
        if (p->flags & TERMP_LITERAL) {

-               /* FIXME: count non-printing chars. */

                for (i = 0; i < p->col; i++)
                        putchar(p->buf[i]);
                putchar('\n');
                for (i = 0; i < p->col; i++)
                        putchar(p->buf[i]);
                putchar('\n');


@@ -165,16 +197,16 @@ flushln(struct termp *p)
                 * the line with TERMP_NOBREAK).
                 */
 
                 * the line with TERMP_NOBREAK).
                 */
 

-               if (vis && vis + vsz >= maxvis) {
-                       /* FIXME */
+               /* FIXME: allow selective right-margin breaking. */
+
+               if (vis && vis + vsz > maxvis) {

                        if (p->flags & TERMP_NOBREAK)
                                errx(1, "word breaks right margin");
                        putchar('\n');
                        for (j = 0; j < p->offset; j++)
                                putchar(' ');
                        vis = 0;
                        if (p->flags & TERMP_NOBREAK)
                                errx(1, "word breaks right margin");
                        putchar('\n');
                        for (j = 0; j < p->offset; j++)
                                putchar(' ');
                        vis = 0;

-               } else if (vis + vsz >= maxvis)
-                       /* FIXME */
+               } else if (vis + vsz > maxvis)

                        errx(1, "word breaks right margin");
 
                /* 
                        errx(1, "word breaks right margin");
 
                /* 


@@ -200,8 +232,9 @@ flushln(struct termp *p)
         */
 
        if (p->flags & TERMP_NOBREAK) {
         */
 
        if (p->flags & TERMP_NOBREAK) {

-               for ( ; vis <= maxvis; vis++)
-                       putchar(' ');
+               if ( ! (p->flags & TERMP_NORPAD))
+                       for ( ; vis < maxvis; vis++)
+                               putchar(' ');

        } else
                putchar('\n');
 
        } else
                putchar('\n');
 


@@ -218,9 +251,12 @@ newln(struct termp *p)
         * vertical space.
         */
        p->flags |= TERMP_NOSPACE;
         * vertical space.
         */
        p->flags |= TERMP_NOSPACE;

-       if (0 == p->col) 
+       if (0 == p->col) {
+               p->flags &= ~TERMP_NOLPAD;

                return;
                return;

+       }

        flushln(p);
        flushln(p);

+       p->flags &= ~TERMP_NOLPAD;

 }
 
 
 }
 
 


@@ -251,9 +287,16 @@ static void
 chara(struct termp *p, char c)
 {
 
 chara(struct termp *p, char c)
 {
 

-       /* TODO: dynamically expand the buffer. */
-       if (p->col + 1 >= p->maxcols)
-               errx(1, "line overrun");
+       /*
+        * Insert a single character into the line-buffer.  If the
+        * buffer's space is exceeded, then allocate more space.
+        */
+       if (p->col + 1 >= p->maxcols) {
+               p->buf = realloc(p->buf, p->maxcols * 2);
+               if (NULL == p->buf)
+                       err(1, "malloc");
+               p->maxcols *= 2;
+       }

        p->buf[(p->col)++] = c;
 }
 
        p->buf[(p->col)++] = c;
 }
 


@@ -285,28 +328,126 @@ style(struct termp *p, enum termstyle esc)
 }
 
 
 }
 
 

+static void
+nescape(struct termp *p, const char *word, size_t len)
+{
+
+       switch (len) {
+       case (1):
+               if ('q' == word[0])
+                       stringa(p, TERMSYM_DQUOTE);
+               break;
+       case (2):
+               if ('r' == word[0] && 'B' == word[1])
+                       stringa(p, TERMSYM_RBRACK);
+               else if ('l' == word[0] && 'B' == word[1])
+                       stringa(p, TERMSYM_LBRACK);
+               else if ('l' == word[0] && 'q' == word[1])
+                       stringa(p, TERMSYM_LDQUOTE);
+               else if ('r' == word[0] && 'q' == word[1])
+                       stringa(p, TERMSYM_RDQUOTE);
+               else if ('o' == word[0] && 'q' == word[1])
+                       stringa(p, TERMSYM_LSQUOTE);
+               else if ('a' == word[0] && 'q' == word[1])
+                       stringa(p, TERMSYM_RSQUOTE);
+               else if ('<' == word[0] && '-' == word[1])
+                       stringa(p, TERMSYM_LARROW);
+               else if ('-' == word[0] && '>' == word[1])
+                       stringa(p, TERMSYM_RARROW);
+               else if ('b' == word[0] && 'u' == word[1])
+                       stringa(p, TERMSYM_BULLET);
+               else if ('<' == word[0] && '=' == word[1])
+                       stringa(p, TERMSYM_LE);
+               else if ('>' == word[0] && '=' == word[1])
+                       stringa(p, TERMSYM_GE);
+               else if ('=' == word[0] && '=' == word[1])
+                       stringa(p, TERMSYM_EQ);
+               else if ('+' == word[0] && '-' == word[1])
+                       stringa(p, TERMSYM_PLUSMINUS);
+               else if ('u' == word[0] && 'a' == word[1])
+                       stringa(p, TERMSYM_UARROW);
+               else if ('d' == word[0] && 'a' == word[1])
+                       stringa(p, TERMSYM_DARROW);
+               else if ('a' == word[0] && 'a' == word[1])
+                       stringa(p, TERMSYM_ACUTE);
+               else if ('g' == word[0] && 'a' == word[1])
+                       stringa(p, TERMSYM_GRAVE);
+               else if ('!' == word[0] && '=' == word[1])
+                       stringa(p, TERMSYM_NEQ);
+               else if ('i' == word[0] && 'f' == word[1])
+                       stringa(p, TERMSYM_INF);
+               else if ('n' == word[0] && 'a' == word[1])
+                       stringa(p, TERMSYM_NAN);
+               else if ('b' == word[0] && 'a' == word[1])
+                       stringa(p, TERMSYM_BAR);
+
+               /* Deprecated forms. */
+               else if ('B' == word[0] && 'a' == word[1])
+                       stringa(p, TERMSYM_BAR);
+               else if ('I' == word[0] && 'f' == word[1])
+                       stringa(p, TERMSYM_INF2);
+               else if ('G' == word[0] && 'e' == word[1])
+                       stringa(p, TERMSYM_GE);
+               else if ('G' == word[0] && 't' == word[1])
+                       stringa(p, TERMSYM_GT);
+               else if ('L' == word[0] && 'e' == word[1])
+                       stringa(p, TERMSYM_LE);
+               else if ('L' == word[0] && 'q' == word[1])
+                       stringa(p, TERMSYM_LDQUOTE);
+               else if ('L' == word[0] && 't' == word[1])
+                       stringa(p, TERMSYM_LT);
+               else if ('N' == word[0] && 'a' == word[1])
+                       stringa(p, TERMSYM_NAN);
+               else if ('N' == word[0] && 'e' == word[1])
+                       stringa(p, TERMSYM_NEQ);
+               else if ('P' == word[0] && 'i' == word[1])
+                       stringa(p, TERMSYM_PI);
+               else if ('P' == word[0] && 'm' == word[1])
+                       stringa(p, TERMSYM_PLUSMINUS);
+               else if ('R' == word[0] && 'q' == word[1])
+                       stringa(p, TERMSYM_RDQUOTE);
+               break;
+       default:
+               break;
+       }
+}
+
+

 static void
 pescape(struct termp *p, const char *word, size_t *i, size_t len)
 {
 static void
 pescape(struct termp *p, const char *word, size_t *i, size_t len)
 {

+       size_t           j;

 
        (*i)++;
        assert(*i < len);
 
 
        (*i)++;
        assert(*i < len);
 

+       /*
+        * Handle an escape sequence.  This must manage both groff-style
+        * escapes and mdoc-style escapes.
+        */
+

        if ('(' == word[*i]) {
                /* Two-character escapes. */
                (*i)++;
                assert(*i + 1 < len);
        if ('(' == word[*i]) {
                /* Two-character escapes. */
                (*i)++;
                assert(*i + 1 < len);

+               nescape(p, &word[*i], 2);
+               (*i)++;
+               return;

 
 

-               if ('r' == word[*i] && 'B' == word[*i + 1])
-                       chara(p, ']');
-               else if ('l' == word[*i] && 'B' == word[*i + 1])
-                       chara(p, '[');
-               else if ('<' == word[*i] && '-' == word[*i + 1])
-                       stringa(p, "<-");
-               else if ('-' == word[*i] && '>' == word[*i + 1])
-                       stringa(p, "->");
-
+       } else if ('*' == word[*i]) { 

                (*i)++;
                (*i)++;

+               assert(*i < len);
+               switch (word[*i]) {
+               case ('('):
+                       (*i)++;
+                       assert(*i + 1 < len);
+                       nescape(p, &word[*i], 2);
+                       (*i)++;
+                       return;
+               default:
+                       break;
+               }
+               nescape(p, &word[*i], 1);

                return;
 
        } else if ('[' != word[*i]) {
                return;
 
        } else if ('[' != word[*i]) {


@@ -320,14 +461,25 @@ pescape(struct termp *p, const char *word, size_t *i, size_t len)
                        /* FALLTHROUGH */
                case ('-'):
                        /* FALLTHROUGH */
                        /* FALLTHROUGH */
                case ('-'):
                        /* FALLTHROUGH */

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

                case ('.'):
                        chara(p, word[*i]);
                case ('.'):
                        chara(p, word[*i]);

+                       break;
+               case ('e'):
+                       chara(p, '\\');
+                       break;

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

-       /* n-character escapes. */
+
+       (*i)++;
+       for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)
+               /* Loop... */ ;
+
+       nescape(p, &word[*i - j], j);

 }
 
 
 }
 
 


@@ -338,11 +490,23 @@ pword(struct termp *p, const char *word, size_t len)
 
        /*assert(len > 0);*/ /* Can be, if literal. */
 
 
        /*assert(len > 0);*/ /* Can be, if literal. */
 

+       /*
+        * Handle pwords, partial words, which may be either a single
+        * word or a phrase that cannot be broken down (such as a
+        * literal string).  This handles word styling.
+        */
+

        if ( ! (p->flags & TERMP_NOSPACE) && 
                        ! (p->flags & TERMP_LITERAL))
                chara(p, ' ');
 
        if ( ! (p->flags & TERMP_NOSPACE) && 
                        ! (p->flags & TERMP_LITERAL))
                chara(p, ' ');
 

-       p->flags &= ~TERMP_NOSPACE;
+       if ( ! (p->flags & TERMP_NONOSPACE))
+               p->flags &= ~TERMP_NOSPACE;
+
+       /* 
+        * XXX - if literal and underlining, this will underline the
+        * spaces between literal words. 
+        */

 
        if (p->flags & TERMP_BOLD)
                style(p, STYLE_BOLD);
 
        if (p->flags & TERMP_BOLD)
                style(p, STYLE_BOLD);


@@ -368,6 +532,13 @@ word(struct termp *p, const char *word)
 {
        size_t           i, j, len;
 
 {
        size_t           i, j, len;
 

+       /*
+        * Break apart a word into tokens.  If we're a literal word,
+        * then don't.  This doesn't handle zero-length words (there
+        * should be none) and makes sure that pword doesn't get spaces
+        * or nil words unless literal.
+        */
+

        if (p->flags & TERMP_LITERAL) {
                pword(p, word, strlen(word));
                return;
        if (p->flags & TERMP_LITERAL) {
                pword(p, word, strlen(word));
                return;


@@ -387,7 +558,14 @@ word(struct termp *p, const char *word)
                if ( ! xisspace(word[i])) {
                        j++;
                        continue;
                if ( ! xisspace(word[i])) {
                        j++;
                        continue;

+               } 
+               
+               /* Escaped spaces don't delimit... */
+               if (i > 0 && xisspace(word[i]) && '\\' == word[i - 1]) {
+                       j++;
+                       continue;

                }
                }

+

                if (0 == j)
                        continue;
                assert(i >= j);
                if (0 == j)
                        continue;
                assert(i >= j);


@@ -402,37 +580,56 @@ word(struct termp *p, const char *word)
 
 
 static void
 
 
 static void

-body(struct termp *p, const struct mdoc_meta *meta,
+body(struct termp *p, struct termpair *ppair,
+               const struct mdoc_meta *meta,

                const struct mdoc_node *node)
 {
        int              dochild;
                const struct mdoc_node *node)
 {
        int              dochild;

+       struct termpair  pair;
+
+       /*
+        * This is the main function for printing out nodes.  It's
+        * constituted of PRE and POST functions, which correspond to
+        * prefix and infix processing.
+        */

 
        /* Pre-processing. */
 
        dochild = 1;
 
        /* Pre-processing. */
 
        dochild = 1;

+       pair.ppair = ppair;
+       pair.type = 0;
+       pair.offset = pair.rmargin = 0;
+       pair.flag = 0;
+       pair.count = 0;

 
        if (MDOC_TEXT != node->type) {
                if (termacts[node->tok].pre)
 
        if (MDOC_TEXT != node->type) {
                if (termacts[node->tok].pre)

-                       if ( ! (*termacts[node->tok].pre)(p, meta, node))
+                       if ( ! (*termacts[node->tok].pre)(p, &pair, meta, node))

                                dochild = 0;
        } else /* MDOC_TEXT == node->type */
                word(p, node->data.text.string);
 
        /* Children. */
 
                                dochild = 0;
        } else /* MDOC_TEXT == node->type */
                word(p, node->data.text.string);
 
        /* Children. */
 

+       if (TERMPAIR_FLAG & pair.type)
+               p->flags |= pair.flag;
+

        if (dochild && node->child)
        if (dochild && node->child)

-               body(p, meta, node->child);
+               body(p, &pair, meta, node->child);
+
+       if (TERMPAIR_FLAG & pair.type)
+               p->flags &= ~pair.flag;

 
        /* Post-processing. */
 
        if (MDOC_TEXT != node->type)
                if (termacts[node->tok].post)
 
        /* Post-processing. */
 
        if (MDOC_TEXT != node->type)
                if (termacts[node->tok].post)

-                       (*termacts[node->tok].post)(p, meta, node);
+                       (*termacts[node->tok].post)(p, &pair, meta, node);

 
        /* Siblings. */
 
        if (node->next)
 
        /* Siblings. */
 
        if (node->next)

-               body(p, meta, node->next);
+               body(p, ppair, meta, node->next);

 }
 
 
 }
 
 


@@ -441,7 +638,6 @@ footer(struct termp *p, const struct mdoc_meta *meta)
 {
        struct tm       *tm;
        char            *buf, *os;
 {
        struct tm       *tm;
        char            *buf, *os;

-       size_t           sz, osz, ssz, i;

 
        if (NULL == (buf = malloc(p->rmargin)))
                err(1, "malloc");
 
        if (NULL == (buf = malloc(p->rmargin)))
                err(1, "malloc");


@@ -457,26 +653,31 @@ footer(struct termp *p, const struct mdoc_meta *meta)
 #endif
                err(1, "strftime");
 
 #endif
                err(1, "strftime");
 

-       osz = strlcpy(os, meta->os, p->rmargin);
+       (void)strlcpy(os, meta->os, p->rmargin);

 
 

-       sz = strlen(buf);
-       ssz = sz + osz + 1;
+       /*
+        * This is /slightly/ different from regular groff output
+        * because we don't have page numbers.  Print the following:
+        *
+        * OS                                            MDOCDATE
+        */

 
 

-       if (ssz > p->rmargin) {
-               ssz -= p->rmargin;
-               assert(ssz <= osz);
-               os[osz - ssz] = 0;
-               ssz = 1;
-       } else
-               ssz = p->rmargin - ssz + 1;
+       vspace(p);
+
+       p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
+       p->rmargin = p->maxrmargin - strlen(buf);
+       p->offset = 0;

 
 

-       printf("\n");
-       printf("%s", os);
-       for (i = 0; i < ssz; i++)
-               printf(" ");
+       word(p, os);
+       flushln(p);

 
 

-       printf("%s\n", buf);
-       fflush(stdout);
+       p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
+       p->offset = p->rmargin;
+       p->rmargin = p->maxrmargin;
+       p->flags &= ~TERMP_NOBREAK;
+
+       word(p, buf);
+       flushln(p);

 
        free(buf);
        free(os);
 
        free(buf);
        free(os);


@@ -486,16 +687,21 @@ footer(struct termp *p, const struct mdoc_meta *meta)
 static void
 header(struct termp *p, const struct mdoc_meta *meta)
 {
 static void
 header(struct termp *p, const struct mdoc_meta *meta)
 {

-       char            *buf, *title;
-       const char      *pp, *msec;
-       size_t           ssz, tsz, ttsz, i;;
+       char            *buf, *title, *bufp, *vbuf;
+       const char      *pp;
+       struct utsname   uts;
+
+       p->rmargin = p->maxrmargin;
+       p->offset = 0;

 
        if (NULL == (buf = malloc(p->rmargin)))
                err(1, "malloc");
        if (NULL == (title = malloc(p->rmargin)))
                err(1, "malloc");
 
        if (NULL == (buf = malloc(p->rmargin)))
                err(1, "malloc");
        if (NULL == (title = malloc(p->rmargin)))
                err(1, "malloc");

+       if (NULL == (vbuf = malloc(p->rmargin)))
+               err(1, "malloc");

 
 

-       if (NULL == (pp = mdoc_vol2a(meta->vol)))
+       if (NULL == (pp = mdoc_vol2a(meta->vol))) {

                switch (meta->msec) {
                case (MSEC_1):
                        /* FALLTHROUGH */
                switch (meta->msec) {
                case (MSEC_1):
                        /* FALLTHROUGH */


@@ -520,56 +726,75 @@ header(struct termp *p, const struct mdoc_meta *meta)
                        pp = mdoc_vol2a(VOL_KM);
                        break;
                default:
                        pp = mdoc_vol2a(VOL_KM);
                        break;
                default:

-                       /* FIXME: capitalise. */
-                       if (NULL == (pp = mdoc_msec2a(meta->msec)))
-                               pp = mdoc_msec2a(MSEC_local);

                        break;
                }
                        break;
                }

-       assert(pp);
-
-       tsz = strlcpy(buf, pp, p->rmargin);
-       assert(tsz < p->rmargin);
-
-       if ((pp = mdoc_arch2a(meta->arch))) {
-               tsz = strlcat(buf, " (", p->rmargin);
-               assert(tsz < p->rmargin);
-               tsz = strlcat(buf, pp, p->rmargin);
-               assert(tsz < p->rmargin);
-               tsz = strlcat(buf, ")", p->rmargin);
-               assert(tsz < p->rmargin);

        }
        }

+       vbuf[0] = 0;
+
+       if (pp) {
+               if (-1 == uname(&uts)) 
+                       err(1, "uname");
+               (void)strlcat(vbuf, uts.sysname, p->rmargin);
+               (void)strlcat(vbuf, " ", p->rmargin);
+       } else if (NULL == (pp = mdoc_msec2a(meta->msec)))
+               pp = mdoc_msec2a(MSEC_local);
+
+       (void)strlcat(vbuf, pp, p->rmargin);

 
 

-       ttsz = strlcpy(title, meta->title, p->rmargin);
+       /*
+        * The header is strange.  It has three components, which are
+        * really two with the first duplicated.  It goes like this:
+        *
+        * IDENTIFIER              TITLE                   IDENTIFIER
+        *
+        * The IDENTIFIER is NAME(SECTION), which is the command-name
+        * (if given, or "unknown" if not) followed by the manual page
+        * section.  These are given in `Dt'.  The TITLE is a free-form
+        * string depending on the manual volume.  If not specified, it
+        * switches on the manual section.
+        */
+
+       if (mdoc_arch2a(meta->arch))
+               (void)snprintf(buf, p->rmargin, "%s (%s)",
+                               vbuf, mdoc_arch2a(meta->arch));
+       else
+               (void)strlcpy(buf, vbuf, p->rmargin);

 
 

-       if (NULL == (msec = mdoc_msec2a(meta->msec)))
-               msec = "";
+       pp = mdoc_msec2a(meta->msec);

 
 

-       ssz = (2 * (ttsz + 2 + strlen(msec))) + tsz + 2;
+       (void)snprintf(title, p->rmargin, "%s(%s)",
+                       meta->title, pp ? pp : "");

 
 

-       if (ssz > p->rmargin) {
-               if ((ssz -= p->rmargin) % 2)
-                       ssz++;
-               ssz /= 2;
+       for (bufp = title; *bufp; bufp++)
+               *bufp = toupper(*bufp);

        
        

-               assert(ssz <= ttsz);
-               title[ttsz - ssz] = 0;
-               ssz = 1;
-       } else
-               ssz = ((p->rmargin - ssz) / 2) + 1;
+       p->offset = 0;
+       p->rmargin = (p->maxrmargin - strlen(buf)) / 2;
+       p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;

 
 

-       printf("%s(%s)", title, msec);
+       word(p, title);
+       flushln(p);

 
 

-       for (i = 0; i < ssz; i++)
-               printf(" ");
+       p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
+       p->offset = p->rmargin;
+       p->rmargin = p->maxrmargin - strlen(title);

 
 

-       printf("%s", buf);
+       word(p, buf);
+       flushln(p);
+
+       p->offset = p->rmargin;
+       p->rmargin = p->maxrmargin;
+       p->flags &= ~TERMP_NOBREAK;
+       p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;

 
 

-       for (i = 0; i < ssz; i++)
-               printf(" ");
+       word(p, title);
+       flushln(p);

 
 

-       printf("%s(%s)\n", title, msec);
-       fflush(stdout);
+       p->rmargin = p->maxrmargin;
+       p->offset = 0;
+       p->flags &= ~TERMP_NOSPACE;

 
        free(title);
 
        free(title);

+       free(vbuf);

        free(buf);
 }
        free(buf);
 }