=================================================================== RCS file: /cvs/mandoc/Attic/mdocterm.c,v retrieving revision 1.1 retrieving revision 1.43 diff -u -p -r1.1 -r1.43 --- mandoc/Attic/mdocterm.c 2009/02/21 21:00:06 1.1 +++ mandoc/Attic/mdocterm.c 2009/03/15 07:08:53 1.43 @@ -1,4 +1,4 @@ - /* $Id: mdocterm.c,v 1.1 2009/02/21 21:00:06 kristaps Exp $ */ +/* $Id: mdocterm.c,v 1.43 2009/03/15 07:08:53 kristaps Exp $ */ /* * Copyright (c) 2008 Kristaps Dzonsons * @@ -16,11 +16,10 @@ * 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 @@ -28,145 +27,238 @@ #include #include -#include "mdoc.h" +#include "mmain.h" #include "term.h" -#define MD_LINE_SZ (256) /* Max input line size. */ +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. */ +}; -struct md_parse { - int warn; /* Warning flags. */ -#define MD_WARN_SYNTAX (1 << 0) /* Show syntax warnings. */ -#define MD_WARN_COMPAT (1 << 1) /* Show compat warnings. */ -#define MD_WARN_ALL (0x03) /* Show all warnings. */ -#define MD_WARN_ERR (1 << 2) /* Make warnings->errors. */ - int dbg; /* Debug level. */ - struct mdoc *mdoc; /* Active parser. */ - char *buf; /* Input buffer. */ - u_long bufsz; /* Input buffer size. */ - char *in; /* Input file name. */ - int fdin; /* Input file desc. */ +struct termseq { + const char *enc; + int sym; }; -extern char *__progname; +dead_pre void punt(struct nroffopt *, char *) dead_post; +static int option(void *, int, char *); +static int optsopt(struct termp *, 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 usage(void); -static int getsopts(struct md_parse *, char *); -static int parse(struct md_parse *); -static void msg_msg(void *, int, int, const char *); -static int msg_err(void *, int, int, const char *); -static int msg_warn(void *, int, int, - enum mdoc_warn, const char *); +static void pword(struct termp *, const char *, size_t); +static void pescape(struct termp *, const char *, + size_t *, size_t); +static void nescape(struct termp *, + const char *, size_t); +static void chara(struct termp *, char); +static void stringa(struct termp *, + const char *, size_t); +static void symbola(struct termp *, enum tsym); +static void sanity(const struct mdoc_node *); #ifdef __linux__ -extern int getsubopt(char **, char *const *, char **); +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 md_parse p; - struct mdoc_cb cb; - struct stat st; - int c; - extern char *optarg; - extern int optind; +static struct termseq termenc1[] = { + { "\\", TERMSYM_SLASH }, + { "\'", TERMSYM_RSQUOTE }, + { "`", TERMSYM_LSQUOTE }, + { "-", TERMSYM_HYPHEN }, + { " ", TERMSYM_SPACE }, + { ".", TERMSYM_PERIOD }, + { "&", TERMSYM_BREAK }, + { "e", TERMSYM_SLASH }, + { "q", TERMSYM_DQUOTE }, + { "|", TERMSYM_BREAK }, + { NULL, 0 } +}; - (void)memset(&p, 0, sizeof(struct md_parse)); +static struct termseq termenc2[] = { + { "rC", TERMSYM_RBRACE }, + { "lC", TERMSYM_LBRACE }, + { "rB", TERMSYM_RBRACK }, + { "lB", TERMSYM_LBRACK }, + { "ra", TERMSYM_RANGLE }, + { "la", TERMSYM_LANGLE }, + { "Lq", TERMSYM_LDQUOTE }, + { "lq", TERMSYM_LDQUOTE }, + { "Rq", TERMSYM_RDQUOTE }, + { "rq", TERMSYM_RDQUOTE }, + { "oq", TERMSYM_LSQUOTE }, + { "aq", TERMSYM_RSQUOTE }, - while (-1 != (c = getopt(argc, argv, "vW:"))) - switch (c) { - case ('v'): - p.dbg++; - break; - case ('W'): - if ( ! getsopts(&p, optarg)) - return(0); - break; - default: - usage(); - return(0); - } + { "<-", TERMSYM_LARROW }, + { "->", TERMSYM_RARROW }, + { "ua", TERMSYM_UARROW }, + { "da", TERMSYM_DARROW }, - argv += optind; - argc -= optind; + { "bu", TERMSYM_BULLET }, + { "Ba", TERMSYM_BAR }, + { "ba", TERMSYM_BAR }, + { "co", TERMSYM_COPY }, + { "Am", TERMSYM_AMP }, - /* Initialise the input file. */ + { "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 }, - p.in = "-"; - p.fdin = STDIN_FILENO; + { "aa", TERMSYM_ACUTE }, + { "ga", TERMSYM_GRAVE }, - if (argc > 0) { - p.in = *argv++; - p.fdin = open(p.in, O_RDONLY, 0); - if (-1 == p.fdin) - err(1, "%s", p.in); - } + { "en", TERMSYM_EN }, + { "em", TERMSYM_EM }, - /* Allocate a buffer to be BUFSIZ/block size. */ + { "Pi", TERMSYM_PI }, + { NULL, 0 } +}; - if (-1 == fstat(p.fdin, &st)) { - warn("%s", p.in); - p.bufsz = BUFSIZ; - } else - p.bufsz = MAX(st.st_blksize, BUFSIZ); +/* FIXME: abstract to dynamically-compiled table. */ +static struct termsym termsym_ascii[TERMSYM_MAX] = { + { "]", 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 */ + { "<", 1 }, /* TERMSYM_LANGLE */ + { ">", 1 }, /* TERMSYM_RANGLE */ + { "{", 1 }, /* TERMSYM_LBRACE */ + { "}", 1 }, /* TERMSYM_RBRACE */ +}; - p.buf = malloc(p.bufsz); - if (NULL == p.buf) - err(1, "malloc"); +int +main(int argc, char *argv[]) +{ + struct mmain *p; + const struct mdoc *mdoc; + struct nroffopt nroff; + struct termp termp; + int c; + char *in; - /* Allocate the parser. */ + (void)memset(&termp, 0, sizeof(struct termp)); + (void)memset(&nroff, 0, sizeof(struct nroffopt)); - cb.mdoc_err = msg_err; - cb.mdoc_warn = msg_warn; - cb.mdoc_msg = msg_msg; + termp.maxrmargin = termp.rmargin = 78; /* FIXME */ + termp.maxcols = 1024; /* FIXME */ + termp.offset = termp.col = 0; + termp.flags = TERMP_NOSPACE; + termp.symtab = termsym_ascii; + termp.enc = TERMENC_NROFF; - p.mdoc = mdoc_alloc(&p, &cb); + nroff.termp = &termp; - /* Parse the input file. */ + p = mmain_alloc(); - c = parse(&p); - free(p.buf); + c = mmain_getopt(p, argc, argv, "[-Ooption...]", + "[infile]", "him:n:o:r:T:O:", &nroff, option); - if (STDIN_FILENO != p.fdin && -1 == close(p.fdin)) - warn("%s", p.in); + /* FIXME: this needs to accept multiple outputs. */ + argv += c; + if ((argc -= c) > 0) + in = *argv++; + else + in = "-"; - if (0 == c) { - mdoc_free(p.mdoc); - return(EXIT_FAILURE); + 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 the parse succeeded, print it out. */ + if (NULL == (termp.buf = malloc(termp.maxcols))) + err(1, "malloc"); - termprint(mdoc_node(p.mdoc), mdoc_meta(p.mdoc)); - mdoc_free(p.mdoc); + header(&termp, mdoc_meta(mdoc)); + body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc)); + footer(&termp, mdoc_meta(mdoc)); - return(EXIT_SUCCESS); + free(termp.buf); + + mmain_exit(p, 0); + /* NOTREACHED */ } static int -getsopts(struct md_parse *p, char *arg) +optsopt(struct termp *p, char *arg) { char *v; - char *toks[] = { "all", "compat", - "syntax", "error", NULL }; + char *toks[] = { "ansi", "nopunt", NULL }; while (*arg) switch (getsubopt(&arg, toks, &v)) { case (0): - p->warn |= MD_WARN_ALL; + p->enc = TERMENC_ANSI; break; - case (1): - p->warn |= MD_WARN_COMPAT; - break; case (2): - p->warn |= MD_WARN_SYNTAX; + p->iflags |= TERMP_NOPUNT; break; - case (3): - p->warn |= MD_WARN_ERR; - break; default: - usage(); + warnx("unknown -O argument"); return(0); } @@ -175,115 +267,860 @@ getsopts(struct md_parse *p, char *arg) static int -parse(struct md_parse *p) +option(void *ptr, int c, char *arg) { - ssize_t sz, i; - size_t pos; - char line[MD_LINE_SZ]; - int lnn; + 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 + * 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. + * + * 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, mmax, bp; + /* - * This is a little more complicated than fgets. TODO: have - * some benchmarks that show it's faster (note that I want to - * check many, many manuals simultaneously, so speed is - * important). Fill a buffer (sized to the block size) with a - * single read, then parse \n-terminated lines into a line - * buffer, which is passed to the parser. Hard-code the line - * buffer to a particular size -- a reasonable assumption. + * First, establish the maximum columns of "visible" content. + * This is usually the difference between the right-margin and + * an indentation, but can be, for tagged lists or columns, a + * small set of values. */ - for (lnn = 1, pos = 0; ; ) { - if (-1 == (sz = read(p->fdin, p->buf, p->bufsz))) { - warn("%s", p->in); - return(0); - } else if (0 == sz) - break; + assert(p->offset < p->rmargin); + maxvis = p->rmargin - p->offset; + mmax = p->maxrmargin - p->offset; + bp = TERMP_NOBREAK & p->flags ? mmax : maxvis; + vis = 0; - for (i = 0; i < sz; i++) { - if ('\n' != p->buf[i]) { - if (pos < sizeof(line)) { - line[(int)pos++] = p->buf[(int)i]; - continue; - } - warnx("%s: line %d too long", p->in, lnn); - return(0); - } - - line[(int)pos] = 0; - if ( ! mdoc_parseln(p->mdoc, lnn, line)) - return(0); + /* + * If in the standard case (left-justified), then begin with our + * indentation, otherwise (columns, etc.) just start spitting + * out text. + */ - lnn++; - pos = 0; + if ( ! (p->flags & TERMP_NOLPAD)) + /* LINTED */ + for (j = 0; j < p->offset; j++) + putchar(' '); + + for (i = 0; i < p->col; i++) { + /* + * Count up visible word characters. Control sequences + * (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). + */ + + /* LINTED */ + for (j = i, vsz = 0; j < p->col; j++) { + if (isspace((u_char)p->buf[j])) { + break; + } 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++; } + + /* + * 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 > bp) { + putchar('\n'); + for (j = 0; j < p->offset; j++) + putchar(' '); + vis = 0; + } 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 - 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 or beyond + * our breakpoint. + */ + + for ( ; i < p->col; i++) { + if (isspace((u_char)p->buf[i])) + break; + putchar(p->buf[i]); + } + vis += vsz; + if (i < p->col && vis <= bp) { + putchar(' '); + vis++; + } } - return(mdoc_endparse(p->mdoc)); + /* + * 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 < 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 ( ! (TERMP_NONOBREAK & p->flags)) + for ( ; vis < maxvis; vis++) + putchar(' '); + } else + putchar('\n'); + + p->col = 0; } -static int -msg_err(void *arg, int line, int col, const char *msg) +/* + * 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) { - struct md_parse *p; - p = (struct md_parse *)arg; + p->flags |= TERMP_NOSPACE; + if (0 == p->col) { + p->flags &= ~TERMP_NOLPAD; + return; + } + flushln(p); + p->flags &= ~TERMP_NOLPAD; +} - warnx("%s:%d: error: %s (column %d)", - p->in, line, msg, col); - return(0); + +/* + * 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) +{ + + newln(p); + putchar('\n'); } +/* + * 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; + + if (p->flags & TERMP_LITERAL) { + pword(p, word, strlen(word)); + return; + } + + if (0 == (len = strlen(word))) + errx(1, "blank line not in literal context"); + + if (mdoc_isdelim(word)) { + if ( ! (p->flags & TERMP_IGNDELIM)) + p->flags |= TERMP_NOSPACE; + p->flags &= ~TERMP_IGNDELIM; + } + + /* LINTED */ + for (j = i = 0; i < len; i++) { + if ( ! isspace((u_char)word[i])) { + j++; + continue; + } + + /* Escaped spaces don't delimit... */ + if (i > 0 && isspace((u_char)word[i]) && + '\\' == word[i - 1]) { + j++; + continue; + } + + if (0 == j) + continue; + assert(i >= j); + pword(p, &word[i - j], j); + j = 0; + } + if (j > 0) { + assert(i >= j); + pword(p, &word[i - j], j); + } +} + + +/* + * 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 -msg_msg(void *arg, int line, int col, const char *msg) +body(struct termp *p, struct termpair *ppair, + const struct mdoc_meta *meta, + const struct mdoc_node *node) { - struct md_parse *p; + int dochild; + struct termpair pair; - p = (struct md_parse *)arg; + /* Some quick sanity-checking. */ - if (0 == p->dbg) + sanity(node); + + /* Pre-processing. */ + + dochild = 1; + pair.ppair = ppair; + pair.type = 0; + pair.offset = pair.rmargin = 0; + pair.flag = 0; + pair.count = 0; + + if (MDOC_TEXT != node->type) { + if (termacts[node->tok].pre) + if ( ! (*termacts[node->tok].pre)(p, &pair, meta, node)) + dochild = 0; + } else /* MDOC_TEXT == node->type */ + word(p, node->string); + + /* Children. */ + + if (TERMPAIR_FLAG & pair.type) + p->flags |= pair.flag; + + if (dochild && node->child) + body(p, &pair, meta, node->child); + + if (TERMPAIR_FLAG & pair.type) + p->flags &= ~pair.flag; + + /* Post-processing. */ + + if (MDOC_TEXT != node->type) + if (termacts[node->tok].post) + (*termacts[node->tok].post)(p, &pair, meta, node); + + /* Siblings. */ + + if (node->next) + body(p, ppair, meta, node->next); +} + + +static void +footer(struct termp *p, const struct mdoc_meta *meta) +{ + struct tm *tm; + char *buf, *os; + + if (NULL == (buf = malloc(p->rmargin))) + err(1, "malloc"); + if (NULL == (os = malloc(p->rmargin))) + err(1, "malloc"); + + tm = localtime(&meta->date); + +#ifdef __OpenBSD__ + if (NULL == strftime(buf, p->rmargin, "%B %d, %Y", tm)) +#else + if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm)) +#endif + err(1, "strftime"); + + (void)strlcpy(os, meta->os, p->rmargin); + + /* + * This is /slightly/ different from regular groff output + * because we don't have page numbers. Print the following: + * + * OS MDOCDATE + */ + + vspace(p); + + p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; + p->rmargin = p->maxrmargin - strlen(buf); + p->offset = 0; + + word(p, os); + flushln(p); + + p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; + p->offset = p->rmargin; + p->rmargin = p->maxrmargin; + p->flags &= ~TERMP_NOBREAK; + + word(p, buf); + flushln(p); + + free(buf); + free(os); +} + + +static void +header(struct termp *p, const struct mdoc_meta *meta) +{ + char *buf, *title, *bufp; + + p->rmargin = p->maxrmargin; + p->offset = 0; + + if (NULL == (buf = malloc(p->rmargin))) + err(1, "malloc"); + if (NULL == (title = malloc(p->rmargin))) + err(1, "malloc"); + + /* + * The header is strange. It has three components, which are + * really two with the first duplicated. It goes like this: + * + * IDENTIFIER TITLE IDENTIFIER + * + * The IDENTIFIER is NAME(SECTION), which is the command-name + * (if given, or "unknown" if not) followed by the manual page + * section. These are given in `Dt'. The TITLE is a free-form + * string depending on the manual volume. If not specified, it + * switches on the manual section. + */ + + assert(meta->vol); + (void)strlcpy(buf, meta->vol, p->rmargin); + + 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(%d)", + meta->title, meta->msec); + + for (bufp = title; *bufp; bufp++) + *bufp = toupper((u_char)*bufp); + + p->offset = 0; + p->rmargin = (p->maxrmargin - strlen(buf)) / 2; + p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; + + word(p, title); + flushln(p); + + p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; + p->offset = p->rmargin; + p->rmargin = p->maxrmargin - strlen(title); + + word(p, buf); + flushln(p); + + p->offset = p->rmargin; + p->rmargin = p->maxrmargin; + p->flags &= ~TERMP_NOBREAK; + p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; + + word(p, title); + flushln(p); + + p->rmargin = p->maxrmargin; + p->offset = 0; + p->flags &= ~TERMP_NOSPACE; + + free(title); + 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) +{ + struct termseq *enc; + + switch (len) { + case (1): + enc = termenc1; + break; + case (2): + enc = termenc2; + break; + default: + warnx("unsupported %zu-byte escape sequence", len); return; + } - warnx("%s:%d: debug: %s (column %d)", - p->in, line, msg, col); + for ( ; enc->enc; enc++) + if (0 == memcmp(enc->enc, word, len)) { + symbola(p, enc->sym); + return; + } + + warnx("unsupported %zu-byte escape sequence", len); } -static int -msg_warn(void *arg, int line, int col, - enum mdoc_warn type, const char *msg) +/* + * 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) { - struct md_parse *p; + size_t j; - p = (struct md_parse *)arg; + if (++(*i) >= len) { + warnx("ignoring bad escape sequence"); + return; + } - switch (type) { - case (WARN_COMPAT): - if (p->warn & MD_WARN_COMPAT) + if ('(' == word[*i]) { + (*i)++; + if (*i + 1 >= len) { + warnx("ignoring bad escape sequence"); + return; + } + nescape(p, &word[*i], 2); + (*i)++; + return; + + } else if ('*' == word[*i]) { + (*i)++; + if (*i >= len) { + warnx("ignoring bad escape sequence"); + return; + } + switch (word[*i]) { + case ('('): + (*i)++; + if (*i + 1 >= len) { + warnx("ignoring bad escape sequence"); + return; + } + nescape(p, &word[*i], 2); + (*i)++; + return; + case ('['): break; - return(1); - case (WARN_SYNTAX): - if (p->warn & MD_WARN_SYNTAX) - break; - return(1); + default: + nescape(p, &word[*i], 1); + return; + } + + } else if ('[' != word[*i]) { + nescape(p, &word[*i], 1); + return; } - warnx("%s:%d: warning: %s (column %d)", - p->in, line, msg, col); + (*i)++; + for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++) + /* Loop... */ ; - if ( ! (p->warn & MD_WARN_ERR)) - return(1); + if (0 == word[*i]) { + warnx("ignoring bad escape sequence"); + return; + } + nescape(p, &word[*i - j], j); +} - warnx("%s: considering warnings as errors", __progname); - return(0); + +/* + * 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; + + /* + * If ANSI (word-length styling), then apply our style now, + * before the word. + */ + + 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 (TERMENC_ANSI == p->enc && TERMP_STYLE & p->flags) { + chara(p, 27); + stringa(p, "[00m", 4); + } } +/* + * Add a symbol to the output line buffer. + */ static void -usage(void) +symbola(struct termp *p, enum tsym sym) { - warnx("usage: %s [-v] [-Wwarn...] [infile]", __progname); + 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; + + if (0 == sz) + return; + + 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; +} + + +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_pre 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 */ }