]> git.cameronkatri.com Git - mandoc.git/commitdiff
Added new old escape sequence \*[nn].
authorKristaps Dzonsons <kristaps@bsd.lv>
Mon, 2 Mar 2009 17:14:46 +0000 (17:14 +0000)
committerKristaps Dzonsons <kristaps@bsd.lv>
Mon, 2 Mar 2009 17:14:46 +0000 (17:14 +0000)
Initial correct .Bd support (still only text in literal displays).
Symbols put into tables (character-encoding).

Makefile
mdoc.c
mdocterm.c
regress/test.escape.13 [new file with mode: 0644]
regress/test.escape.14 [new file with mode: 0644]
strings.c
term.c
term.h
validate.c

index c7792be2b16a28c40172f33e5d72fa6b9fedf6e2..7f6b29bdc1051ac8976da1a3d4bc407756342459 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -100,7 +100,8 @@ FAIL        = regress/test.empty \
          regress/test.escape.08 \
          regress/test.escape.09 \
          regress/test.escape.11 \
-         regress/test.escape.12
+         regress/test.escape.12 \
+         regress/test.escape.14
 
 SUCCEED        = regress/test.prologue.05 \
          regress/test.prologue.07 \
@@ -129,7 +130,8 @@ SUCCEED     = regress/test.prologue.05 \
          regress/test.sh.02 \
          regress/test.escape.00 \
          regress/test.escape.05 \
-         regress/test.escape.10
+         regress/test.escape.10 \
+         regress/test.escape.13
 
 REGRESS        = $(FAIL) $(SUCCEED)
 
diff --git a/mdoc.c b/mdoc.c
index af8a7fcce8802cbf3d24cc12ff02881db4c0b06d..ca3f5752a648092b916352875150daa8c2043bc9 100644 (file)
--- a/mdoc.c
+++ b/mdoc.c
@@ -1,4 +1,4 @@
-/* $Id: mdoc.c,v 1.49 2009/03/01 23:14:15 kristaps Exp $ */
+/* $Id: mdoc.c,v 1.50 2009/03/02 17:14:46 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -180,6 +180,12 @@ mdoc_endparse(struct mdoc *mdoc)
 }
 
 
+/*
+ * Main line-parsing routine.  If the line is a macro-line (started with
+ * a '.' control character), then pass along to the parser, which parses
+ * subsequent macros until the end of line.  If normal text, simply
+ * append the entire line to the chain.
+ */
 int
 mdoc_parseln(struct mdoc *mdoc, int line, char *buf)
 {
@@ -191,20 +197,24 @@ mdoc_parseln(struct mdoc *mdoc, int line, char *buf)
 
        mdoc->linetok = 0;
 
-       /*
-        * FIXME: should puke on whitespace in non-literal displays.
-        */
-
        if ('.' != *buf) {
+               /*
+                * Free-form text.  Not allowed in the prologue.
+                */
                if (SEC_PROLOGUE == mdoc->lastnamed)
                        return(mdoc_perr(mdoc, line, 0, 
-                               "no text in document prologue"));
+                                       "no text in prologue"));
+
                if ( ! mdoc_word_alloc(mdoc, line, 0, buf))
                        return(0);
                mdoc->next = MDOC_NEXT_SIBLING;
                return(1);
        }
 
+       /*
+        * Control-character detected.  Begin the parsing sequence.
+        */
+
        if (buf[1] && '\\' == buf[1])
                if (buf[2] && '\"' == buf[2])
                        return(1);
@@ -238,6 +248,7 @@ mdoc_parseln(struct mdoc *mdoc, int line, char *buf)
                mdoc->flags |= MDOC_HALT;
                return(0);
        }
+
        return(1);
 }
 
