Support for maxrmargin-breaking with TERMP_NOBREAK.

[mandoc.git] / mdocterm.c

diff --git a/mdocterm.c b/mdocterm.c
index c0ac1f547a7b99fa0f6585407f6e2e2c80476137..7a0e1230af49bd0223eb1b85e09061e9f712bb5e 100644 (file)
--- a/mdocterm.c
+++ b/mdocterm.c
@@ -1,4 +1,4 @@
-/* $Id: mdocterm.c,v 1.14 2009/02/25 23:18:50 kristaps Exp $ */
+/* $Id: mdocterm.c,v 1.24 2009/03/02 12:09:32 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


@@ -55,6 +85,7 @@ 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              pgraph(struct termp *, char);

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


@@ -82,7 +113,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;


@@ -91,7 +122,7 @@ main(int argc, char *argv[])
        if (NULL == (termp.buf = malloc(termp.maxcols)))
                err(1, "malloc");
 
        if (NULL == (termp.buf = malloc(termp.maxcols)))
                err(1, "malloc");
 

-       /*header(&termp, mdoc_meta(mdoc));*/
+       header(&termp, mdoc_meta(mdoc));

        body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc));
        footer(&termp, mdoc_meta(mdoc));
 
        body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc));
        footer(&termp, mdoc_meta(mdoc));
 


@@ -133,7 +164,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');


@@ -144,9 +174,10 @@ flushln(struct termp *p)
        for (i = 0; i < p->col; i++) {
                /*
                 * Count up visible word characters.  Control sequences
        for (i = 0; i < p->col; i++) {
                /*
                 * Count up visible word characters.  Control sequences

-                * (starting with the CSI) aren't counted. 
+                * (starting with the CSI) aren't counted.  A space
+                * generates a non-printing word, which is valid (the
+                * space is printed according to regular spacing rules).

                 */
                 */

-               assert( ! xisspace(p->buf[i]));

 
                /* LINTED */
                for (j = i, vsz = 0; j < p->col; j++) {
 
                /* LINTED */
                for (j = i, vsz = 0; j < p->col; j++) {


@@ -158,27 +189,35 @@ flushln(struct termp *p)
                        } else
                                vsz++;
                }
                        } else
                                vsz++;
                }

-               assert(vsz > 0);

 
                /*
 
                /*

+                * If we're breaking normally...
+                *

                 * If a word is too long and we're within a line, put it
                 * on the next line.  Puke if we're being asked to write
                 * something that will exceed the right margin (i.e.,
                 * If a word is too long and we're within a line, put it
                 * on the next line.  Puke if we're being asked to write
                 * something that will exceed the right margin (i.e.,

-                * from a fresh line or when we're not allowed to break
-                * the line with TERMP_NOBREAK).
+                * from a fresh line).
+                *
+                * If we're not breaking...
+                *
+                * Don't let the visible size exceed the full right
+                * margin.

                 */
 
                 */
 

