=================================================================== RCS file: /cvs/mandoc/term.c,v retrieving revision 1.78 retrieving revision 1.85 diff -u -p -r1.78 -r1.85 --- mandoc/term.c 2009/06/11 10:34:32 1.78 +++ mandoc/term.c 2009/07/14 15:49:44 1.85 @@ -1,4 +1,4 @@ -/* $Id: term.c,v 1.78 2009/06/11 10:34:32 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); @@ -106,7 +105,7 @@ 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); } @@ -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,35 +263,37 @@ 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; } /* - * 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; @@ -293,12 +307,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; } @@ -309,8 +326,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'); @@ -407,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]); } @@ -519,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. @@ -595,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); +}