=================================================================== RCS file: /cvs/mandoc/term.c,v retrieving revision 1.79 retrieving revision 1.89 diff -u -p -r1.79 -r1.89 --- mandoc/term.c 2009/06/17 18:42:42 1.79 +++ mandoc/term.c 2009/07/16 13:17:51 1.89 @@ -1,4 +1,4 @@ -/* $Id: term.c,v 1.79 2009/06/17 18:42:42 kristaps Exp $ */ +/* $Id: term.c,v 1.89 2009/07/16 13:17:51 kristaps Exp $ */ /* * Copyright (c) 2008, 2009 Kristaps Dzonsons * @@ -31,15 +31,13 @@ extern int mdoc_run(struct termp *, static struct termp *term_alloc(enum termenc); static void term_free(struct termp *); -static void term_pword(struct termp *, const char *, int); -static void term_pescape(struct termp *, - const char *, int *, int); +static void term_pescape(struct termp *, const char **); static void term_nescape(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 *, int); -static int term_isclosedelim(const char *, int); +static int term_isopendelim(const char *); +static int term_isclosedelim(const char *); void * @@ -105,17 +103,17 @@ term_alloc(enum termenc enc) if (NULL == (p = malloc(sizeof(struct termp)))) err(1, "malloc"); bzero(p, sizeof(struct termp)); - p->maxrmargin = 80; + p->maxrmargin = 78; p->enc = enc; return(p); } static int -term_isclosedelim(const char *p, int len) +term_isclosedelim(const char *p) { - if (1 != len) + if ( ! (*p && 0 == *(p + 1))) return(0); switch (*p) { @@ -146,10 +144,10 @@ term_isclosedelim(const char *p, int len) static int -term_isopendelim(const char *p, int len) +term_isopendelim(const char *p) { - if (1 != len) + if ( ! (*p && 0 == *(p + 1))) return(0); switch (*p) { @@ -176,8 +174,7 @@ term_isopendelim(const char *p, int len) * 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: + * The usage of termp:flags is as 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 @@ -187,8 +184,13 @@ term_isopendelim(const char *p, int len) * 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. + * - TERMP_DANGLE: don't newline when TERMP_NOBREAK is specified and + * the line is overrun, and don't pad-right if it's underrun. * + * - TERMP_HANG: like TERMP_DANGLE, but doesn't newline when + * overruning, instead save the position and continue at that point + * when the next invocation. + * * In-line line breaking: * * If TERMP_NOBREAK is specified and the line overruns the right @@ -200,12 +202,16 @@ term_isopendelim(const char *p, int len) * 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! */ void term_flushln(struct termp *p) { int i, j; - size_t vsz, vis, maxvis, mmax, bp; + size_t vbl, vsz, vis, maxvis, mmax, bp; + static int sv = -1; /* * First, establish the maximum columns of "visible" content. @@ -220,6 +226,11 @@ term_flushln(struct termp *p) bp = TERMP_NOBREAK & p->flags ? mmax : maxvis; vis = 0; + if (sv >= 0) { + vis = (size_t)sv; + sv = -1; + } + /* * If in the standard case (left-justified), then begin with our * indentation, otherwise (columns, etc.) just start spitting @@ -241,44 +252,46 @@ term_flushln(struct termp *p) /* LINTED */ for (j = i, vsz = 0; j < (int)p->col; j++) { - if (' ' == p->buf[j]) + if (' ' == p->buf[j]) break; else if (8 == p->buf[j]) - j += 1; + vsz--; 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. + * Choose the number of blanks to prepend: no blank at the + * beginning of a line, one between words -- but do not + * actually write them yet. */ + vbl = (size_t)(0 == vis ? 0 : 1); - if ( ! (TERMP_NOBREAK & p->flags)) { - if (vis && vis + vsz > bp) { - putchar('\n'); + /* + * Find out whether we would exceed the right margin. + * If so, break to the next line. (TODO: hyphenate) + * Otherwise, write the chosen number of blanks now. + */ + if (vis && vis + vbl + vsz > bp) { + putchar('\n'); + if (TERMP_NOBREAK & p->flags) { + for (j = 0; j < (int)p->rmargin; j++) + putchar(' '); + vis = p->rmargin - p->offset; + } else { for (j = 0; j < (int)p->offset; j++) putchar(' '); vis = 0; - } - } else if (vis && vis + vsz > bp) { - putchar('\n'); - for (j = 0; j < (int)p->rmargin; j++) + } + } else { + for (j = 0; j < (int)vbl; j++) putchar(' '); - vis = p->rmargin - p->offset; + vis += vbl; } /* - * Prepend a space if we're not already at the beginning - * of the line, then the word. + * Finally, write out the word. */ - - if (0 < vis++) - putchar(' '); - for ( ; i < (int)p->col; i++) { if (' ' == p->buf[i]) break; @@ -292,12 +305,15 @@ term_flushln(struct termp *p) * cause a newline and offset at the right margin. */ - if ((TERMP_NOBREAK & p->flags) && vis > maxvis) { - if ( ! (TERMP_NONOBREAK & p->flags)) { + if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) { + if ( ! (TERMP_DANGLE & p->flags) && + ! (TERMP_HANG & p->flags)) { putchar('\n'); for (i = 0; i < (int)p->rmargin; i++) putchar(' '); } + if (TERMP_HANG & p->flags) + sv = (int)(vis - maxvis); p->col = 0; return; } @@ -308,8 +324,8 @@ term_flushln(struct termp *p) */ if (p->flags & TERMP_NOBREAK) { - if ( ! (TERMP_NONOBREAK & p->flags)) - for ( ; vis <= maxvis; vis++) + if ( ! (TERMP_DANGLE & p->flags)) + for ( ; vis < maxvis; vis++) putchar(' '); } else putchar('\n'); @@ -353,50 +369,6 @@ term_vspace(struct termp *p) /* - * 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 -term_word(struct termp *p, const char *word) -{ - int i, j, len; - - len = (int)strlen(word); - - if (p->flags & TERMP_LITERAL) { - term_pword(p, word, len); - return; - } - - /* LINTED */ - for (j = i = 0; i < len; 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); - term_pword(p, &word[i - j], j); - j = 0; - } - if (j > 0) { - assert(i >= j); - term_pword(p, &word[i - j], j); - } -} - - -/* * 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. @@ -408,7 +380,9 @@ term_nescape(struct termp *p, const char *word, size_t size_t sz; int i; - if ((rhs = term_a2ascii(p->symtab, word, len, &sz))) + rhs = term_a2ascii(p->symtab, word, len, &sz); + + if (rhs) for (i = 0; i < (int)sz; i++) term_encodea(p, rhs[i]); } @@ -420,48 +394,61 @@ term_nescape(struct termp *p, const char *word, size_t * the escape sequence (we assert upon badly-formed escape sequences). */ static void -term_pescape(struct termp *p, const char *word, int *i, int len) +term_pescape(struct termp *p, const char **word) { int j; + const char *wp; - if (++(*i) >= len) + wp = *word; + + if (0 == *(++wp)) { + *word = wp; return; + } - if ('(' == word[*i]) { - (*i)++; - if (*i + 1 >= len) + if ('(' == *wp) { + wp++; + if (0 == *wp || 0 == *(wp + 1)) { + *word = 0 == *wp ? wp : wp + 1; return; + } - term_nescape(p, &word[*i], 2); - (*i)++; + term_nescape(p, wp, 2); + *word = ++wp; return; - } else if ('*' == word[*i]) { - (*i)++; - if (*i >= len) + } else if ('*' == *wp) { + if (0 == *(++wp)) { + *word = wp; return; + } - switch (word[*i]) { + switch (*wp) { case ('('): - (*i)++; - if (*i + 1 >= len) + wp++; + if (0 == *wp || 0 == *(wp + 1)) { + *word = 0 == *wp ? wp : wp + 1; return; + } - term_nescape(p, &word[*i], 2); - (*i)++; + term_nescape(p, wp, 2); + *word = ++wp; return; case ('['): break; default: - term_nescape(p, &word[*i], 1); + term_nescape(p, wp, 1); + *word = wp; return; } - } else if ('f' == word[*i]) { - (*i)++; - if (*i >= len) + } else if ('f' == *wp) { + if (0 == *(++wp)) { + *word = wp; return; - switch (word[*i]) { + } + + switch (*wp) { case ('B'): p->flags |= TERMP_BOLD; break; @@ -476,21 +463,27 @@ term_pescape(struct termp *p, const char *word, int *i default: break; } + + *word = wp; return; - } else if ('[' != word[*i]) { - term_nescape(p, &word[*i], 1); + } else if ('[' != *wp) { + term_nescape(p, wp, 1); + *word = wp; return; } - (*i)++; - for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++) + wp++; + for (j = 0; *wp && ']' != *wp; wp++, j++) /* Loop... */ ; - if (0 == word[*i]) + if (0 == *wp) { + *word = wp; return; + } - term_nescape(p, &word[*i - j], (size_t)j); + term_nescape(p, wp - j, (size_t)j); + *word = wp; } @@ -499,12 +492,12 @@ term_pescape(struct termp *p, const char *word, int *i * phrase that cannot be broken down (such as a literal string). This * handles word styling. */ -static void -term_pword(struct termp *p, const char *word, int len) +void +term_word(struct termp *p, const char *word) { - int i; + const char *sv; - if (term_isclosedelim(word, len)) + if (term_isclosedelim(word)) if ( ! (TERMP_IGNDELIM & p->flags)) p->flags |= TERMP_NOSPACE; @@ -519,13 +512,13 @@ term_pword(struct termp *p, const char *word, int len) * before the word. */ - for (i = 0; i < len; i++) - if ('\\' == word[i]) - term_pescape(p, word, &i, len); + for (sv = word; *word; word++) + if ('\\' != *word) + term_encodea(p, *word); else - term_encodea(p, word[i]); + term_pescape(p, &word); - if (term_isopendelim(word, len)) + if (term_isopendelim(sv)) p->flags |= TERMP_NOSPACE; } @@ -556,8 +549,8 @@ term_chara(struct termp *p, char c) static void term_encodea(struct termp *p, char c) { - - if (TERMP_STYLE & p->flags) { + + if (' ' != c && TERMP_STYLE & p->flags) { if (TERMP_BOLD & p->flags) { term_chara(p, c); term_chara(p, 8);