-/* $Id: term.c,v 1.79 2009/06/17 18:42:42 kristaps Exp $ */
+/* $Id: term.c,v 1.91 2009/07/21 13:34:13 kristaps Exp $ */
/*
* Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
*
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 *
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) {
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) {
* 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_TWOSPACE: when padding, make sure there are at least two
+ * space characters of padding. Otherwise, rather break the line.
+ *
+ * - 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 (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)
{
int i, j;
- size_t vsz, vis, maxvis, mmax, bp;
+ size_t vbl, vsz, vis, maxvis, mmax, bp;
+ static int overstep = 0;
/*
* First, establish the maximum columns of "visible" content.
*/
assert(p->offset < p->rmargin);
- maxvis = p->rmargin - p->offset;
- mmax = p->maxrmargin - p->offset;
+ maxvis = p->rmargin - p->offset - overstep;
+ mmax = p->maxrmargin - p->offset - overstep;
bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
vis = 0;
+ overstep = 0;
/*
* If in the standard case (left-justified), then begin with our
/* 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;
}
vis += vsz;
}
+ p->col = 0;
- /*
- * If we've overstepped our maximum visible no-break space, then
- * cause a newline and offset at the right margin.
- */
-
- if ((TERMP_NOBREAK & p->flags) && vis > maxvis) {
- if ( ! (TERMP_NONOBREAK & p->flags)) {
- putchar('\n');
- for (i = 0; i < (int)p->rmargin; i++)
- putchar(' ');
- }
- p->col = 0;
+ if ( ! (TERMP_NOBREAK & p->flags)) {
+ putchar('\n');
return;
}
- /*
- * If we're not to right-marginalise it (newline), then instead
- * pad to the right margin and stay off.
- */
+ if (TERMP_HANG & p->flags) {
- if (p->flags & TERMP_NOBREAK) {
- if ( ! (TERMP_NONOBREAK & p->flags))
- for ( ; vis <= maxvis; vis++)
- putchar(' ');
- } else
- putchar('\n');
+ /* We need one blank after the tag. */
+ overstep = vis - maxvis + 1;
- p->col = 0;
+ /*
+ * 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 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 (overstep >= -1)
+ maxvis += overstep;
+ else
+ overstep = 0;
+
+ } else if (TERMP_DANGLE & p->flags)
+ return;
+
+ if (maxvis > vis + ((TERMP_TWOSPACE & p->flags) ? 1 : 0)) /* pad */
+ for ( ; vis < maxvis; vis++)
+ putchar(' ');
+ else { /* break */
+ putchar('\n');
+ for (i = 0; i < (int)p->rmargin; i++)
+ putchar(' ');
+ }
}
}
-/*
- * 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
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]);
}
* 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;
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;
}
* 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;
* 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;
}
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);
git.ckatri.com / mandoc.git / blobdiff