=================================================================== RCS file: /cvs/mandoc/Attic/mdocterm.c,v retrieving revision 1.30 retrieving revision 1.48 diff -u -p -r1.30 -r1.48 --- mandoc/Attic/mdocterm.c 2009/03/04 14:04:02 1.30 +++ mandoc/Attic/mdocterm.c 2009/03/17 13:35:46 1.48 @@ -1,6 +1,6 @@ -/* $Id: mdocterm.c,v 1.30 2009/03/04 14:04:02 kristaps Exp $ */ +/* $Id: mdocterm.c,v 1.48 2009/03/17 13:35:46 kristaps Exp $ */ /* - * Copyright (c) 2008 Kristaps Dzonsons + * Copyright (c) 2008, 2009 Kristaps Dzonsons * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the @@ -16,7 +16,7 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -#include +#include #include #include @@ -25,18 +25,25 @@ #include #include #include -#ifndef __OpenBSD__ -#include -#endif +#include #include "mmain.h" #include "term.h" -struct termenc { - const char *enc; - int sym; +struct nroffopt { + int fl_h; + int fl_i; + char *arg_m; + char *arg_n; + char *arg_o; + char *arg_r; + char *arg_T; + struct termp *termp; /* Ephemeral. */ }; +__dead void punt(struct nroffopt *, char *); +static int option(void *, int, char *); +static int optsopt(struct termp *, char *); static void body(struct termp *, struct termpair *, const struct mdoc_meta *, @@ -54,148 +61,50 @@ static void nescape(struct termp *, 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[] = { - { "\\", 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 }, - { "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 */ -}; - -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[]) { - struct mmain *p; + struct mmain *p; const struct mdoc *mdoc; - struct termp termp; + struct nroffopt nroff; + struct termp termp; + int c; + char *in; + (void)memset(&termp, 0, sizeof(struct termp)); + (void)memset(&nroff, 0, sizeof(struct nroffopt)); + + termp.maxrmargin = termp.rmargin = 78; /* FIXME */ + termp.maxcols = 1024; /* FIXME */ + termp.flags = TERMP_NOSPACE; + termp.symtab = ascii2htab(); + + nroff.termp = &termp; + p = mmain_alloc(); - if ( ! mmain_getopt(p, argc, argv, NULL, NULL, NULL, NULL)) - mmain_exit(p, 1); + c = mmain_getopt(p, argc, argv, "[-Ooption...]", + "[infile]", "him:n:o:r:T:O:", &nroff, option); - if (NULL == (mdoc = mmain_mdoc(p))) - mmain_exit(p, 1); + /* FIXME: this needs to accept multiple outputs. */ + argv += c; + if ((argc -= c) > 0) + in = *argv++; + else + in = "-"; - 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; + mmain_prepare(p, in); + if (NULL == (mdoc = mmain_process(p))) { + if (TERMP_NOPUNT & termp.iflags) + mmain_exit(p, 1); + mmain_free(p); + punt(&nroff, in); + /* NOTREACHED */ + } + if (NULL == (termp.buf = malloc(termp.maxcols))) err(1, "malloc"); @@ -204,12 +113,74 @@ main(int argc, char *argv[]) footer(&termp, mdoc_meta(mdoc)); free(termp.buf); + asciifree(termp.symtab); mmain_exit(p, 0); /* NOTREACHED */ } +static int +optsopt(struct termp *p, char *arg) +{ + char *v; + char *toks[] = { "nopunt", NULL }; + + while (*arg) + switch (getsubopt(&arg, toks, &v)) { + case (0): + p->iflags |= TERMP_NOPUNT; + break; + default: + warnx("unknown -O argument"); + return(0); + } + + return(1); +} + + +static int +option(void *ptr, int c, char *arg) +{ + struct termp *termp; + struct nroffopt *nroff; + + nroff = (struct nroffopt *)ptr; + termp = nroff->termp; + + switch (c) { + case ('h'): + nroff->fl_h = 1; + break; + case ('i'): + nroff->fl_i = 1; + break; + case ('m'): + nroff->arg_m = arg; + break; + case ('n'): + nroff->arg_n = arg; + break; + case ('o'): + nroff->arg_o = arg; + break; + case ('r'): + nroff->arg_r = arg; + break; + case ('T'): + nroff->arg_T = arg; + break; + case ('O'): + return(optsopt(termp, arg)); + default: + break; + } + + return(1); +} + + /* * 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 @@ -279,16 +250,13 @@ 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((int)p->buf[j])) + if (' ' == p->buf[j]) break; - else if (27 == p->buf[j]) { - assert(j + 4 <= p->col); - j += 3; - } else + else if (8 == p->buf[j]) + j += 1; + else vsz++; } @@ -330,7 +298,7 @@ flushln(struct termp *p) */ for ( ; i < p->col; i++) { - if (isspace((int)p->buf[i])) + if (' ' == p->buf[i]) break; putchar(p->buf[i]); } @@ -347,9 +315,11 @@ flushln(struct termp *p) */ 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; } @@ -359,10 +329,11 @@ flushln(struct termp *p) * pad to the right margin and stay off. */ - if (p->flags & TERMP_NOBREAK) - for ( ; vis < maxvis; vis++) - putchar(' '); - else + if (p->flags & TERMP_NOBREAK) { + if ( ! (TERMP_NONOBREAK & p->flags)) + for ( ; vis < maxvis; vis++) + putchar(' '); + } else putchar('\n'); p->col = 0; @@ -419,8 +390,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)) @@ -430,14 +401,13 @@ word(struct termp *p, const char *word) /* LINTED */ for (j = i = 0; i < len; i++) { - if ( ! isspace((int)word[i])) { + if (' ' != word[i]) { j++; continue; } /* Escaped spaces don't delimit... */ - if (i > 0 && isspace((int)word[i]) && - '\\' == word[i - 1]) { + if (i && ' ' == word[i] && '\\' == word[i - 1]) { j++; continue; } @@ -469,6 +439,10 @@ body(struct termp *p, struct termpair *ppair, int dochild; struct termpair pair; + /* Some quick sanity-checking. */ + + sanity(node); + /* Pre-processing. */ dochild = 1; @@ -483,7 +457,7 @@ body(struct termp *p, struct termpair *ppair, if ( ! (*termacts[node->tok].pre)(p, &pair, meta, node)) dochild = 0; } else /* MDOC_TEXT == node->type */ - word(p, node->data.text.string); + word(p, node->string); /* Children. */ @@ -563,9 +537,7 @@ footer(struct termp *p, const struct mdoc_meta *meta) static void header(struct termp *p, const struct mdoc_meta *meta) { - char *buf, *title, *bufp, *vbuf; - const char *pp; - struct utsname uts; + char *buf, *title, *bufp; p->rmargin = p->maxrmargin; p->offset = 0; @@ -574,49 +546,7 @@ header(struct termp *p, const struct mdoc_meta *meta) err(1, "malloc"); if (NULL == (title = malloc(p->rmargin))) err(1, "malloc"); - if (NULL == (vbuf = malloc(p->rmargin))) - err(1, "malloc"); - if (NULL == (pp = mdoc_vol2a(meta->vol))) { - switch (meta->msec) { - case (MSEC_1): - /* FALLTHROUGH */ - case (MSEC_6): - /* FALLTHROUGH */ - case (MSEC_7): - pp = mdoc_vol2a(VOL_URM); - break; - case (MSEC_8): - pp = mdoc_vol2a(VOL_SMM); - break; - case (MSEC_2): - /* FALLTHROUGH */ - case (MSEC_3): - /* FALLTHROUGH */ - case (MSEC_4): - /* FALLTHROUGH */ - case (MSEC_5): - pp = mdoc_vol2a(VOL_PRM); - break; - case (MSEC_9): - pp = mdoc_vol2a(VOL_KM); - break; - default: - break; - } - } - vbuf[0] = 0; - - if (pp) { - if (-1 == uname(&uts)) - err(1, "uname"); - (void)strlcat(vbuf, uts.sysname, p->rmargin); - (void)strlcat(vbuf, " ", p->rmargin); - } else if (NULL == (pp = mdoc_msec2a(meta->msec))) - pp = mdoc_msec2a(MSEC_local); - - (void)strlcat(vbuf, pp, p->rmargin); - /* * The header is strange. It has three components, which are * really two with the first duplicated. It goes like this: @@ -630,19 +560,20 @@ header(struct termp *p, const struct mdoc_meta *meta) * switches on the manual section. */ - if (mdoc_arch2a(meta->arch)) - (void)snprintf(buf, p->rmargin, "%s (%s)", - vbuf, mdoc_arch2a(meta->arch)); - else - (void)strlcpy(buf, vbuf, p->rmargin); + assert(meta->vol); + (void)strlcpy(buf, meta->vol, p->rmargin); - pp = mdoc_msec2a(meta->msec); + if (meta->arch) { + (void)strlcat(buf, " (", p->rmargin); + (void)strlcat(buf, meta->arch, p->rmargin); + (void)strlcat(buf, ")", p->rmargin); + } - (void)snprintf(title, p->rmargin, "%s(%s)", - meta->title, pp ? pp : ""); + (void)snprintf(title, p->rmargin, "%s(%d)", + meta->title, meta->msec); for (bufp = title; *bufp; bufp++) - *bufp = toupper(*bufp); + *bufp = toupper((u_char)*bufp); p->offset = 0; p->rmargin = (p->maxrmargin - strlen(buf)) / 2; @@ -671,7 +602,6 @@ header(struct termp *p, const struct mdoc_meta *meta) p->flags &= ~TERMP_NOSPACE; free(title); - free(vbuf); free(buf); } @@ -684,27 +614,15 @@ header(struct termp *p, const struct mdoc_meta *meta) static void nescape(struct termp *p, const char *word, size_t len) { - struct termenc *enc; + const char *rhs; + size_t sz; - switch (len) { - case (1): - enc = termenc1; - break; - case (2): - enc = termenc2; - break; - default: + if (NULL == (rhs = a2ascii(p->symtab, word, len, &sz))) { 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); + stringa(p, rhs, sz); } @@ -718,24 +636,34 @@ pescape(struct termp *p, const char *word, size_t *i, { size_t j; - (*i)++; - assert(*i < len); + if (++(*i) >= len) { + warnx("ignoring bad escape sequence"); + return; + } if ('(' == word[*i]) { (*i)++; - assert(*i + 1 < len); + if (*i + 1 >= len) { + warnx("ignoring bad escape sequence"); + return; + } nescape(p, &word[*i], 2); (*i)++; return; } else if ('*' == word[*i]) { - /* XXX - deprecated! */ (*i)++; - assert(*i < len); + if (*i >= len) { + warnx("ignoring bad escape sequence"); + return; + } switch (word[*i]) { case ('('): (*i)++; - assert(*i + 1 < len); + if (*i + 1 >= len) { + warnx("ignoring bad escape sequence"); + return; + } nescape(p, &word[*i], 2); (*i)++; return; @@ -755,7 +683,10 @@ pescape(struct termp *p, const char *word, size_t *i, for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++) /* Loop... */ ; - assert(word[*i]); + if (0 == word[*i]) { + warnx("ignoring bad escape sequence"); + return; + } nescape(p, &word[*i - j], j); } @@ -778,54 +709,33 @@ 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); - for (i = 0; i < len; i++) { if ('\\' == word[i]) { pescape(p, word, &i, len); continue; } + + if (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); } /* - * 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. @@ -870,3 +780,149 @@ 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; + } +} + + +__dead void +punt(struct nroffopt *nroff, char *in) +{ + char *args[32]; + char arg0[32], argm[32]; + int i; + + warnx("punting to nroff!"); + + i = 0; + + (void)strlcpy(arg0, "nroff", 32); + args[i++] = arg0; + + if (nroff->fl_h) + args[i++] = "-h"; + if (nroff->fl_i) + args[i++] = "-i"; + + if (nroff->arg_m) { + (void)strlcpy(argm, "-m", 32); + (void)strlcat(argm, nroff->arg_m, 32); + args[i++] = argm; + } else + args[i++] = "-mandoc"; + + args[i++] = in; + args[i++] = (char *)NULL; + + (void)execvp("nroff", args); + errx(1, "exec"); + /* NOTREACHED */ +} +