=================================================================== RCS file: /cvs/mandoc/Attic/mdocterm.c,v retrieving revision 1.18 retrieving revision 1.49 diff -u -p -r1.18 -r1.49 --- mandoc/Attic/mdocterm.c 2009/02/27 10:55:16 1.18 +++ mandoc/Attic/mdocterm.c 2009/03/19 11:49:00 1.49 @@ -1,6 +1,6 @@ -/* $Id: mdocterm.c,v 1.18 2009/02/27 10:55:16 kristaps Exp $ */ +/* $Id: mdocterm.c,v 1.49 2009/03/19 11:49:00 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,126 +16,407 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ -#include +#include +#include #include -#include #include +#include #include #include #include #include +#include -#ifndef __OpenBSD__ -#include -#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" +#define WARN_WALL 0x03 /* All-warnings mask. */ +#define WARN_WCOMPAT (1 << 0) /* Compatibility warnings. */ +#define WARN_WSYNTAX (1 << 1) /* Syntax warnings. */ +#define WARN_WERR (1 << 2) /* Warnings->errors. */ -#ifdef __NetBSD__ -#define xisspace(x) isspace((int)(x)) -#else -#define xisspace(x) isspace((x)) -#endif - -enum termstyle { - STYLE_CLEAR, - STYLE_BOLD, - STYLE_UNDERLINE +enum termt { + TERMT_ASCII, + TERMT_LINT, + TERMT_TREE }; -static void body(struct termp *, - struct termpair *, +extern char *__progname; + +__dead static void version(void); +__dead static void usage(void); +#if 0 +__dead static void punt(struct cmdargs *, char **); +#endif +static int foptions(int *, char *); +static int toptions(enum termt *, char *); +static int woptions(int *, char *); +static int merr(void *, int, int, const char *); +static int mwarn(void *, int, int, + enum mdoc_warn, const char *); +static void body(struct termp *, struct termpair *, const struct mdoc_meta *, const struct mdoc_node *); static void header(struct termp *, const struct mdoc_meta *); static void footer(struct termp *, const struct mdoc_meta *); - -static void pword(struct termp *, const char *, size_t); +static int file(char **, size_t *, char **, size_t *, + const char *, struct mdoc *); +static int fdesc(char **, size_t *, char **, size_t *, + const char *, int, struct mdoc *); +static void pword(struct termp *, const char *, int); static void pescape(struct termp *, - const char *, size_t *, size_t); -static void nescape(struct termp *, + const char *, int *, int); +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 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 - int main(int argc, char *argv[]) { - struct mmain *p; - const struct mdoc *mdoc; struct termp termp; + int c, fflags, wflags; + struct mdoc_cb cb; + struct mdoc *mdoc; + char *buf, *line; + size_t bufsz, linesz; + enum termt termt; - p = mmain_alloc(); + bzero(&termp, sizeof(struct termp)); + bzero(&cb, sizeof(struct mdoc_cb)); - if ( ! mmain_getopt(p, argc, argv, NULL, NULL, NULL, NULL)) - mmain_exit(p, 1); + termt = TERMT_ASCII; + fflags = wflags = 0; - if (NULL == (mdoc = mmain_mdoc(p))) - mmain_exit(p, 1); + /* LINTED */ + while (-1 != (c = getopt(argc, argv, "f:VW:T:"))) + switch (c) { + case ('f'): + if ( ! foptions(&fflags, optarg)) + return(0); + break; + case ('T'): + if ( ! toptions(&termt, optarg)) + return(0); + break; + case ('W'): + if ( ! woptions(&wflags, optarg)) + return(0); + break; + case ('V'): + version(); + /* NOTREACHED */ + default: + usage(); + /* NOTREACHED */ + } - termp.maxrmargin = 80; /* XXX */ - termp.rmargin = termp.maxrmargin; - termp.maxcols = 1024; - termp.offset = termp.col = 0; - termp.flags = TERMP_NOSPACE; + argc -= optind; + argv += optind; - if (NULL == (termp.buf = malloc(termp.maxcols))) - err(1, "malloc"); + termp.maxrmargin = 78; /* FIXME */ - header(&termp, mdoc_meta(mdoc)); - body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc)); - footer(&termp, mdoc_meta(mdoc)); + cb.mdoc_err = merr; + cb.mdoc_warn = mwarn; - free(termp.buf); + /* Line and block buffers persist between parses. */ - mmain_exit(p, 0); + buf = line = NULL; + bufsz = linesz = 0; + + /* Overall mdoc persists between parses. */ + + mdoc = mdoc_alloc(&wflags, fflags, &cb); + + while (*argv) { + if ( ! file(&line, &linesz, &buf, &bufsz, *argv, mdoc)) + break; + + switch (termt) { + case (TERMT_ASCII): + if (NULL == termp.symtab) + termp.symtab = ascii2htab(); + header(&termp, mdoc_meta(mdoc)); + body(&termp, NULL, mdoc_meta(mdoc), + mdoc_node(mdoc)); + footer(&termp, mdoc_meta(mdoc)); + break; + default: + break; + } + + mdoc_reset(mdoc); + argv++; + } + + if (buf) + free(buf); + if (line) + free(line); + if (termp.buf) + free(termp.buf); + if (termp.symtab) + asciifree(termp.symtab); + + mdoc_free(mdoc); + + return(0); +} + + +__dead static void +version(void) +{ + + (void)printf("%s %s\n", __progname, VERSION); + exit(0); /* NOTREACHED */ } +__dead static void +usage(void) +{ + + (void)fprintf(stderr, "usage: %s\n", __progname); + exit(1); + /* NOTREACHED */ +} + + +static int +file(char **ln, size_t *lnsz, char **buf, size_t *bufsz, + const char *file, struct mdoc *mdoc) +{ + int fd, c; + + if (-1 == (fd = open(file, O_RDONLY, 0))) { + warn("%s", file); + return(0); + } + + c = fdesc(ln, lnsz, buf, bufsz, file, fd, mdoc); + + if (-1 == close(fd)) + warn("%s", file); + + return(c); +} + + +static int +fdesc(char **lnp, size_t *lnsz, char **bufp, size_t *bufsz, + const char *f, int fd, struct mdoc *mdoc) +{ + size_t sz; + ssize_t ssz; + struct stat st; + int j, i, pos, lnn; + char *ln, *buf; + + buf = *bufp; + ln = *lnp; + + /* + * Two buffers: ln and buf. buf is the input buffer, optimised + * for each file's block size. ln is a line buffer. Both + * growable, hence passed in by ptr-ptr. + */ + + if (-1 == fstat(fd, &st)) { + warnx("%s", f); + sz = BUFSIZ; + } else + sz = (unsigned)BUFSIZ > st.st_blksize ? + (size_t)BUFSIZ : st.st_blksize; + + if (sz > *bufsz) { + if (NULL == (buf = realloc(buf, sz))) + err(1, "realloc"); + *bufp = buf; + *bufsz = sz; + } + + /* + * Fill buf with file blocksize and parse newlines into ln. + */ + + for (lnn = 1, pos = 0; ; ) { + if (-1 == (ssz = read(fd, buf, sz))) { + warn("%s", f); + return(0); + } else if (0 == ssz) + break; + + for (i = 0; i < (int)ssz; i++) { + if (pos >= (int)*lnsz) { + *lnsz += 256; /* Step-size. */ + ln = realloc(ln, *lnsz); + if (NULL == ln) + err(1, "realloc"); + *lnp = ln; + } + + if ('\n' != buf[i]) { + ln[pos++] = buf[i]; + continue; + } + + /* Check for CPP-escaped newline. */ + + if (pos > 0 && '\\' == ln[pos - 1]) { + for (j = pos - 1; j >= 0; j--) + if ('\\' != ln[j]) + break; + + if ( ! ((pos - j) % 2)) { + pos--; + lnn++; + continue; + } + } + + ln[pos] = 0; + if ( ! mdoc_parseln(mdoc, lnn, ln)) + return(0); + lnn++; + pos = 0; + } + } + + return(mdoc_endparse(mdoc)); +} + + +static int +toptions(enum termt *tflags, char *arg) +{ + + if (0 == strcmp(arg, "ascii")) + *tflags = TERMT_ASCII; + else if (0 == strcmp(arg, "lint")) + *tflags = TERMT_LINT; + else if (0 == strcmp(arg, "tree")) + *tflags = TERMT_TREE; + else { + warnx("bad argument: -T%s", arg); + return(0); + } + + return(1); +} + + +/* + * Parse out the options for [-fopt...] setting compiler options. These + * can be comma-delimited or called again. + */ +static int +foptions(int *fflags, char *arg) +{ + char *v; + char *toks[] = { "ign-scope", "ign-escape", + "ign-macro", NULL }; + + while (*arg) + switch (getsubopt(&arg, toks, &v)) { + case (0): + *fflags |= MDOC_IGN_SCOPE; + break; + case (1): + *fflags |= MDOC_IGN_ESCAPE; + break; + case (2): + *fflags |= MDOC_IGN_MACRO; + break; + default: + warnx("bad argument: -f%s", arg); + return(0); + } + + return(1); +} + + +/* + * Parse out the options for [-Werr...], which sets warning modes. + * These can be comma-delimited or called again. XXX - should this be + * using -w like troff? + */ +static int +woptions(int *wflags, char *arg) +{ + char *v; + char *toks[] = { "all", "compat", + "syntax", "error", NULL }; + + while (*arg) + switch (getsubopt(&arg, toks, &v)) { + case (0): + *wflags |= WARN_WALL; + break; + case (1): + *wflags |= WARN_WCOMPAT; + break; + case (2): + *wflags |= WARN_WSYNTAX; + break; + case (3): + *wflags |= WARN_WERR; + break; + default: + warnx("bad argument: -W%s", arg); + return(0); + } + + 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 + * broken apart by newlines getting there. A line can also be a + * fragment of a columnar list. + * + * Specifically, a line is whatever's in p->buf of length p->col, which + * is zeroed after this function returns. + * + * The variables TERMP_NOLPAD, TERMP_LITERAL and TERMP_NOBREAK are of + * critical importance here. Their behaviour follows: + * + * - TERMP_NOLPAD: when beginning to write the line, don't left-pad the + * offset value. This is useful when doing columnar lists where the + * prior column has right-padded. + * + * - TERMP_NOBREAK: this is the most important and is used when making + * columns. In short: don't print a newline and instead pad to the + * right margin. Used in conjunction with TERMP_NOLPAD. + * + * - TERMP_NONOBREAK: don't newline when TERMP_NOBREAK is specified. + * + * 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; + int i, j; + size_t vsz, vis, maxvis, mmax, bp; /* * First, establish the maximum columns of "visible" content. @@ -146,6 +427,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; /* @@ -156,83 +439,98 @@ flushln(struct termp *p) if ( ! (p->flags & TERMP_NOLPAD)) /* LINTED */ - for (j = 0; j < p->offset; j++) + for (j = 0; j < (int)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++) { + for (i = 0; i < (int)p->col; i++) { /* * Count up visible word characters. Control sequences - * (starting with the CSI) aren't counted. + * (starting with the CSI) aren't counted. A space + * generates a non-printing word, which is valid (the + * space is printed according to regular spacing rules). */ - assert( ! xisspace(p->buf[i])); /* LINTED */ - for (j = i, vsz = 0; j < p->col; j++) { - if (xisspace(p->buf[j])) + for (j = i, vsz = 0; j < (int)p->col; 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++; } - assert(vsz > 0); /* - * 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 or when we're not allowed to break - * the line with TERMP_NOBREAK). + * 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. */ - /* FIXME: allow selective right-margin breaking. */ + if ( ! (TERMP_NOBREAK & p->flags)) { + if (vis && vis + vsz > bp) { + putchar('\n'); + for (j = 0; j < (int)p->offset; j++) + putchar(' '); + vis = 0; + } else if (vis + vsz > bp) + warnx("word breaks right margin"); - if (vis && vis + vsz > maxvis) { - if (p->flags & TERMP_NOBREAK) - errx(1, "word breaks right margin"); - putchar('\n'); - for (j = 0; j < p->offset; j++) - putchar(' '); - vis = 0; - } else if (vis + vsz > maxvis) - errx(1, "word breaks right margin"); + /* TODO: hyphenate. */ + } else { + if (vis && vis + vsz > bp) { + putchar('\n'); + for (j = 0; j < (int)p->rmargin; j++) + putchar(' '); + vis = p->rmargin - p->offset; + } else if (vis + vsz > bp) + warnx("word breaks right margin"); + + /* TODO: hyphenate. */ + } + /* * Write out the word and a trailing space. Omit the - * 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])) + for ( ; i < (int)p->col; i++) { + if (' ' == p->buf[i]) break; putchar(p->buf[i]); } vis += vsz; - if (i < p->col) { + if (i < (int)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) { + if ( ! (TERMP_NONOBREAK & p->flags)) { + putchar('\n'); + for (i = 0; i < (int)p->rmargin; i++) + putchar(' '); + } + p->col = 0; + return; + } + + /* * If we're not to right-marginalise it (newline), then instead * pad to the right margin and stay off. */ if (p->flags & TERMP_NOBREAK) { - if ( ! (p->flags & TERMP_NORPAD)) + if ( ! (TERMP_NONOBREAK & p->flags)) for ( ; vis < maxvis; vis++) putchar(' '); } else @@ -242,14 +540,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; @@ -260,288 +559,39 @@ 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 -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]); - 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; - - /*assert(len > 0);*/ /* Can be, if literal. */ - - /* - * Handle pwords, partial words, which may be either a single - * word or a phrase that cannot be broken down (such as a - * literal string). This handles word styling. - */ - - if ( ! (p->flags & TERMP_NOSPACE) && - ! (p->flags & TERMP_LITERAL)) - chara(p, ' '); - - if ( ! (p->flags & TERMP_NONOSPACE)) - p->flags &= ~TERMP_NOSPACE; - - /* - * XXX - if literal and underlining, this will underline the - * spaces between literal words. - */ - - if (p->flags & TERMP_BOLD) - style(p, STYLE_BOLD); - if (p->flags & TERMP_UNDERLINE) - style(p, STYLE_UNDERLINE); - - for (i = 0; i < len; i++) { - if ('\\' == word[i]) { - pescape(p, word, &i, len); - continue; - } - chara(p, word[i]); - } - - if (p->flags & TERMP_BOLD || - p->flags & TERMP_UNDERLINE) - style(p, STYLE_CLEAR); -} - - +/* + * Break apart a word into "pwords" (partial-words, usually from + * breaking up a phrase into individual words) and, eventually, put them + * into the output buffer. If we're a literal word, then don't break up + * the word and put it verbatim into the output buffer. + */ void word(struct termp *p, const char *word) { - size_t i, j, len; + int 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)); + pword(p, word, (int)strlen(word)); return; } - len = strlen(word); - assert(len > 0); + if (0 == (len = (int)strlen(word))) + errx(1, "blank line not in literal context"); if (mdoc_isdelim(word)) { if ( ! (p->flags & TERMP_IGNDELIM)) @@ -551,10 +601,17 @@ word(struct termp *p, const char *word) /* LINTED */ for (j = i = 0; i < len; i++) { - if ( ! xisspace(word[i])) { + if (' ' != word[i]) { j++; continue; + } + + /* Escaped spaces don't delimit... */ + if (i && ' ' == word[i] && '\\' == word[i - 1]) { + j++; + continue; } + if (0 == j) continue; assert(i >= j); @@ -568,6 +625,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, @@ -576,12 +639,10 @@ 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. - */ + /* Some quick sanity-checking. */ + sanity(node); + /* Pre-processing. */ dochild = 1; @@ -596,7 +657,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. */ @@ -676,9 +737,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; p->rmargin = p->maxrmargin; p->offset = 0; @@ -687,49 +746,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: @@ -743,20 +760,18 @@ 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); - p->offset = 0; p->rmargin = (p->maxrmargin - strlen(buf)) / 2; p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; @@ -784,6 +799,334 @@ header(struct termp *p, const struct mdoc_meta *meta) p->flags &= ~TERMP_NOSPACE; free(title); - 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) +{ + const char *rhs; + size_t sz; + + if (NULL == (rhs = a2ascii(p->symtab, word, len, &sz))) + return; + stringa(p, rhs, sz); +} + + +/* + * 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, int *i, int len) +{ + int j; + + if (++(*i) >= len) + return; + + if ('(' == word[*i]) { + (*i)++; + if (*i + 1 >= len) + return; + + nescape(p, &word[*i], 2); + (*i)++; + return; + + } else if ('*' == word[*i]) { + (*i)++; + if (*i >= len) + return; + + switch (word[*i]) { + case ('('): + (*i)++; + if (*i + 1 >= len) + return; + + 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... */ ; + + if (0 == word[*i]) + return; + + nescape(p, &word[*i - j], (size_t)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, int len) +{ + int i; + + if ( ! (TERMP_NOSPACE & p->flags) && + ! (TERMP_LITERAL & p->flags)) + chara(p, ' '); + + if ( ! (p->flags & TERMP_NONOSPACE)) + p->flags &= ~TERMP_NOSPACE; + + /* + * If ANSI (word-length styling), then apply our style now, + * before the word. + */ + + 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]); + } +} + + +/* + * Like chara() but for arbitrary-length buffers. Resize the buffer by + * a factor of two (if the buffer is less than that) or the buffer's + * size. + */ +static void +stringa(struct termp *p, const char *c, size_t sz) +{ + size_t s; + + if (0 == sz) + return; + + assert(c); + if (p->col + sz >= p->maxcols) { + if (0 == p->maxcols) + p->maxcols = 256; + s = sz > p->maxcols * 2 ? sz : p->maxcols * 2; + p->buf = realloc(p->buf, s); + if (NULL == p->buf) + err(1, "realloc"); + p->maxcols = s; + } + + (void)memcpy(&p->buf[(int)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) +{ + size_t s; + + if (p->col + 1 >= p->maxcols) { + if (0 == p->maxcols) + p->maxcols = 256; + s = p->maxcols * 2; + p->buf = realloc(p->buf, s); + if (NULL == p->buf) + err(1, "realloc"); + p->maxcols = s; + } + p->buf[(int)(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; + } +} + + +static int +merr(void *arg, int line, int col, const char *msg) +{ + + warnx("error: %s (line %d, column %d)", msg, line, col); + return(0); +} + + +static int +mwarn(void *arg, int line, int col, + enum mdoc_warn type, const char *msg) +{ + int flags; + char *wtype; + + flags = *(int *)arg; + wtype = NULL; + + switch (type) { + case (WARN_COMPAT): + wtype = "compat"; + if (flags & WARN_WCOMPAT) + break; + return(1); + case (WARN_SYNTAX): + wtype = "syntax"; + if (flags & WARN_WSYNTAX) + break; + return(1); + } + + assert(wtype); + warnx("%s warning: %s (line %d, column %d)", + wtype, msg, line, col); + + if ( ! (flags & WARN_WERR)) + return(1); + + warnx("%s: considering warnings as errors", + __progname); + return(0); +} + +