Cleaned up ctype functions (netbsd).

[mandoc.git] / mdocterm.c

diff --git a/mdocterm.c b/mdocterm.c
index 499c4da18d21b86ddf13050beed7a02b23ac2c89..278d224e840a53f1f8d441977a583835d1b2692a 100644 (file)
--- a/mdocterm.c
+++ b/mdocterm.c
@@ -1,4 +1,4 @@
-/* $Id: mdocterm.c,v 1.23 2009/03/01 23:23:55 kristaps Exp $ */
+/* $Id: mdocterm.c,v 1.33 2009/03/05 13:12:12 kristaps Exp $ */

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


@@ -25,7 +25,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

-

 #ifndef __OpenBSD__
 #include <time.h>
 #endif
 #ifndef __OpenBSD__
 #include <time.h>
 #endif


@@ -33,44 +32,9 @@
 #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
-#define        xisspace(x) isspace((x))
-#endif
-
-enum   termstyle {
-       STYLE_CLEAR,
-       STYLE_BOLD,
-       STYLE_UNDERLINE
+struct termenc {
+       const char       *enc;
+       int               sym;

 };
 
 static void              body(struct termp *,
 };
 
 static void              body(struct termp *,


@@ -83,19 +47,136 @@ static     void              footer(struct termp *,
                                const struct mdoc_meta *);
 
 static void              pword(struct termp *, const char *, size_t);
                                const struct mdoc_meta *);
 
 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 *, 
+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);
                                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              stringa(struct termp *, 
+                               const char *, size_t);
+static void              symbola(struct termp *, enum tsym);
+static void              stylea(struct termp *, enum tstyle);

 
 #ifdef __linux__
 extern size_t            strlcat(char *, const char *, size_t);
 extern size_t            strlcpy(char *, const char *, size_t);
 #endif
 
 
 #ifdef __linux__
 extern size_t            strlcat(char *, const char *, size_t);
 extern size_t            strlcpy(char *, const char *, size_t);
 #endif
 

