=================================================================== RCS file: /cvs/mandoc/term.c,v retrieving revision 1.75 retrieving revision 1.85 diff -u -p -r1.75 -r1.85 --- mandoc/term.c 2009/06/10 20:18:44 1.75 +++ mandoc/term.c 2009/07/14 15:49:44 1.85 @@ -1,4 +1,4 @@ -/* $Id: term.c,v 1.75 2009/06/10 20:18:44 kristaps Exp $ */ +/* $Id: term.c,v 1.85 2009/07/14 15:49:44 kristaps Exp $ */ /* * Copyright (c) 2008, 2009 Kristaps Dzonsons * @@ -37,8 +37,7 @@ static void term_pescape(struct termp *, static void term_nescape(struct termp *, const char *, size_t); static void term_chara(struct termp *, char); -static void term_stringa(struct termp *, - const char *, size_t); +static void term_encodea(struct termp *, char); static int term_isopendelim(const char *, int); static int term_isclosedelim(const char *, int); @@ -177,8 +176,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 @@ -188,8 +186,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 @@ -201,12 +204,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. @@ -221,6 +228,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 @@ -251,43 +263,43 @@ term_flushln(struct termp *p) } /* - * 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; } - /* - * Write out the word and a trailing space. Omit the - * space if we're the last word in the line or beyond - * our breakpoint. + /* + * Finally, write out the word. */ - for ( ; i < (int)p->col; i++) { if (' ' == p->buf[i]) break; putchar(p->buf[i]); } vis += vsz; - if (i < (int)p->col && vis <= bp) { - putchar(' '); - vis++; - } } /* @@ -296,11 +308,14 @@ term_flushln(struct termp *p) */ if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) { - if ( ! (TERMP_NONOBREAK & p->flags)) { + 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; } @@ -311,7 +326,7 @@ term_flushln(struct termp *p) */ if (p->flags & TERMP_NOBREAK) { - if ( ! (TERMP_NONOBREAK & p->flags)) + if ( ! (TERMP_DANGLE & p->flags)) for ( ; vis < maxvis; vis++) putchar(' '); } else @@ -409,10 +424,12 @@ term_nescape(struct termp *p, const char *word, size_t { const char *rhs; size_t sz; + int i; - if (NULL == (rhs = term_a2ascii(p->symtab, word, len, &sz))) - return; - term_stringa(p, rhs, sz); + rhs = term_a2ascii(p->symtab, word, len, &sz); + if (rhs) + for (i = 0; i < (int)sz; i++) + term_encodea(p, rhs[i]); } @@ -521,61 +538,18 @@ term_pword(struct termp *p, const char *word, int len) * before the word. */ - for (i = 0; i < len; i++) { - if ('\\' == word[i]) { + for (i = 0; i < len; i++) + if ('\\' == word[i]) term_pescape(p, word, &i, len); - continue; - } + else + term_encodea(p, word[i]); - if (TERMP_STYLE & p->flags) { - if (TERMP_BOLD & p->flags) { - term_chara(p, word[i]); - term_chara(p, 8); - } - if (TERMP_UNDER & p->flags) { - term_chara(p, '_'); - term_chara(p, 8); - } - } - - term_chara(p, word[i]); - } - if (term_isopendelim(word, len)) p->flags |= TERMP_NOSPACE; } /* - * Like term_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 -term_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. @@ -597,3 +571,20 @@ term_chara(struct termp *p, char c) p->buf[(int)(p->col)++] = c; } + +static void +term_encodea(struct termp *p, char c) +{ + + if (TERMP_STYLE & p->flags) { + if (TERMP_BOLD & p->flags) { + term_chara(p, c); + term_chara(p, 8); + } + if (TERMP_UNDER & p->flags) { + term_chara(p, '_'); + term_chara(p, 8); + } + } + term_chara(p, c); +}