=================================================================== RCS file: /cvs/mandoc/term.c,v retrieving revision 1.91 retrieving revision 1.98 diff -u -p -r1.91 -r1.98 --- mandoc/term.c 2009/07/21 13:34:13 1.91 +++ mandoc/term.c 2009/09/15 08:16:20 1.98 @@ -1,4 +1,4 @@ -/* $Id: term.c,v 1.91 2009/07/21 13:34:13 kristaps Exp $ */ +/* $Id: term.c,v 1.98 2009/09/15 08:16:20 kristaps Exp $ */ /* * Copyright (c) 2008, 2009 Kristaps Dzonsons * @@ -31,13 +31,16 @@ extern int mdoc_run(struct termp *, static struct termp *term_alloc(enum termenc); static void term_free(struct termp *); -static void term_pescape(struct termp *, const char **); -static void term_nescape(struct termp *, + +static void do_escaped(struct termp *, const char **); +static void do_special(struct termp *, const char *, size_t); -static void term_chara(struct termp *, char); -static void term_encodea(struct termp *, char); -static int term_isopendelim(const char *); -static int term_isclosedelim(const char *); +static void do_reserved(struct termp *, + const char *, size_t); +static void buffer(struct termp *, char); +static void encode(struct termp *, char); +static int isopendelim(const char *); +static int isclosedelim(const char *); void * @@ -101,7 +104,7 @@ term_alloc(enum termenc enc) struct termp *p; if (NULL == (p = malloc(sizeof(struct termp)))) - err(1, "malloc"); + return(NULL); bzero(p, sizeof(struct termp)); p->maxrmargin = 78; p->enc = enc; @@ -110,7 +113,7 @@ term_alloc(enum termenc enc) static int -term_isclosedelim(const char *p) +isclosedelim(const char *p) { if ( ! (*p && 0 == *(p + 1))) @@ -144,7 +147,7 @@ term_isclosedelim(const char *p) static int -term_isopendelim(const char *p) +isopendelim(const char *p) { if ( ! (*p && 0 == *(p + 1))) @@ -205,12 +208,6 @@ term_isopendelim(const char *p) * Otherwise, the line will break at the right margin. Extremely long * lines will cause the system to emit a warning (TODO: hyphenate, if * possible). - * - * FIXME: newline breaks occur (in groff) also occur when a single - * space follows a NOBREAK (try `Bl -tag') - * - * FIXME: there's a newline error where a `Bl -diag' will have a - * trailing newline if the line is exactly 73 chars long. */ void term_flushln(struct termp *p) @@ -227,8 +224,13 @@ term_flushln(struct termp *p) */ assert(p->offset < p->rmargin); - maxvis = p->rmargin - p->offset - overstep; - mmax = p->maxrmargin - p->offset - overstep; + assert((int)(p->rmargin - p->offset) - overstep > 0); + + maxvis = /* LINTED */ + p->rmargin - p->offset - overstep; + mmax = /* LINTED */ + p->maxrmargin - p->offset - overstep; + bp = TERMP_NOBREAK & p->flags ? mmax : maxvis; vis = 0; overstep = 0; @@ -254,7 +256,7 @@ term_flushln(struct termp *p) /* LINTED */ for (j = i, vsz = 0; j < (int)p->col; j++) { - if (' ' == p->buf[j]) + if (j && ' ' == p->buf[j]) break; else if (8 == p->buf[j]) vsz--; @@ -309,30 +311,36 @@ term_flushln(struct termp *p) } if (TERMP_HANG & p->flags) { - /* We need one blank after the tag. */ - overstep = vis - maxvis + 1; + overstep = /* LINTED */ + vis - maxvis + 1; /* * Behave exactly the same way as groff: - * If we have overstepped the margin, temporarily move it - * to the right and flag the rest of the line to be shorter. + * If we have overstepped the margin, temporarily move + * it to the right and flag the rest of the line to be + * shorter. * If we landed right at the margin, be happy. - * If we are one step before the margin, temporarily move it - * one step LEFT and flag the rest of the line to be longer. + * If we are one step before the margin, temporarily + * move it one step LEFT and flag the rest of the line + * to be longer. */ - if (overstep >= -1) + if (overstep >= -1) { + assert((int)maxvis + overstep >= 0); + /* LINTED */ maxvis += overstep; - else + } else overstep = 0; } else if (TERMP_DANGLE & p->flags) return; - if (maxvis > vis + ((TERMP_TWOSPACE & p->flags) ? 1 : 0)) /* pad */ + /* Right-pad. */ + if (maxvis > vis + /* LINTED */ + ((TERMP_TWOSPACE & p->flags) ? 1 : 0)) for ( ; vis < maxvis; vis++) putchar(' '); - else { /* break */ + else { /* ...or newline break. */ putchar('\n'); for (i = 0; i < (int)p->rmargin; i++) putchar(' '); @@ -374,13 +382,8 @@ term_vspace(struct termp *p) } -/* - * 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 -term_nescape(struct termp *p, const char *word, size_t len) +do_special(struct termp *p, const char *word, size_t len) { const char *rhs; size_t sz; @@ -388,24 +391,56 @@ term_nescape(struct termp *p, const char *word, size_t rhs = term_a2ascii(p->symtab, word, len, &sz); - if (rhs) - for (i = 0; i < (int)sz; i++) - term_encodea(p, rhs[i]); + if (NULL == rhs) { +#if 0 + fputs("Unknown special character: ", stderr); + for (i = 0; i < (int)len; i++) + fputc(word[i], stderr); + fputc('\n', stderr); +#endif + return; + } + for (i = 0; i < (int)sz; i++) + encode(p, rhs[i]); } +static void +do_reserved(struct termp *p, const char *word, size_t len) +{ + const char *rhs; + size_t sz; + int i; + + rhs = term_a2res(p->symtab, word, len, &sz); + + if (NULL == rhs) { +#if 0 + fputs("Unknown reserved word: ", stderr); + for (i = 0; i < (int)len; i++) + fputc(word[i], stderr); + fputc('\n', stderr); +#endif + return; + } + for (i = 0; i < (int)sz; i++) + encode(p, rhs[i]); +} + + /* * 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 -term_pescape(struct termp *p, const char **word) +do_escaped(struct termp *p, const char **word) { - int j; + int j, type; const char *wp; wp = *word; + type = 1; if (0 == *(++wp)) { *word = wp; @@ -419,7 +454,7 @@ term_pescape(struct termp *p, const char **word) return; } - term_nescape(p, wp, 2); + do_special(p, wp, 2); *word = ++wp; return; @@ -437,13 +472,14 @@ term_pescape(struct termp *p, const char **word) return; } - term_nescape(p, wp, 2); + do_reserved(p, wp, 2); *word = ++wp; return; case ('['): + type = 0; break; default: - term_nescape(p, wp, 1); + do_reserved(p, wp, 1); *word = wp; return; } @@ -456,15 +492,15 @@ term_pescape(struct termp *p, const char **word) switch (*wp) { case ('B'): - p->flags |= TERMP_BOLD; + p->bold++; break; case ('I'): - p->flags |= TERMP_UNDER; + p->under++; break; case ('P'): /* FALLTHROUGH */ case ('R'): - p->flags &= ~TERMP_STYLE; + p->bold = p->under = 0; break; default: break; @@ -474,7 +510,7 @@ term_pescape(struct termp *p, const char **word) return; } else if ('[' != *wp) { - term_nescape(p, wp, 1); + do_special(p, wp, 1); *word = wp; return; } @@ -488,7 +524,10 @@ term_pescape(struct termp *p, const char **word) return; } - term_nescape(p, wp - j, (size_t)j); + if (type) + do_special(p, wp - j, (size_t)j); + else + do_reserved(p, wp - j, (size_t)j); *word = wp; } @@ -503,28 +542,23 @@ term_word(struct termp *p, const char *word) { const char *sv; - if (term_isclosedelim(word)) + if (isclosedelim(word)) if ( ! (TERMP_IGNDELIM & p->flags)) p->flags |= TERMP_NOSPACE; if ( ! (TERMP_NOSPACE & p->flags)) - term_chara(p, ' '); + buffer(p, ' '); if ( ! (p->flags & TERMP_NONOSPACE)) p->flags &= ~TERMP_NOSPACE; - /* - * If ANSI (word-length styling), then apply our style now, - * before the word. - */ - for (sv = word; *word; word++) if ('\\' != *word) - term_encodea(p, *word); + encode(p, *word); else - term_pescape(p, &word); + do_escaped(p, &word); - if (term_isopendelim(sv)) + if (isopendelim(sv)) p->flags |= TERMP_NOSPACE; } @@ -535,7 +569,7 @@ term_word(struct termp *p, const char *word) * size. */ static void -term_chara(struct termp *p, char c) +buffer(struct termp *p, char c) { size_t s; @@ -545,7 +579,7 @@ term_chara(struct termp *p, char c) s = p->maxcols * 2; p->buf = realloc(p->buf, s); if (NULL == p->buf) - err(1, "realloc"); + err(1, "realloc"); /* FIXME: shouldn't be here! */ p->maxcols = s; } p->buf[(int)(p->col)++] = c; @@ -553,18 +587,18 @@ term_chara(struct termp *p, char c) static void -term_encodea(struct termp *p, char c) +encode(struct termp *p, char c) { - if (' ' != c && TERMP_STYLE & p->flags) { - if (TERMP_BOLD & p->flags) { - term_chara(p, c); - term_chara(p, 8); + if (' ' != c) { + if (p->bold) { + buffer(p, c); + buffer(p, 8); } - if (TERMP_UNDER & p->flags) { - term_chara(p, '_'); - term_chara(p, 8); + if (p->under) { + buffer(p, '_'); + buffer(p, 8); } } - term_chara(p, c); + buffer(p, c); }