-               if (vis && vis + vsz > maxvis) {
-                       /* FIXME */
-                       if (p->flags & TERMP_NOBREAK)
+               if ( ! (TERMP_NOBREAK & p->flags)) {
+                       if (vis && vis + vsz > maxvis) {
+                               putchar('\n');
+                               for (j = 0; j < p->offset; j++)
+                                       putchar(' ');
+                               vis = 0;
+                       } else if (vis + vsz > maxvis)

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

+               } else if (vis + vsz > p->maxrmargin - p->offset) {

                        putchar('\n');
                        putchar('\n');

-                       for (j = 0; j < p->offset; j++)
+                       for (j = 0; j < p->rmargin; j++)

                                putchar(' ');
                                putchar(' ');

-                       vis = 0;
-               } else if (vis + vsz > maxvis)
-                       /* FIXME */
-                       errx(1, "word breaks right margin");
+                       vis = p->rmargin;
+               }

 
                /* 
                 * Write out the word and a trailing space.  Omit the
 
                /* 
                 * Write out the word and a trailing space.  Omit the


@@ -197,15 +236,22 @@ flushln(struct termp *p)
                }
        }
 
                }
        }
 

+       if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {
+               putchar('\n');
+               for (i = 0; i < p->rmargin; i++)
+                       putchar(' ');
+               p->col = 0;
+               return;
+       }
+

        /*
         * If we're not to right-marginalise it (newline), then instead
         * pad to the right margin and stay off.
         */
 
        if (p->flags & TERMP_NOBREAK) {
        /*
         * If we're not to right-marginalise it (newline), then instead
         * pad to the right margin and stay off.
         */
 
        if (p->flags & TERMP_NOBREAK) {

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

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


@@ -258,9 +304,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;
 }
 


@@ -297,23 +350,101 @@ nescape(struct termp *p, const char *word, size_t len)
 {
 
        switch (len) {
 {
 
        switch (len) {

+       case (1):
+               if ('q' == word[0])
+                       stringa(p, TERMSYM_DQUOTE);
+               break;

        case (2):
                if ('r' == word[0] && 'B' == word[1])
        case (2):
                if ('r' == word[0] && 'B' == word[1])

-                       chara(p, ']');
+                       stringa(p, TERMSYM_RBRACK);

                else if ('l' == word[0] && 'B' == word[1])
                else if ('l' == word[0] && 'B' == word[1])

-                       chara(p, '[');
-               else if ('<' == word[0] && '-' == word[1])
-                       stringa(p, "<-");
-               else if ('-' == word[0] && '>' == word[1])
-                       stringa(p, "->");
+                       stringa(p, TERMSYM_LBRACK);

                else if ('l' == word[0] && 'q' == word[1])
                else if ('l' == word[0] && 'q' == word[1])

-                       chara(p, '\"');
+                       stringa(p, TERMSYM_LDQUOTE);

                else if ('r' == word[0] && 'q' == word[1])
                else if ('r' == word[0] && 'q' == word[1])

-                       chara(p, '\"');
+                       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])
                else if ('b' == word[0] && 'u' == word[1])

-                       chara(p, 'o');
+                       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
+pgraph(struct termp *p, char byte)
+{
+       int              i;
+
+       switch (byte) {
+       case (' '):
+               chara(p, ' ');
+               break;
+       case ('\t'):
+               for (i = 0; i < INDENT; i++)
+                       chara(p, ' ');

                break;
        default:
                break;
        default:

+               warnx("unknown non-graphing character");

                break;
        }
 }
                break;
        }
 }


@@ -327,6 +458,11 @@ pescape(struct termp *p, const char *word, size_t *i, size_t len)
        (*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)++;
        if ('(' == word[*i]) {
                /* Two-character escapes. */
                (*i)++;


@@ -335,6 +471,22 @@ pescape(struct termp *p, const char *word, size_t *i, size_t len)
                (*i)++;
                return;
 
                (*i)++;
                return;
 

+       } else if ('*' == word[*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]) {
                /* One-character escapes. */
                switch (word[*i]) {
        } else if ('[' != word[*i]) {
                /* One-character escapes. */
                switch (word[*i]) {


@@ -350,6 +502,10 @@ pescape(struct termp *p, const char *word, size_t *i, size_t len)
                        /* FALLTHROUGH */
                case ('.'):
                        chara(p, word[*i]);
                        /* FALLTHROUGH */
                case ('.'):
                        chara(p, word[*i]);

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

                default:
                        break;
                }
                default:
                        break;
                }


@@ -369,7 +525,11 @@ pword(struct termp *p, const char *word, size_t len)
 {
        size_t           i;
 
 {
        size_t           i;
 

-       /*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))
 
        if ( ! (p->flags & TERMP_NOSPACE) && 
                        ! (p->flags & TERMP_LITERAL))


@@ -378,6 +538,11 @@ pword(struct termp *p, const char *word, size_t len)
        if ( ! (p->flags & TERMP_NONOSPACE))
                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_UNDERLINE)
        if (p->flags & TERMP_BOLD)
                style(p, STYLE_BOLD);
        if (p->flags & TERMP_UNDERLINE)


@@ -388,6 +553,10 @@ pword(struct termp *p, const char *word, size_t len)
                        pescape(p, word, &i, len);
                        continue;
                }
                        pescape(p, word, &i, len);
                        continue;
                }

+               if ( ! isgraph((int)word[i])) {
+                       pgraph(p, word[i]);
+                       continue;
+               }

                chara(p, word[i]);
        }
 
                chara(p, word[i]);
        }
 


@@ -402,6 +571,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;


@@ -421,7 +597,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);


@@ -443,6 +626,12 @@ body(struct termp *p, struct termpair *ppair,
        int              dochild;
        struct termpair  pair;
 
        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;


@@ -488,7 +677,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");


@@ -504,26 +692,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);

 
 

-       printf("\n");
-       printf("%s", os);
-       for (i = 0; i < ssz; i++)
-               printf(" ");
+       p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
+       p->rmargin = p->maxrmargin - strlen(buf);
+       p->offset = 0;
+
+       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);


@@ -533,15 +726,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;
+       char            *buf, *title, *bufp, *vbuf;

        const char      *pp;
        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 */


@@ -566,42 +765,66 @@ 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;
                }

+       }
+       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);
+
+       /*
+        * 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))
 
        if (mdoc_arch2a(meta->arch))

-               (void)snprintf(buf, p->rmargin, "%s(%s)",
-                               pp, mdoc_arch2a(meta->arch));
+               (void)snprintf(buf, p->rmargin, "%s (%s)",
+                               vbuf, mdoc_arch2a(meta->arch));

        else
        else

-               (void)strlcpy(buf, pp, p->rmargin);
+               (void)strlcpy(buf, vbuf, p->rmargin);

 
        pp = mdoc_msec2a(meta->msec);
 
        (void)snprintf(title, p->rmargin, "%s(%s)",
                        meta->title, pp ? pp : "");
 
 
        pp = mdoc_msec2a(meta->msec);
 
        (void)snprintf(title, p->rmargin, "%s(%s)",
                        meta->title, pp ? pp : "");
 

+       for (bufp = title; *bufp; bufp++)
+               *bufp = toupper(*bufp);
+       

        p->offset = 0;
        p->rmargin = (p->maxrmargin - strlen(buf)) / 2;
        p->offset = 0;
        p->rmargin = (p->maxrmargin - strlen(buf)) / 2;

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

 
        word(p, title);
        flushln(p);
 
 
        word(p, title);
        flushln(p);
 

+       p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;

        p->offset = p->rmargin;
        p->offset = p->rmargin;

-       p->rmargin += strlen(buf);
+       p->rmargin = p->maxrmargin - strlen(title);

 
        word(p, buf);
        flushln(p);
 
 
        word(p, buf);
        flushln(p);
 

-       exit(1);
-

        p->offset = p->rmargin;
        p->rmargin = p->maxrmargin;
        p->flags &= ~TERMP_NOBREAK;
        p->offset = p->rmargin;
        p->rmargin = p->maxrmargin;
        p->flags &= ~TERMP_NOBREAK;

+       p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;

 
        word(p, title);
        flushln(p);
 
        word(p, title);
        flushln(p);


@@ -611,5 +834,6 @@ header(struct termp *p, const struct mdoc_meta *meta)
        p->flags &= ~TERMP_NOSPACE;
 
        free(title);
        p->flags &= ~TERMP_NOSPACE;
 
        free(title);

+       free(vbuf);

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