+static struct termenc    termenc1[] = {
+       { "\\",           TERMSYM_SLASH },
+       { "\'",           TERMSYM_RSQUOTE },
+       { "`",            TERMSYM_LSQUOTE },
+       { "-",            TERMSYM_HYPHEN },
+       { " ",            TERMSYM_SPACE },
+       { ".",            TERMSYM_PERIOD },
+       { "&",            TERMSYM_BREAK },
+       { "e",            TERMSYM_SLASH },
+       { "q",            TERMSYM_DQUOTE },
+       { NULL,           0 }
+};
+
+static struct termenc    termenc2[] = {
+       { "rB",           TERMSYM_RBRACK },
+       { "lB",           TERMSYM_LBRACK },
+       { "ra",           TERMSYM_RANGLE },
+       { "la",           TERMSYM_LANGLE },
+       { "Lq",           TERMSYM_LDQUOTE },
+       { "lq",           TERMSYM_LDQUOTE },
+       { "Rq",           TERMSYM_RDQUOTE },
+       { "rq",           TERMSYM_RDQUOTE },
+       { "oq",           TERMSYM_LSQUOTE },
+       { "aq",           TERMSYM_RSQUOTE },
+
+       { "<-",           TERMSYM_LARROW },
+       { "->",           TERMSYM_RARROW },
+       { "ua",           TERMSYM_UARROW },
+       { "da",           TERMSYM_DARROW },
+
+       { "bu",           TERMSYM_BULLET },
+       { "Ba",           TERMSYM_BAR },
+       { "ba",           TERMSYM_BAR },
+       { "co",           TERMSYM_COPY },
+       { "Am",           TERMSYM_AMP },
+
+       { "Le",           TERMSYM_LE },
+       { "<=",           TERMSYM_LE },
+       { "Ge",           TERMSYM_GE },
+       { ">=",           TERMSYM_GE },
+       { "==",           TERMSYM_EQ },
+       { "Ne",           TERMSYM_NEQ },
+       { "!=",           TERMSYM_NEQ },
+       { "Pm",           TERMSYM_PLUSMINUS },
+       { "+-",           TERMSYM_PLUSMINUS },
+       { "If",           TERMSYM_INF2 },
+       { "if",           TERMSYM_INF },
+       { "Na",           TERMSYM_NAN },
+       { "na",           TERMSYM_NAN },
+       { "**",           TERMSYM_ASTERISK },
+       { "Gt",           TERMSYM_GT },
+       { "Lt",           TERMSYM_LT },
+
+       { "aa",           TERMSYM_ACUTE },
+       { "ga",           TERMSYM_GRAVE },
+
+       { "en",           TERMSYM_EN },
+       { "em",           TERMSYM_EM },
+
+       { "Pi",           TERMSYM_PI },
+       { NULL,           0 }
+};
+
+static struct termsym    termsym_ansi[] = {
+       { "]", 1 },             /* TERMSYM_RBRACK */
+       { "[", 1 },             /* TERMSYM_LBRACK */
+       { "<-", 2 },            /* TERMSYM_LARROW */
+       { "->", 2 },            /* TERMSYM_RARROW */
+       { "^", 1 },             /* TERMSYM_UARROW */
+       { "v", 1 },             /* TERMSYM_DARROW */
+       { "`", 1 },             /* TERMSYM_LSQUOTE */
+       { "\'", 1 },            /* TERMSYM_RSQUOTE */
+       { "\'", 1 },            /* TERMSYM_SQUOTE */
+       { "``", 2 },            /* TERMSYM_LDQUOTE */
+       { "\'\'", 2 },          /* TERMSYM_RDQUOTE */
+       { "\"", 1 },            /* TERMSYM_DQUOTE */
+       { "<", 1 },             /* TERMSYM_LT */
+       { ">", 1 },             /* TERMSYM_GT */
+       { "<=", 2 },            /* TERMSYM_LE */
+       { ">=", 2 },            /* TERMSYM_GE */
+       { "==", 2 },            /* TERMSYM_EQ */
+       { "!=", 2 },            /* TERMSYM_NEQ */
+       { "\'", 1 },            /* TERMSYM_ACUTE */
+       { "`", 1 },             /* TERMSYM_GRAVE */
+       { "pi", 2 },            /* TERMSYM_PI */
+       { "+=", 2 },            /* TERMSYM_PLUSMINUS */
+       { "oo", 2 },            /* TERMSYM_INF */
+       { "infinity", 8 },      /* TERMSYM_INF2 */
+       { "NaN", 3 },           /* TERMSYM_NAN */
+       { "|", 1 },             /* TERMSYM_BAR */
+       { "o", 1 },             /* TERMSYM_BULLET */
+       { "&", 1 },             /* TERMSYM_AMP */
+       { "--", 2 },            /* TERMSYM_EM */
+       { "-", 1 },             /* TERMSYM_EN */
+       { "(C)", 3 },           /* TERMSYM_COPY */
+       { "*", 1 },             /* TERMSYM_ASTERISK */
+       { "\\", 1 },            /* TERMSYM_SLASH */
+       { "-", 1 },             /* TERMSYM_HYPHEN */
+       { " ", 1 },             /* TERMSYM_SPACE */
+       { ".", 1 },             /* TERMSYM_PERIOD */
+       { "", 0 },              /* TERMSYM_BREAK */
+       { "<", 1 },             /* TERMSYM_LANGLE */
+       { ">", 1 },             /* TERMSYM_RANGLE */
+};
+
+static const char        ansi_clear[]  = { 27, '[', '0', 'm' };
+static const char        ansi_bold[]  = { 27, '[', '1', 'm' };
+static const char        ansi_under[]  = { 27, '[', '4', 'm' };
+
+static struct termsym    termstyle_ansi[] = {
+       { ansi_clear, 4 },
+       { ansi_bold, 4 },
+       { ansi_under, 4 }
+};
+

 
 int
 main(int argc, char *argv[])
 
 int
 main(int argc, char *argv[])


@@ -112,11 +193,12 @@ 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 = 78; /* XXX */
-       termp.rmargin = termp.maxrmargin;
+       termp.maxrmargin = termp.rmargin = 78; /* XXX */

        termp.maxcols = 1024;
        termp.offset = termp.col = 0;
        termp.flags = TERMP_NOSPACE;
        termp.maxcols = 1024;
        termp.offset = termp.col = 0;
        termp.flags = TERMP_NOSPACE;

