-/* $Id: term.c,v 1.88 2009/07/16 12:34:06 kristaps Exp $ */
+/* $Id: term.c,v 1.96 2009/07/27 13:10:08 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_pescape(struct termp *, const char **);
-static void term_nescape(struct termp *,
+
+static void do_escaped(struct termp *, const char **);
+static void do_special(struct termp *,
+ const char *, size_t);
+static void do_reserved(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 *);
-static int term_isclosedelim(const char *);
+static void buffer(struct termp *, char);
+static void encode(struct termp *, char);
+static int isopendelim(const char *);
+static int isclosedelim(const char *);
void *
static int
-term_isclosedelim(const char *p)
+isclosedelim(const char *p)
{
if ( ! (*p && 0 == *(p + 1)))
static int
-term_isopendelim(const char *p)
+isopendelim(const char *p)
{
if ( ! (*p && 0 == *(p + 1)))
* columns. In short: don't print a newline and instead pad to the
* right margin. Used in conjunction with TERMP_NOLPAD.
*
+ * - 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.
*
* 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 vbl, vsz, vis, maxvis, mmax, bp;
- static int sv = -1;
+ 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;
+ assert((int)(p->rmargin - p->offset) - overstep > 0);
+
+ maxvis = /* LINTED */
+ p->rmargin - p->offset - overstep;
+ mmax = /* LINTED */
+ p->maxrmargin - p->offset - overstep;
+
bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
vis = 0;
-
- if (sv >= 0) {
- vis = (size_t)sv;
- sv = -1;
- }
+ 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 (j && ' ' == p->buf[j])
break;
else if (8 == p->buf[j])
- j += 1;
+ vsz--;
else
vsz++;
}
}
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_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;
+ 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) {
+ /* We need one blank after the tag. */
+ overstep = /* LINTED */
+ vis - maxvis + 1;
- if (p->flags & TERMP_NOBREAK) {
- if ( ! (TERMP_DANGLE & p->flags))
- for ( ; vis < maxvis; vis++)
- putchar(' ');
- } else
- putchar('\n');
+ /*
+ * 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) {
+ assert((int)maxvis + overstep >= 0);
+ /* LINTED */
+ maxvis += overstep;
+ } else
+ overstep = 0;
+
+ } else if (TERMP_DANGLE & p->flags)
+ return;
- p->col = 0;
+ /* Right-pad. */
+ if (maxvis > vis + /* LINTED */
+ ((TERMP_TWOSPACE & p->flags) ? 1 : 0))
+ for ( ; vis < maxvis; vis++)
+ putchar(' ');
+ else { /* ...or newline break. */
+ putchar('\n');
+ for (i = 0; i < (int)p->rmargin; i++)
+ putchar(' ');
+ }
}
}
-/*
- * 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.
- */
static void
-term_nescape(struct termp *p, const char *word, size_t len)
+do_special(struct termp *p, const char *word, size_t len)
{
const char *rhs;
size_t sz;
rhs = term_a2ascii(p->symtab, word, len, &sz);
- if (rhs)
- for (i = 0; i < (int)sz; i++)
- term_encodea(p, rhs[i]);
+ if (NULL == rhs) {
+#if 1
+ fputs("Unknown special character: ", stderr);
+ for (i = 0; i < (int)len; i++)
+ fputc(word[i], stderr);
+ fputc('\n', stderr);
+#endif
+ return;
+ }
+ for (i = 0; i < (int)sz; i++)
+ encode(p, rhs[i]);
+}
+
+
+static void
+do_reserved(struct termp *p, const char *word, size_t len)
+{
+ const char *rhs;
+ size_t sz;
+ int i;
+
+ rhs = term_a2res(p->symtab, word, len, &sz);
+
+ if (NULL == rhs) {
+#if 0
+ fputs("Unknown reserved word: ", stderr);
+ for (i = 0; i < (int)len; i++)
+ fputc(word[i], stderr);
+ fputc('\n', stderr);
+#endif
+ return;
+ }
+ for (i = 0; i < (int)sz; i++)
+ encode(p, rhs[i]);
}
* the escape sequence (we assert upon badly-formed escape sequences).
*/
static void
-term_pescape(struct termp *p, const char **word)
+do_escaped(struct termp *p, const char **word)
{
int j;
const char *wp;
return;
}
- term_nescape(p, wp, 2);
+ do_special(p, wp, 2);
*word = ++wp;
return;
return;
}
- term_nescape(p, wp, 2);
+ do_reserved(p, wp, 2);
*word = ++wp;
return;
case ('['):
break;
default:
- term_nescape(p, wp, 1);
+ do_reserved(p, wp, 1);
*word = wp;
return;
}
return;
} else if ('[' != *wp) {
- term_nescape(p, wp, 1);
+ do_special(p, wp, 1);
*word = wp;
return;
}
return;
}
- term_nescape(p, wp - j, (size_t)j);
+ do_special(p, wp - j, (size_t)j);
*word = wp;
}
{
const char *sv;
- if (term_isclosedelim(word))
+ if (isclosedelim(word))
if ( ! (TERMP_IGNDELIM & p->flags))
p->flags |= TERMP_NOSPACE;
if ( ! (TERMP_NOSPACE & p->flags))
- term_chara(p, ' ');
+ buffer(p, ' ');
if ( ! (p->flags & TERMP_NONOSPACE))
p->flags &= ~TERMP_NOSPACE;
- /*
- * If ANSI (word-length styling), then apply our style now,
- * before the word.
- */
-
for (sv = word; *word; word++)
if ('\\' != *word)
- term_encodea(p, *word);
+ encode(p, *word);
else
- term_pescape(p, &word);
+ do_escaped(p, &word);
- if (term_isopendelim(sv))
+ if (isopendelim(sv))
p->flags |= TERMP_NOSPACE;
}
* size.
*/
static void
-term_chara(struct termp *p, char c)
+buffer(struct termp *p, char c)
{
size_t s;
static void
-term_encodea(struct termp *p, char c)
+encode(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);
+ buffer(p, c);
+ buffer(p, 8);
}
if (TERMP_UNDER & p->flags) {
- term_chara(p, '_');
- term_chara(p, 8);
+ buffer(p, '_');
+ buffer(p, 8);
}
}
- term_chara(p, c);
+ buffer(p, c);
}
git.ckatri.com / mandoc.git / blobdiff