diff options
| -rw-r--r-- | Makefile | 6 | ||||
| -rw-r--r-- | mdoc.c | 21 | ||||
| -rw-r--r-- | mdocterm.c | 832 | ||||
| -rw-r--r-- | regress/test.escape.13 | 24 | ||||
| -rw-r--r-- | regress/test.escape.14 | 25 | ||||
| -rw-r--r-- | strings.c | 5 | ||||
| -rw-r--r-- | term.c | 56 | ||||
| -rw-r--r-- | term.h | 48 | ||||
| -rw-r--r-- | validate.c | 2 |
9 files changed, 615 insertions, 404 deletions
@@ -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) @@ -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); } @@ -25,7 +25,6 @@ #include <stdio.h> #include <stdlib.h> #include <string.h> - #ifndef __OpenBSD__ #include <time.h> #endif @@ -33,46 +32,6 @@ #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 index 00000000..c3cf3c3b --- /dev/null +++ b/regress/test.escape.13 @@ -0,0 +1,24 @@ +.\" +.Dd $Mdocdate$ +.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 index 00000000..4bddad72 --- /dev/null +++ b/regress/test.escape.14 @@ -0,0 +1,25 @@ +.\" +.Dd $Mdocdate$ +.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: \*[ @@ -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; } @@ -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; } @@ -25,6 +25,50 @@ __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 @@ -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))) { |