+       termp.symtab = termsym_ansi;
+       termp.styletab = termstyle_ansi;

 
        if (NULL == (termp.buf = malloc(termp.maxcols)))
                err(1, "malloc");
 
        if (NULL == (termp.buf = malloc(termp.maxcols)))
                err(1, "malloc");


@@ -132,10 +214,42 @@ main(int argc, char *argv[])
 }
 
 
 }
 
 

+/*
+ * Flush a line of text.  A "line" is loosely defined as being something
+ * that should be followed by a newline, regardless of whether it's
+ * broken apart by newlines getting there.  A line can also be a
+ * fragment of a columnar list.
+ *
+ * Specifically, a line is whatever's in p->buf of length p->col, which
+ * is zeroed after this function returns.
+ *
+ * The variables TERMP_NOLPAD, TERMP_LITERAL and TERMP_NOBREAK are of
+ * critical importance here.  Their behaviour follows:
+ *
+ *  - TERMP_NOLPAD: when beginning to write the line, don't left-pad the
+ *    offset value.  This is useful when doing columnar lists where the
+ *    prior column has right-padded.
+ *
+ *  - TERMP_NOBREAK: this is the most important and is used when making
+ *    columns.  In short: don't print a newline and instead pad to the
+ *    right margin.  Used in conjunction with TERMP_NOLPAD.
+ *
+ *  In-line line breaking:
+ *
+ *  If TERMP_NOBREAK is specified and the line overruns the right
+ *  margin, it will break and pad-right to the right margin after
+ *  writing.  If maxrmargin is violated, it will break and continue
+ *  writing from the right-margin, which will lead to the above
+ *  scenario upon exit.
+ *
+ *  Otherwise, the line will break at the right margin.  Extremely long
+ *  lines will cause the system to emit a warning (TODO: hyphenate, if
+ *  possible).
+ */

 void
 flushln(struct termp *p)
 {
 void
 flushln(struct termp *p)
 {

-       size_t           i, j, vsz, vis, maxvis;
+       size_t           i, j, vsz, vis, maxvis, mmax, bp;

 
        /*
         * First, establish the maximum columns of "visible" content.
 
        /*
         * First, establish the maximum columns of "visible" content.


@@ -146,6 +260,8 @@ flushln(struct termp *p)
 
        assert(p->offset < p->rmargin);
        maxvis = p->rmargin - p->offset;
 
        assert(p->offset < p->rmargin);
        maxvis = p->rmargin - p->offset;

+       mmax = p->maxrmargin - p->offset;
+       bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;

        vis = 0;
 
        /*
        vis = 0;
 
        /*


@@ -159,17 +275,6 @@ flushln(struct termp *p)
                for (j = 0; j < p->offset; j++)
                        putchar(' ');
 
                for (j = 0; j < p->offset; j++)
                        putchar(' ');
 

-       /*
-        * If we're literal, print out verbatim.
-        */
-       if (p->flags & TERMP_LITERAL) {
-               for (i = 0; i < p->col; i++)
-                       putchar(p->buf[i]);
-               putchar('\n');
-               p->col = 0;
-               return;
-       }
-

        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


@@ -178,9 +283,11 @@ flushln(struct termp *p)
                 * space is printed according to regular spacing rules).
                 */
 
                 * space is printed according to regular spacing rules).
                 */
 

+               /* FIXME: make non-ANSI friendly. */
+

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