index 7a0e1230af49bd0223eb1b85e09061e9f712bb5e..0e36fb308d6fff12cdc44f656ba10bec31cc719d 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mdocterm.c,v 1.24 2009/03/02 12:09:32 kristaps Exp $ */
+/* $Id: mdocterm.c,v 1.25 2009/03/02 17:14:46 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -25,7 +25,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
 #ifndef __OpenBSD__
 #include <time.h>
 #endif
 #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
-};
-
 static void              body(struct termp *,
                                struct termpair *,
                                const struct mdoc_meta *,
@@ -83,20 +42,63 @@ static      void              footer(struct termp *,
                                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              pgraph(struct termp *, char);
-static void              nescape(struct termp *, 
+static void              pescape(struct termp *, const char *, 
+                               size_t *, size_t);
+static void              style(struct termp *, enum tstyle);
+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              stringa(struct termp *, 
+                               const char *, size_t);
+static void              symbola(struct termp *, enum tsym);
 
 #ifdef __linux__
 extern size_t            strlcat(char *, const char *, size_t);
 extern size_t            strlcpy(char *, const char *, size_t);
 #endif
 
+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_AND */
+       { "|", 1 },             /* TERMSYM_OR */
+};
+
+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[])
@@ -118,6 +120,8 @@ main(int argc, char *argv[])
        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");
