-/* $Id: term.c,v 1.75 2009/06/10 20:18:44 kristaps Exp $ */
+/* $Id: term.c,v 1.84 2009/07/14 15:16:41 kristaps Exp $ */
/*
* Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
*
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);
* 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
* 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:
*
* 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.
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
}
/*
- * 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++;
- }
}
/*
*/
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 = vis - maxvis;
p->col = 0;
return;
}
*/
if (p->flags & TERMP_NOBREAK) {
- if ( ! (TERMP_NONOBREAK & p->flags))
+ if ( ! (TERMP_DANGLE & p->flags))
for ( ; vis < maxvis; vis++)
putchar(' ');
} else
{
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]);
}
* 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;
- }
-
- 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]);
- }
+ else
+ term_encodea(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
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);
+}
git.ckatri.com / mandoc.git / blobdiff