-                       if (xisspace(p->buf[j]))
+                       if (isspace((u_char)p->buf[j]))

                                break;
                        else if (27 == p->buf[j]) {
                                assert(j + 4 <= p->col);
                                break;
                        else if (27 == p->buf[j]) {
                                assert(j + 4 <= p->col);


@@ -190,50 +297,65 @@ flushln(struct termp *p)
                }
 
                /*
                }
 
                /*

-                * 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.,
-                * from a fresh line).
-                *
-                * If we're not breaking...
-                *
-                * Don't let the visible size exceed the full margin.
+                * Do line-breaking.  If we're greater than our
+                * break-point and already in-line, break to the next
+                * line and start writing.  If we're at the line start,
+                * then write out the word (TODO: hyphenate) and break
+                * in a subsequent loop invocation.

                 */
 
                if ( ! (TERMP_NOBREAK & p->flags)) {
                 */
 
                if ( ! (TERMP_NOBREAK & p->flags)) {

-                       if (vis && vis + vsz > maxvis) {
+                       if (vis && vis + vsz > bp) {

                                putchar('\n');
                                for (j = 0; j < p->offset; j++)
                                        putchar(' ');
                                vis = 0;
                                putchar('\n');
                                for (j = 0; j < p->offset; j++)
                                        putchar(' ');
                                vis = 0;

-                       } else if (vis + vsz > maxvis)
-                               errx(1, "word breaks right margin");
-               } else if (vis + vsz > p->maxrmargin)
-                       errx(1, "word breaks right margin");
+                       } else if (vis + vsz > bp)
+                               warnx("word breaks right margin");
+
+                       /* TODO: hyphenate. */
+
+               } else {
+                       if (vis && vis + vsz > bp) {
+                               putchar('\n');
+                               for (j = 0; j < p->rmargin; j++)
+                                       putchar(' ');
+                               vis = p->rmargin - p->offset;
+                       } else if (vis + vsz > bp) 
+                               warnx("word breaks right margin");
+
+                       /* TODO: hyphenate. */
+               }

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

-                * space if we're the last word in the line.
+                * space if we're the last word in the line or beyond
+                * our breakpoint.

                 */
 
                for ( ; i < p->col; i++) {
                 */
 
                for ( ; i < p->col; i++) {

-                       if (xisspace(p->buf[i]))
+                       if (isspace((u_char)p->buf[i]))

                                break;
                        putchar(p->buf[i]);
                }
                vis += vsz;
                                break;
                        putchar(p->buf[i]);
                }
                vis += vsz;

-               if (i < p->col) {
+               if (i < p->col && vis <= bp) {

                        putchar(' ');
                        vis++;
                }
        }
 
                        putchar(' ');
                        vis++;
                }
        }
 

+       /*
+        * If we've overstepped our maximum visible no-break space, then
+        * cause a newline and offset at the right margin.
+        */
+

        if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {
        if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {

-               putchar('\n');
-               for (i = 0; i < p->rmargin; i++)
-                       putchar(' ');
+               if ( ! (TERMP_NONOBREAK & p->flags)) {
+                       putchar('\n');
+                       for (i = 0; i < p->rmargin; i++)
+                               putchar(' ');
+               }

                p->col = 0;
                return;
        }
                p->col = 0;
                return;
        }


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

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

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


@@ -253,14 +376,15 @@ flushln(struct termp *p)
 }
 
 
 }
 
 

+/* 
+ * A newline only breaks an existing line; it won't assert vertical
+ * space.  All data in the output buffer is flushed prior to the newline
+ * assertion.
+ */

 void
 newln(struct termp *p)
 {
 
 void
 newln(struct termp *p)
 {
 

-       /* 
-        * A newline only breaks an existing line; it won't assert
-        * vertical space.
-        */

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


@@ -271,283 +395,32 @@ newln(struct termp *p)
 }
 
 
 }
 
 

+/*
+ * Asserts a vertical space (a full, empty line-break between lines).
+ * Note that if used twice, this will cause two blank spaces and so on.
+ * All data in the output buffer is flushed prior to the newline
+ * assertion.
+ */

 void
 vspace(struct termp *p)
 {
 
 void
 vspace(struct termp *p)
 {
 

-       /*
-        * Asserts a vertical space (a full, empty line-break between
-        * lines).
-        */

        newln(p);
        putchar('\n');
 }
 
 
        newln(p);
        putchar('\n');
 }
 
 