@@ -133,10 +137,45 @@ 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_LITERAL: don't break apart words.  Note that a long literal
+ *    word will violate the right margin.
+ *
+ *  - 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)
 {
-       size_t           i, j, vsz, vis, maxvis;
+       size_t           i, j, vsz, vis, maxvis, mmax, bp;
 
        /*
         * First, establish the maximum columns of "visible" content.
@@ -147,6 +186,8 @@ flushln(struct termp *p)
 
        assert(p->offset < p->rmargin);
        maxvis = p->rmargin - p->offset;
+       mmax = p->maxrmargin - p->offset;
+       bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
        vis = 0;
 
        /*
@@ -160,17 +201,6 @@ flushln(struct termp *p)
                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
@@ -179,9 +209,11 @@ flushln(struct termp *p)
                 * space is printed according to regular spacing rules).
                 */
 
+               /* FIXME: make non-ANSI friendly. */
+
                /* LINTED */
                for (j = i, vsz = 0; j < p->col; j++) {
-                       if (xisspace(p->buf[j]))
+                       if (isspace((int)p->buf[j]))
                                break;
                        else if (27 == p->buf[j]) {
                                assert(j + 4 <= p->col);
@@ -191,51 +223,59 @@ 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 right
-                * 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 (vis && vis + vsz > maxvis) {
+                       if (vis && vis + vsz > bp) {
                                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 - p->offset) {
-                       putchar('\n');
-                       for (j = 0; j < p->rmargin; j++)
-                               putchar(' ');
-                       vis = p->rmargin;
+                       } 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;
+                       } else if (vis + vsz > bp) 
+                               warnx("word breaks right margin");
+
+                       /* TODO: hyphenate. */
                }
 
                /* 
                 * 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++) {
-                       if (xisspace(p->buf[i]))
+                       if (isspace((int)p->buf[i]))
                                break;
                        putchar(p->buf[i]);
                }
                vis += vsz;
-               if (i < p->col) {
+               if (i < p->col && vis <= bp) {
                        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) {
                putchar('\n');
                for (i = 0; i < p->rmargin; i++)
@@ -259,14 +299,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)
 {
 
-       /* 
-        * 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;
@@ -277,307 +318,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)
 {
 
-       /*
-        * Asserts a vertical space (a full, empty line-break between
-        * lines).
-        */
        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
-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:
-               warnx("unknown non-graphing character");
-               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;
-               }
-               if ( ! isgraph((int)word[i])) {
-                       pgraph(p, word[i]);
-                       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;
 
-       /*
-        * 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;
@@ -594,13 +360,14 @@ word(struct termp *p, const char *word)
 
        /* LINTED */
        for (j = i = 0; i < len; i++) {
-               if ( ! xisspace(word[i])) {
+               if ( ! isspace((int)word[i])) {
                        j++;
                        continue;
                } 
                
                /* Escaped spaces don't delimit... */
-               if (i > 0 && xisspace(word[i]) && '\\' == word[i - 1]) {
+               if (i > 0 && isspace((int)word[i]) && 
+                               '\\' == word[i - 1]) {
                        j++;
                        continue;
                }
@@ -618,6 +385,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,
@@ -626,12 +399,6 @@ body(struct termp *p, struct termpair *ppair,
        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;
@@ -837,3 +604,306 @@ header(struct termp *p, const struct mdoc_meta *meta)
        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)
+{
+
+       switch (len) {
+       case (1):
+               switch (word[0]) {
+               case ('\\'):
+                       /* FALLTHROUGH */
+               case ('\''):
+                       /* FALLTHROUGH */
+               case ('`'):
+                       /* FALLTHROUGH */
+               case ('-'):
+                       /* FALLTHROUGH */
+               case (' '):
+                       /* FALLTHROUGH */
+               case ('.'):
+                       chara(p, word[0]); /* FIXME */
+                       break;
+               case ('&'):
+                       break;
+               case ('e'):
+                       chara(p, '\\'); /* FIXME */
+                       break;
+               case ('q'):
+                       symbola(p, TERMSYM_DQUOTE);
+                       break;
+               default:
+                       warnx("escape sequence not supported: %c",
+                                       word[0]);
+                       break;
+               }
+               break;
+
+       case (2):
+               if ('r' == word[0] && 'B' == word[1])
+                       symbola(p, TERMSYM_RBRACK);
+               else if ('l' == word[0] && 'B' == word[1])
+                       symbola(p, TERMSYM_LBRACK);
+               else if ('l' == word[0] && 'q' == word[1])
+                       symbola(p, TERMSYM_LDQUOTE);
+               else if ('r' == word[0] && 'q' == word[1])
+                       symbola(p, TERMSYM_RDQUOTE);
+               else if ('o' == word[0] && 'q' == word[1])
+                       symbola(p, TERMSYM_LSQUOTE);
+               else if ('a' == word[0] && 'q' == word[1])
+                       symbola(p, TERMSYM_RSQUOTE);
+               else if ('<' == word[0] && '-' == word[1])
+                       symbola(p, TERMSYM_LARROW);
+               else if ('-' == word[0] && '>' == word[1])
+                       symbola(p, TERMSYM_RARROW);
+               else if ('b' == word[0] && 'u' == word[1])
+                       symbola(p, TERMSYM_BULLET);
+               else if ('<' == word[0] && '=' == word[1])
+                       symbola(p, TERMSYM_LE);
+               else if ('>' == word[0] && '=' == word[1])
+                       symbola(p, TERMSYM_GE);
+               else if ('=' == word[0] && '=' == word[1])
+                       symbola(p, TERMSYM_EQ);
+               else if ('+' == word[0] && '-' == word[1])
+                       symbola(p, TERMSYM_PLUSMINUS);
+               else if ('u' == word[0] && 'a' == word[1])
+                       symbola(p, TERMSYM_UARROW);
+               else if ('d' == word[0] && 'a' == word[1])
+                       symbola(p, TERMSYM_DARROW);
+               else if ('a' == word[0] && 'a' == word[1])
+                       symbola(p, TERMSYM_ACUTE);
+               else if ('g' == word[0] && 'a' == word[1])
+                       symbola(p, TERMSYM_GRAVE);
+               else if ('!' == word[0] && '=' == word[1])
+                       symbola(p, TERMSYM_NEQ);
+               else if ('i' == word[0] && 'f' == word[1])
+                       symbola(p, TERMSYM_INF);
+               else if ('n' == word[0] && 'a' == word[1])
+                       symbola(p, TERMSYM_NAN);
+               else if ('b' == word[0] && 'a' == word[1])
+                       symbola(p, TERMSYM_BAR);
+
+               /* Deprecated forms. */
+               else if ('A' == word[0] && 'm' == word[1])
+                       symbola(p, TERMSYM_AMP);
+               else if ('B' == word[0] && 'a' == word[1])
+                       symbola(p, TERMSYM_BAR);
+               else if ('I' == word[0] && 'f' == word[1])
+                       symbola(p, TERMSYM_INF2);
+               else if ('G' == word[0] && 'e' == word[1])
+                       symbola(p, TERMSYM_GE);
+               else if ('G' == word[0] && 't' == word[1])
+                       symbola(p, TERMSYM_GT);
+               else if ('L' == word[0] && 'e' == word[1])
+                       symbola(p, TERMSYM_LE);
+               else if ('L' == word[0] && 'q' == word[1])
+                       symbola(p, TERMSYM_LDQUOTE);
+               else if ('L' == word[0] && 't' == word[1])
+                       symbola(p, TERMSYM_LT);
+               else if ('N' == word[0] && 'a' == word[1])
+                       symbola(p, TERMSYM_NAN);
+               else if ('N' == word[0] && 'e' == word[1])
+                       symbola(p, TERMSYM_NEQ);
+               else if ('P' == word[0] && 'i' == word[1])
+                       symbola(p, TERMSYM_PI);
+               else if ('P' == word[0] && 'm' == word[1])
+                       symbola(p, TERMSYM_PLUSMINUS);
+               else if ('R' == word[0] && 'q' == word[1])
+                       symbola(p, TERMSYM_RDQUOTE);
+               else
+                       warnx("escape sequence not supported: %c%c",
+                                       word[0], word[1]);
+               break;
+
+       default:
+               warnx("escape sequence not supported");
+               break;
+       }
+}
+
+
+/*
+ * Apply a style to the output buffer.  This is looked up by means of
+ * the styletab.
+ */
+static void
+style(struct termp *p, enum tstyle esc)
+{
+
+       if (p->col + 4 >= p->maxcols)
+               errx(1, "line overrun");
+
+       p->buf[(p->col)++] = 27;
+       p->buf[(p->col)++] = '[';
+       switch (esc) {
+       case (TERMSTYLE_CLEAR):
+               p->buf[(p->col)++] = '0';
+               break;
+       case (TERMSTYLE_BOLD):
+               p->buf[(p->col)++] = '1';
+               break;
+       case (TERMSTYLE_UNDER):
+               p->buf[(p->col)++] = '4';
+               break;
+       default:
+               abort();
+               /* NOTREACHED */
+       }
+       p->buf[(p->col)++] = 'm';
+}
+
+
+/*
+ * 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)
+               style(p, TERMSTYLE_BOLD);
+       if (p->flags & TERMP_UNDERLINE)
+               style(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)
+               style(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);
+}
+
+
+/*
+ * 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;
+
+       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;
+}
diff --git a/regress/test.escape.13 b/regress/test.escape.13
new file mode 100644 (file)
index 0000000..7cd6a09
--- /dev/null
@@ -0,0 +1,24 @@
+.\" 
+.Dd $Mdocdate: March 2 2009 $
+.Dt mdoc 3
+.Os
+.\"
+.Sh NAME
+.Nm mdoc_free
+.Nd mdoc macro compiler library
+.\"
+.Sh SYNOPSIS
+Valid escape: \(ab 
+Valid escape: \[d]
+Valid escape: \[dsdfajsdflaksjfhalksjdfh__----]
+Valid escape: \\
+Valid escape: \e
+Valid escape: \`
+Valid escape: \'
+Valid escape: \.
+Valid escape: \-
+Valid escape: \ 
+Valid escape: \*a
+Valid escape: \(*ab
+Valid escape: \*[d]
+Valid escape: \*[asdfasdasdfasldkjfhasldjkfhaslkjhfasljfhd]
diff --git a/regress/test.escape.14 b/regress/test.escape.14
new file mode 100644 (file)
index 0000000..5307872
--- /dev/null
@@ -0,0 +1,25 @@
+.\" 
+.Dd $Mdocdate: March 2 2009 $
+.Dt mdoc 3
+.Os
+.\"
+.Sh NAME
+.Nm mdoc_free
+.Nd mdoc macro compiler library
+.\"
+.Sh SYNOPSIS
+Valid escape: \(ab 
+Valid escape: \[d]
+Valid escape: \[dsdfajsdflaksjfhalksjdfh__----]
+Valid escape: \\
+Valid escape: \e
+Valid escape: \`
+Valid escape: \'
+Valid escape: \.
+Valid escape: \-
+Valid escape: \ 
+Valid escape: \*a
+Valid escape: \(*ab
+Valid escape: \*[d]
+Valid escape: \*[asdfasdasdfasldkjfhasldjkfhaslkjhfasljfhd]
+Invalid escape: \*[
index 4910e308c7f077e3d720a333a444e835a3a3595d..6d07edeae2ff71b65fa0312c592b866ef836b83a 100644 (file)
--- a/strings.c
+++ b/strings.c
@@ -1,4 +1,4 @@
-/* $Id: strings.c,v 1.23 2009/03/02 12:09:32 kristaps Exp $ */
+/* $Id: strings.c,v 1.24 2009/03/02 17:14:46 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -69,6 +69,11 @@ mdoc_isescape(const char *p)
                        if (0 == *++p || ! isgraph((int)*p))
                                return(0);
                        return(4);
+               case ('['):
+                       for (c = 3, p++; *p && ']' != *p; p++, c++)
+                               if ( ! isgraph((int)*p))
+                                       break;
+                       return(*p == ']' ? c : 0);
                default:
                        break;
                }
diff --git a/term.c b/term.c
index e1fa44da23f3308da1146805af1fab906b44ec40..8096238733bd82b7f638e9fa777f52cfb56ca76f 100644 (file)
--- a/term.c
+++ b/term.c
@@ -1,4 +1,4 @@
-/* $Id: term.c,v 1.34 2009/03/02 12:09:32 kristaps Exp $ */
+/* $Id: term.c,v 1.35 2009/03/02 17:14:46 kristaps Exp $ */
 /*
  * Copyright (c) 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -1051,8 +1051,8 @@ static int
 termp_bd_pre(DECL_ARGS)
 {
        const struct mdoc_block *bl;
-       const struct mdoc_node *n;
-       int              i;
+       const struct mdoc_node  *n;
+       int              i, type;
 
        if (MDOC_BLOCK == node->type) {
                if (node->prev)
@@ -1061,31 +1061,55 @@ termp_bd_pre(DECL_ARGS)
        } else if (MDOC_BODY != node->type)
                return(1);
 
-       assert(MDOC_BLOCK == node->parent->type);
        pair->offset = p->offset;
-
        bl = &node->parent->data.block;
 
+       for (type = -1, i = 0; i < (int)bl->argc; i++) {
+               switch (bl->argv[i].arg) {
+               case (MDOC_Ragged):
+                       /* FALLTHROUGH */
+               case (MDOC_Filled):
+                       /* FALLTHROUGH */
+               case (MDOC_Unfilled):
+                       /* FALLTHROUGH */
+               case (MDOC_Literal):
+                       type = bl->argv[i].arg;
+                       i = (int)bl->argc;
+                       break;
+               default:
+                       errx(1, "display type not supported");
+               }
+       }
+
+       assert(-1 != type);
+
        i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
        if (-1 != i) {
                assert(1 == bl->argv[i].sz);
                p->offset += arg_offset(&bl->argv[i]);
        }
 
+
+       switch (type) {
+       case (MDOC_Literal):
+               /* FALLTHROUGH */
+       case (MDOC_Unfilled):
+               break;
+       default:
+               return(1);
+       }
+
        p->flags |= TERMP_LITERAL;
 
        for (n = node->child; n; n = n->next) {
-               if (MDOC_TEXT != n->type) 
-                       errx(1, "non-text displays unsupported");
-               if ((*n->data.text.string)) {
-                       word(p, n->data.text.string);
-                       flushln(p);
-               } else
-                       vspace(p);
-
+               if (MDOC_TEXT != n->type) {
+                       warnx("non-text children not yet allowed");
+                       continue;
+               }
+               word(p, n->data.text.string);
+               flushln(p);
        }
 
-       p->flags &= ~TERMP_LITERAL;
        return(0);
 }
 
@@ -1097,7 +1121,11 @@ termp_bd_post(DECL_ARGS)
 
        if (MDOC_BODY != node->type) 
                return;
-       newln(p);
+
+       if ( ! (p->flags & TERMP_LITERAL))
+               flushln(p);
+
+       p->flags &= ~TERMP_LITERAL;
        p->offset = pair->offset;
 }
 
diff --git a/term.h b/term.h
index 48162221aafeb61349fbcdc77735b4d2ac54e3dc..df7dd545595993b7d414774271419472430c3ea4 100644 (file)
--- a/term.h
+++ b/term.h
@@ -1,4 +1,4 @@
-/* $Id: term.h,v 1.13 2009/03/02 12:09:32 kristaps Exp $ */
+/* $Id: term.h,v 1.14 2009/03/02 17:14:46 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
 
 __BEGIN_DECLS
 
+enum   tsym {
+       TERMSYM_RBRACK =        0,
+       TERMSYM_LBRACK =        1,
+       TERMSYM_LARROW =        2,
+       TERMSYM_RARROW =        3,
+       TERMSYM_UARROW =        4,
+       TERMSYM_DARROW =        5,
+       TERMSYM_LSQUOTE =       6,
+       TERMSYM_RSQUOTE =       7,
+       TERMSYM_SQUOTE =        8,
+       TERMSYM_LDQUOTE =       9,
+       TERMSYM_RDQUOTE =       10,
+       TERMSYM_DQUOTE =        11,
+       TERMSYM_LT =            12,
+       TERMSYM_GT =            13,
+       TERMSYM_LE =            14,
+       TERMSYM_GE =            15,
+       TERMSYM_EQ =            16,
+       TERMSYM_NEQ =           17,
+       TERMSYM_ACUTE =         18,
+       TERMSYM_GRAVE =         19,
+       TERMSYM_PI =            20,
+       TERMSYM_PLUSMINUS =     21,
+       TERMSYM_INF =           22,
+       TERMSYM_INF2 =          23,
+       TERMSYM_NAN =           24,
+       TERMSYM_BAR =           25,
+       TERMSYM_BULLET =        26,
+       TERMSYM_AMP =           27,
+};
+
+
+enum   tstyle {
+       TERMSTYLE_CLEAR =       0,
+       TERMSTYLE_BOLD =        1,
+       TERMSTYLE_UNDER =       2,
+       TERMSTYLE_MAX =         3
+};
+
+struct termsym {
+       const char       *sym;
+       size_t            sz;
+};
+
 struct termp {
        size_t            rmargin;
        size_t            maxrmargin;
@@ -41,6 +85,8 @@ struct        termp {
 #define        TERMP_IGNDELIM   (1 << 6)       /* Delims like regulars. */
 #define        TERMP_NONOSPACE  (1 << 7)       /* No space (no autounset). */
        char             *buf;
+       struct termsym   *symtab;       /* Special-symbol table. */
+       struct termsym   *styletab;     /* Style table. */
 };
 
 struct termpair {
@@ -78,11 +124,11 @@ void                         word(struct termp *, const char *);
 void                     flushln(struct termp *);
 void                     transcode(struct termp *, 
                                const char *, size_t);
-
 void                     subtree(struct termp *,
                                const struct mdoc_meta *,
                                const struct mdoc_node *);
 
+
 const  struct termact   *termacts;
 
 __END_DECLS
index 0189cee304f804a7c2a845f03a4d3bf7961740c4..ebd95aee751b02ff149a6592f0d5f0784b99d328 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: validate.c,v 1.65 2009/02/28 14:40:07 kristaps Exp $ */
+/* $Id: validate.c,v 1.66 2009/03/02 17:14:46 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -484,7 +484,7 @@ check_text(struct mdoc *mdoc, int line, int pos, const char *p)
        for ( ; *p; p++) {
                if ( ! isprint((int)*p) && '\t' != *p)
                        return(mdoc_perr(mdoc, line, pos,
-                                       "invalid characters"));
+                               "invalid non-printing characters"));
                if ('\\' != *p)
                        continue;
                if ((c = mdoc_isescape(p))) {