=================================================================== RCS file: /cvs/mandoc/Attic/mdocterm.c,v retrieving revision 1.39 retrieving revision 1.49 diff -u -p -r1.39 -r1.49 --- mandoc/Attic/mdocterm.c 2009/03/11 00:39:58 1.39 +++ mandoc/Attic/mdocterm.c 2009/03/19 11:49:00 1.49 @@ -1,6 +1,6 @@ -/* $Id: mdocterm.c,v 1.39 2009/03/11 00:39:58 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 @@ -17,208 +17,368 @@ * PERFORMANCE OF THIS SOFTWARE. */ #include +#include #include -#include #include +#include #include #include #include #include +#include -#include "mmain.h" #include "term.h" -struct termenc { - const char *enc; - int sym; +#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. */ + +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 void pescape(struct termp *, const char *, - size_t *, 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 *, int *, int); 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 *); -static void stylea(struct termp *, enum tstyle); -#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 } -}; +int +main(int argc, char *argv[]) +{ + struct termp termp; + int c, fflags, wflags; + struct mdoc_cb cb; + struct mdoc *mdoc; + char *buf, *line; + size_t bufsz, linesz; + enum termt termt; -static struct termenc 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 }, + bzero(&termp, sizeof(struct termp)); + bzero(&cb, sizeof(struct mdoc_cb)); - { "<-", TERMSYM_LARROW }, - { "->", TERMSYM_RARROW }, - { "ua", TERMSYM_UARROW }, - { "da", TERMSYM_DARROW }, + termt = TERMT_ASCII; + fflags = wflags = 0; - { "bu", TERMSYM_BULLET }, - { "Ba", TERMSYM_BAR }, - { "ba", TERMSYM_BAR }, - { "co", TERMSYM_COPY }, - { "Am", TERMSYM_AMP }, + /* 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 */ + } - { "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 }, + argc -= optind; + argv += optind; - { "aa", TERMSYM_ACUTE }, - { "ga", TERMSYM_GRAVE }, + termp.maxrmargin = 78; /* FIXME */ - { "en", TERMSYM_EN }, - { "em", TERMSYM_EM }, + cb.mdoc_err = merr; + cb.mdoc_warn = mwarn; - { "Pi", TERMSYM_PI }, - { NULL, 0 } -}; + /* Line and block buffers persist between parses. */ -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 */ - { "<", 1 }, /* TERMSYM_LANGLE */ - { ">", 1 }, /* TERMSYM_RANGLE */ - { "{", 1 }, /* TERMSYM_LBRACE */ - { "}", 1 }, /* TERMSYM_RBRACE */ -}; + buf = line = NULL; + bufsz = linesz = 0; -static const char ansi_clear[] = { 27, '[', '0', 'm' }; -static const char ansi_bold[] = { 27, '[', '1', 'm' }; -static const char ansi_under[] = { 27, '[', '4', 'm' }; + /* Overall mdoc persists between parses. */ -static struct termsym termstyle_ansi[] = { - { ansi_clear, 4 }, - { ansi_bold, 4 }, - { ansi_under, 4 } -}; + mdoc = mdoc_alloc(&wflags, fflags, &cb); + while (*argv) { + if ( ! file(&line, &linesz, &buf, &bufsz, *argv, mdoc)) + break; -int -main(int argc, char *argv[]) -{ - struct mmain *p; - int c; - const struct mdoc *mdoc; - struct termp termp; + 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; + } - p = mmain_alloc(); + mdoc_reset(mdoc); + argv++; + } - c = mmain_getopt(p, argc, argv, NULL, NULL, NULL, NULL); - if (1 != c) - mmain_exit(p, -1 == c ? 1 : 0); + if (buf) + free(buf); + if (line) + free(line); + if (termp.buf) + free(termp.buf); + if (termp.symtab) + asciifree(termp.symtab); - if (NULL == (mdoc = mmain_mdoc(p))) - mmain_exit(p, 1); + mdoc_free(mdoc); - 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; + return(0); +} - if (NULL == (termp.buf = malloc(termp.maxcols))) - err(1, "malloc"); - header(&termp, mdoc_meta(mdoc)); - body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc)); - footer(&termp, mdoc_meta(mdoc)); +__dead static void +version(void) +{ - free(termp.buf); + (void)printf("%s %s\n", __progname, VERSION); + exit(0); + /* NOTREACHED */ +} - mmain_exit(p, 0); + +__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 @@ -238,6 +398,8 @@ main(int argc, char *argv[]) * 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 @@ -253,7 +415,8 @@ main(int argc, char *argv[]) void flushln(struct termp *p) { - size_t i, j, vsz, vis, maxvis, mmax, bp; + int i, j; + size_t vsz, vis, maxvis, mmax, bp; /* * First, establish the maximum columns of "visible" content. @@ -276,10 +439,10 @@ 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(' '); - 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. A space @@ -287,16 +450,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((u_char)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++; } @@ -311,7 +471,7 @@ flushln(struct termp *p) if ( ! (TERMP_NOBREAK & p->flags)) { if (vis && vis + vsz > bp) { putchar('\n'); - for (j = 0; j < p->offset; j++) + for (j = 0; j < (int)p->offset; j++) putchar(' '); vis = 0; } else if (vis + vsz > bp) @@ -322,7 +482,7 @@ flushln(struct termp *p) } else { if (vis && vis + vsz > bp) { putchar('\n'); - for (j = 0; j < p->rmargin; j++) + for (j = 0; j < (int)p->rmargin; j++) putchar(' '); vis = p->rmargin - p->offset; } else if (vis + vsz > bp) @@ -337,13 +497,13 @@ flushln(struct termp *p) * our breakpoint. */ - for ( ; i < p->col; i++) { - if (isspace((u_char)p->buf[i])) + for ( ; i < (int)p->col; i++) { + if (' ' == p->buf[i]) break; putchar(p->buf[i]); } vis += vsz; - if (i < p->col && vis <= bp) { + if (i < (int)p->col && vis <= bp) { putchar(' '); vis++; } @@ -357,7 +517,7 @@ flushln(struct termp *p) if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) { if ( ! (TERMP_NONOBREAK & p->flags)) { putchar('\n'); - for (i = 0; i < p->rmargin; i++) + for (i = 0; i < (int)p->rmargin; i++) putchar(' '); } p->col = 0; @@ -423,15 +583,15 @@ vspace(struct termp *p) void word(struct termp *p, const char *word) { - size_t i, j, len; + int i, j, len; 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)) @@ -441,14 +601,13 @@ word(struct termp *p, const char *word) /* LINTED */ for (j = i = 0; i < len; i++) { - if ( ! isspace((u_char)word[i])) { + if (' ' != word[i]) { j++; continue; } /* Escaped spaces don't delimit... */ - if (i > 0 && isspace((u_char)word[i]) && - '\\' == word[i - 1]) { + if (i && ' ' == word[i] && '\\' == word[i - 1]) { j++; continue; } @@ -578,7 +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; + char *buf, *title; p->rmargin = p->maxrmargin; p->offset = 0; @@ -613,9 +772,6 @@ header(struct termp *p, const struct mdoc_meta *meta) (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; @@ -655,27 +811,12 @@ 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: - warnx("unsupported %zu-byte escape sequence", len); + if (NULL == (rhs = a2ascii(p->symtab, word, len, &sz))) 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); } @@ -685,38 +826,33 @@ nescape(struct termp *p, const char *word, size_t len) * 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) +pescape(struct termp *p, const char *word, int *i, int len) { - size_t j; + int j; - if (++(*i) >= len) { - warnx("ignoring bad escape sequence"); + if (++(*i) >= len) return; - } if ('(' == word[*i]) { (*i)++; - if (*i + 1 >= len) { - warnx("ignoring bad escape sequence"); + if (*i + 1 >= len) return; - } + nescape(p, &word[*i], 2); (*i)++; return; } else if ('*' == word[*i]) { (*i)++; - if (*i >= len) { - warnx("ignoring bad escape sequence"); + if (*i >= len) return; - } + switch (word[*i]) { case ('('): (*i)++; - if (*i + 1 >= len) { - warnx("ignoring bad escape sequence"); + if (*i + 1 >= len) return; - } + nescape(p, &word[*i], 2); (*i)++; return; @@ -736,11 +872,10 @@ pescape(struct termp *p, const char *word, size_t *i, for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++) /* Loop... */ ; - if (0 == word[*i]) { - warnx("ignoring bad escape sequence"); + if (0 == word[*i]) return; - } - nescape(p, &word[*i - j], j); + + nescape(p, &word[*i - j], (size_t)j); } @@ -750,9 +885,9 @@ pescape(struct termp *p, const char *word, size_t *i, * handles word styling. */ static void -pword(struct termp *p, const char *word, size_t len) +pword(struct termp *p, const char *word, int len) { - size_t i; + int i; if ( ! (TERMP_NOSPACE & p->flags) && ! (TERMP_LITERAL & p->flags)) @@ -762,54 +897,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. @@ -822,17 +936,18 @@ stringa(struct termp *p, const char *c, size_t sz) if (0 == sz) return; - s = sz > p->maxcols * 2 ? sz : p->maxcols * 2; - 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[p->col], c, sz); + (void)memcpy(&p->buf[(int)p->col], c, sz); p->col += sz; } @@ -845,14 +960,18 @@ stringa(struct termp *p, const char *c, size_t sz) static void chara(struct termp *p, char c) { + size_t s; if (p->col + 1 >= p->maxcols) { - p->buf = realloc(p->buf, p->maxcols * 2); + if (0 == p->maxcols) + p->maxcols = 256; + s = p->maxcols * 2; + p->buf = realloc(p->buf, s); if (NULL == p->buf) - err(1, "malloc"); - p->maxcols *= 2; + err(1, "realloc"); + p->maxcols = s; } - p->buf[(p->col)++] = c; + p->buf[(int)(p->col)++] = c; } @@ -964,4 +1083,50 @@ sanity(const struct mdoc_node *n) 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); +} +