-static void
-stringa(struct termp *p, const char *s)
-{
-
-       /* XXX - speed up if not passing to chara. */
-       for ( ; *s; s++)
-               chara(p, *s);
-}
-
-
-static void
-chara(struct termp *p, char c)
-{
-
-       /*
-        * 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;
-}
-
-
-static void
-style(struct termp *p, enum termstyle esc)
-{
-
-       if (p->col + 4 >= p->maxcols)
-               errx(1, "line overrun");
-
-       p->buf[(p->col)++] = 27;
-       p->buf[(p->col)++] = '[';
-       switch (esc) {
-       case (STYLE_CLEAR):
-               p->buf[(p->col)++] = '0';
-               break;
-       case (STYLE_BOLD):
-               p->buf[(p->col)++] = '1';
-               break;
-       case (STYLE_UNDERLINE):
-               p->buf[(p->col)++] = '4';
-               break;
-       default:
-               abort();
-               /* NOTREACHED */
-       }
-       p->buf[(p->col)++] = 'm';
-}
-
-
-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)
-{
-       size_t           j;
-
-       (*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);
-               nescape(p, &word[*i], 2);
-               (*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]) {
-               case ('\\'):
-                       /* FALLTHROUGH */
-               case ('\''):
-                       /* FALLTHROUGH */
-               case ('`'):
-                       /* FALLTHROUGH */
-               case ('-'):
-                       /* FALLTHROUGH */
-               case (' '):
-                       /* FALLTHROUGH */
-               case ('.'):
-                       chara(p, word[*i]);
-                       break;
-               case ('e'):
-                       chara(p, '\\');
-                       break;
-               default:
-                       break;
-               }
-               return;
-       }
-
-       (*i)++;
-       for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)
-               /* Loop... */ ;
-
-       nescape(p, &word[*i - j], j);
-}
-
-
-static void
-pword(struct termp *p, const char *word, size_t len)
-{
-       size_t           i;
-
-       /*
-        * 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_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)
-               style(p, STYLE_UNDERLINE);
-
-       for (i = 0; i < len; i++) {
-               if ('\\' == word[i]) {
-                       pescape(p, word, &i, len);
-                       continue;
-               }
-               chara(p, word[i]);
-       }
-
-       if (p->flags & TERMP_BOLD ||
-                       p->flags & TERMP_UNDERLINE)
-               style(p, STYLE_CLEAR);
-}
-
-
+/*
+ * Break apart a word into "pwords" (partial-words, usually from
+ * breaking up a phrase into individual words) and, eventually, put them
+ * into the output buffer.  If we're a literal word, then don't break up
+ * the word and put it verbatim into the output buffer.
+ */

 void
 word(struct termp *p, const char *word)
 {
        size_t           i, j, len;
 
 void
 word(struct termp *p, const char *word)
 {
        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;


@@ -564,13 +437,14 @@ word(struct termp *p, const char *word)
 
        /* LINTED */
        for (j = i = 0; i < len; i++) {
 
        /* LINTED */
        for (j = i = 0; i < len; i++) {

-               if ( ! xisspace(word[i])) {
+               if ( ! isspace((u_char)word[i])) {

                        j++;
                        continue;
                } 
                
                /* Escaped spaces don't delimit... */
                        j++;
                        continue;
                } 
                
                /* Escaped spaces don't delimit... */

-               if (i > 0 && xisspace(word[i]) && '\\' == word[i - 1]) {
+               if (i > 0 && isspace((u_char)word[i]) && 
+                               '\\' == word[i - 1]) {

                        j++;
                        continue;
                }
                        j++;
                        continue;
                }


@@ -588,6 +462,12 @@ word(struct termp *p, const char *word)
 }
 
 
 }
 
 

+/*
+ * This is the main function for printing out nodes.  It's constituted
+ * of PRE and POST functions, which correspond to prefix and infix
+ * processing.  The termpair structure allows data to persist between
+ * prefix and postfix invocations.
+ */

 static void
 body(struct termp *p, struct termpair *ppair,
                const struct mdoc_meta *meta,
 static void
 body(struct termp *p, struct termpair *ppair,
                const struct mdoc_meta *meta,


@@ -596,12 +476,6 @@ 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;


@@ -775,7 +649,7 @@ header(struct termp *p, const struct mdoc_meta *meta)
                        meta->title, pp ? pp : "");
 
        for (bufp = title; *bufp; bufp++)
                        meta->title, pp ? pp : "");
 
        for (bufp = title; *bufp; bufp++)

-               *bufp = toupper(*bufp);
+               *bufp = toupper((u_char)*bufp);

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


@@ -807,3 +681,199 @@ header(struct termp *p, const struct mdoc_meta *meta)
        free(vbuf);
        free(buf);
 }
        free(vbuf);
        free(buf);
 }

+
+
+/*
+ * Determine the symbol indicated by an escape sequences, that is, one
+ * starting with a backslash.  Once done, we pass this value into the
+ * output buffer by way of the symbol table.
+ */
+static void
+nescape(struct termp *p, const char *word, size_t len)
+{
+       struct termenc  *enc;
+
+       switch (len) {
+       case (1):
+               enc = termenc1;
+               break;
+       case (2):
+               enc = termenc2;
+               break;
+       default:
+               warnx("unsupported %zu-byte escape sequence", len);
+               return;
+       }
+
+       for ( ; enc->enc; enc++) 
+               if (0 == memcmp(enc->enc, word, len)) {
+                       symbola(p, enc->sym);
+                       return;
+               }
+
+       warnx("unsupported %zu-byte escape sequence", len);
+}
+
+
+/*
+ * Handle an escape sequence: determine its length and pass it to the
+ * escape-symbol look table.  Note that we assume mdoc(3) has validated
+ * the escape sequence (we assert upon badly-formed escape sequences).
+ */
+static void
+pescape(struct termp *p, const char *word, size_t *i, size_t len)
+{
+       size_t           j;
+
+       (*i)++;
+       assert(*i < len);
+
+       if ('(' == word[*i]) {
+               (*i)++;
+               assert(*i + 1 < len);
+               nescape(p, &word[*i], 2);
+               (*i)++;
+               return;
+
+       } else if ('*' == word[*i]) { 
+               /* XXX - deprecated! */
+               (*i)++;
+               assert(*i < len);
+               switch (word[*i]) {
+               case ('('):
+                       (*i)++;
+                       assert(*i + 1 < len);
+                       nescape(p, &word[*i], 2);
+                       (*i)++;
+                       return;
+               case ('['):
+                       break;
+               default:
+                       nescape(p, &word[*i], 1);
+                       return;
+               }
+
+       } else if ('[' != word[*i]) {
+               nescape(p, &word[*i], 1);
+               return;
+       }
+
+       (*i)++;
+       for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)
+               /* Loop... */ ;
+
+       assert(word[*i]);
+       nescape(p, &word[*i - j], j);
+}
+
+
+/*
+ * 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.
+ */
+static void
+pword(struct termp *p, const char *word, size_t len)
+{
+       size_t           i;
+
+       if ( ! (TERMP_NOSPACE & p->flags) && 
+                       ! (TERMP_LITERAL & p->flags))
+               chara(p, ' ');
+
+       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)
+               stylea(p, TERMSTYLE_BOLD);
+       if (p->flags & TERMP_UNDERLINE)
+               stylea(p, TERMSTYLE_UNDER);
+
+       for (i = 0; i < len; i++) {
+               if ('\\' == word[i]) {
+                       pescape(p, word, &i, len);
+                       continue;
+               }
+               chara(p, word[i]);
+       }
+
+       if (p->flags & TERMP_BOLD ||
+                       p->flags & TERMP_UNDERLINE)
+               stylea(p, TERMSTYLE_CLEAR);
+}
+
+
+/*
+ * Add a symbol to the output line buffer.
+ */
+static void
+symbola(struct termp *p, enum tsym sym)
+{
+
+       assert(p->symtab[sym].sym);
+       stringa(p, p->symtab[sym].sym, p->symtab[sym].sz);
+}
+
+
+/*
+ * Add a style to the output line buffer.
+ */
+static void
+stylea(struct termp *p, enum tstyle style)
+{
+
+       assert(p->styletab[style].sym);
+       stringa(p, p->styletab[style].sym, p->styletab[style].sz);
+}
+
+
+/*
+ * Like chara() but for arbitrary-length buffers.  Resize the buffer by
+ * a factor of two (if the buffer is less than that) or the buffer's
+ * size.
+ */
+static void
+stringa(struct termp *p, const char *c, size_t sz)
+{
+       size_t           s;
+
+       if (0 == sz)
+               return;
+
+       s = sz > p->maxcols * 2 ? sz : p->maxcols * 2;
+       
+       assert(c);
+       if (p->col + sz >= p->maxcols) {
+               p->buf = realloc(p->buf, s);
+               if (NULL == p->buf)
+                       err(1, "realloc");
+               p->maxcols = s;
+       }
+
+       (void)memcpy(&p->buf[p->col], c, sz);
+       p->col += sz;
+}
+
+
+/*
+ * Insert a single character into the line-buffer.  If the buffer's
+ * space is exceeded, then allocate more space by doubling the buffer
+ * size.
+ */
+static void
+chara(struct termp *p, char c)
+{
+
+       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;
+}