=================================================================== RCS file: /cvs/mandoc/Attic/mdocterm.c,v retrieving revision 1.37 retrieving revision 1.42 diff -u -p -r1.37 -r1.42 --- mandoc/Attic/mdocterm.c 2009/03/09 13:17:49 1.37 +++ mandoc/Attic/mdocterm.c 2009/03/14 12:35:02 1.42 @@ -1,4 +1,4 @@ -/* $Id: mdocterm.c,v 1.37 2009/03/09 13:17:49 kristaps Exp $ */ +/* $Id: mdocterm.c,v 1.42 2009/03/14 12:35:02 kristaps Exp $ */ /* * Copyright (c) 2008 Kristaps Dzonsons * @@ -29,11 +29,12 @@ #include "mmain.h" #include "term.h" -struct termenc { +struct termseq { const char *enc; int sym; }; +static int option(void *, int, const char *); static void body(struct termp *, struct termpair *, const struct mdoc_meta *, @@ -52,14 +53,14 @@ static void chara(struct termp *, char); static void stringa(struct termp *, const char *, size_t); static void symbola(struct termp *, enum tsym); -static void stylea(struct termp *, enum tstyle); +static void sanity(const struct mdoc_node *); #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[] = { +static struct termseq termenc1[] = { { "\\", TERMSYM_SLASH }, { "\'", TERMSYM_RSQUOTE }, { "`", TERMSYM_LSQUOTE }, @@ -69,10 +70,13 @@ static struct termenc termenc1[] = { { "&", TERMSYM_BREAK }, { "e", TERMSYM_SLASH }, { "q", TERMSYM_DQUOTE }, + { "|", TERMSYM_BREAK }, { NULL, 0 } }; -static struct termenc termenc2[] = { +static struct termseq termenc2[] = { + { "rC", TERMSYM_RBRACE }, + { "lC", TERMSYM_LBRACE }, { "rB", TERMSYM_RBRACK }, { "lB", TERMSYM_LBRACK }, { "ra", TERMSYM_RANGLE }, @@ -122,7 +126,7 @@ static struct termenc termenc2[] = { { NULL, 0 } }; -static struct termsym termsym_ansi[] = { +static struct termsym termsym_ascii[TERMSYM_MAX] = { { "]", 1 }, /* TERMSYM_RBRACK */ { "[", 1 }, /* TERMSYM_LBRACK */ { "<-", 2 }, /* TERMSYM_LARROW */ @@ -162,19 +166,11 @@ static struct termsym termsym_ansi[] = { { "", 0 }, /* TERMSYM_BREAK */ { "<", 1 }, /* TERMSYM_LANGLE */ { ">", 1 }, /* TERMSYM_RANGLE */ + { "{", 1 }, /* TERMSYM_LBRACE */ + { "}", 1 }, /* TERMSYM_RBRACE */ }; -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[]) { @@ -183,22 +179,25 @@ main(int argc, char *argv[]) const struct mdoc *mdoc; struct termp termp; + (void)memset(&termp, 0, sizeof(struct termp)); + + termp.maxrmargin = termp.rmargin = 78; /* XXX */ + termp.maxcols = 1024; + termp.offset = termp.col = 0; + termp.flags = TERMP_NOSPACE; + termp.symtab = termsym_ascii; + termp.enc = TERMENC_ANSI; + p = mmain_alloc(); + c = mmain_getopt(p, argc, argv, "[-Ooption...]", + "O:", &termp, option); - c = mmain_getopt(p, argc, argv, NULL, NULL, NULL, NULL); if (1 != c) mmain_exit(p, -1 == c ? 1 : 0); if (NULL == (mdoc = mmain_mdoc(p))) mmain_exit(p, 1); - termp.maxrmargin = termp.rmargin = 78; /* XXX */ - 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"); @@ -213,6 +212,26 @@ main(int argc, char *argv[]) } +int +option(void *ptr, int c, const char *arg) +{ + struct termp *p; + + p = (struct termp *)ptr; + + if (0 == strcmp(arg, "nroff")) { + p->enc = TERMENC_NROFF; + return(1); + } else if (0 == strcmp(arg, "ansi")) { + p->enc = TERMENC_ANSI; + return(1); + } + + warnx("unknown option: -O%s", arg); + return(0); +} + + /* * 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 @@ -282,15 +301,18 @@ 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 (isspace((u_char)p->buf[j])) + if (isspace((u_char)p->buf[j])) { break; - else if (27 == p->buf[j]) { - assert(j + 4 <= p->col); - j += 3; + } else if (27 == p->buf[j]) { + assert(TERMENC_ANSI == p->enc); + assert(j + 5 <= p->col); + j += 4; + } else if (8 == p->buf[j]) { + assert(TERMENC_NROFF == p->enc); + assert(j + 2 <= p->col); + j += 1; } else vsz++; } @@ -425,8 +447,8 @@ word(struct termp *p, const char *word) return; } - len = strlen(word); - assert(len > 0); + if (0 == (len = strlen(word))) + errx(1, "blank line not in literal context"); if (mdoc_isdelim(word)) { if ( ! (p->flags & TERMP_IGNDELIM)) @@ -475,6 +497,10 @@ body(struct termp *p, struct termpair *ppair, int dochild; struct termpair pair; + /* Some quick sanity-checking. */ + + sanity(node); + /* Pre-processing. */ dochild = 1; @@ -646,7 +672,7 @@ header(struct termp *p, const struct mdoc_meta *meta) static void nescape(struct termp *p, const char *word, size_t len) { - struct termenc *enc; + struct termseq *enc; switch (len) { case (1): @@ -753,26 +779,70 @@ pword(struct termp *p, const char *word, size_t len) p->flags &= ~TERMP_NOSPACE; /* - * XXX - if literal and underlining, this will underline the - * spaces between literal words. + * If ANSI (word-length styling), then apply our style now, + * before the word. */ - if (p->flags & TERMP_BOLD) - stylea(p, TERMSTYLE_BOLD); - if (p->flags & TERMP_UNDERLINE) - stylea(p, TERMSTYLE_UNDER); + if (TERMENC_ANSI == p->enc && TERMP_STYLE & p->flags) { + if (TERMP_BOLD & p->flags) { + chara(p, 27); + stringa(p, "[01m", 4); + } + if (TERMP_UNDER & p->flags) { + chara(p, 27); + stringa(p, "[04m", 4); + } + if (TERMP_RED & p->flags) { + chara(p, 27); + stringa(p, "[31m", 4); + } + if (TERMP_GREEN & p->flags) { + chara(p, 27); + stringa(p, "[32m", 4); + } + if (TERMP_YELLOW & p->flags) { + chara(p, 27); + stringa(p, "[33m", 4); + } + if (TERMP_BLUE & p->flags) { + chara(p, 27); + stringa(p, "[34m", 4); + } + if (TERMP_MAGENTA & p->flags) { + chara(p, 27); + stringa(p, "[35m", 4); + } + if (TERMP_CYAN & p->flags) { + chara(p, 27); + stringa(p, "[36m", 4); + } + } for (i = 0; i < len; i++) { if ('\\' == word[i]) { pescape(p, word, &i, len); continue; } + + if (TERMENC_NROFF == p->enc && + TERMP_STYLE & p->flags) { + if (TERMP_BOLD & p->flags) { + chara(p, word[i]); + chara(p, 8); + } + if (TERMP_UNDER & p->flags) { + chara(p, '_'); + chara(p, 8); + } + } + chara(p, word[i]); } - if (p->flags & TERMP_BOLD || - p->flags & TERMP_UNDERLINE) - stylea(p, TERMSTYLE_CLEAR); + if (TERMENC_ANSI == p->enc && TERMP_STYLE & p->flags) { + chara(p, 27); + stringa(p, "[00m", 4); + } } @@ -789,18 +859,6 @@ symbola(struct termp *p, enum tsym sym) /* - * 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. @@ -845,3 +903,114 @@ chara(struct termp *p, char c) } p->buf[(p->col)++] = c; } + + +static void +sanity(const struct mdoc_node *n) +{ + + switch (n->type) { + case (MDOC_TEXT): + if (n->child) + errx(1, "regular form violated (1)"); + if (NULL == n->parent) + errx(1, "regular form violated (2)"); + if (NULL == n->string) + errx(1, "regular form violated (3)"); + switch (n->parent->type) { + case (MDOC_TEXT): + /* FALLTHROUGH */ + case (MDOC_ROOT): + errx(1, "regular form violated (4)"); + /* NOTREACHED */ + default: + break; + } + break; + case (MDOC_ELEM): + if (NULL == n->parent) + errx(1, "regular form violated (5)"); + switch (n->parent->type) { + case (MDOC_TAIL): + /* FALLTHROUGH */ + case (MDOC_BODY): + /* FALLTHROUGH */ + case (MDOC_HEAD): + break; + default: + errx(1, "regular form violated (6)"); + /* NOTREACHED */ + } + if (n->child) switch (n->child->type) { + case (MDOC_TEXT): + break; + default: + errx(1, "regular form violated (7("); + /* NOTREACHED */ + } + break; + case (MDOC_HEAD): + /* FALLTHROUGH */ + case (MDOC_BODY): + /* FALLTHROUGH */ + case (MDOC_TAIL): + if (NULL == n->parent) + errx(1, "regular form violated (8)"); + if (MDOC_BLOCK != n->parent->type) + errx(1, "regular form violated (9)"); + if (n->child) switch (n->child->type) { + case (MDOC_BLOCK): + /* FALLTHROUGH */ + case (MDOC_ELEM): + /* FALLTHROUGH */ + case (MDOC_TEXT): + break; + default: + errx(1, "regular form violated (a)"); + /* NOTREACHED */ + } + break; + case (MDOC_BLOCK): + if (NULL == n->parent) + errx(1, "regular form violated (b)"); + if (NULL == n->child) + errx(1, "regular form violated (c)"); + switch (n->parent->type) { + case (MDOC_ROOT): + /* FALLTHROUGH */ + case (MDOC_HEAD): + /* FALLTHROUGH */ + case (MDOC_BODY): + /* FALLTHROUGH */ + case (MDOC_TAIL): + break; + default: + errx(1, "regular form violated (d)"); + /* NOTREACHED */ + } + switch (n->child->type) { + case (MDOC_ROOT): + /* FALLTHROUGH */ + case (MDOC_ELEM): + errx(1, "regular form violated (e)"); + /* NOTREACHED */ + default: + break; + } + break; + case (MDOC_ROOT): + if (n->parent) + errx(1, "regular form violated (f)"); + if (NULL == n->child) + errx(1, "regular form violated (10)"); + switch (n->child->type) { + case (MDOC_BLOCK): + break; + default: + errx(1, "regular form violated (11)"); + /* NOTREACHED */ + } + break; + } +} +