-/* $Id: term.c,v 1.71 2009/03/31 13:50:19 kristaps Exp $ */
+/* $Id: term.c,v 1.96 2009/07/27 13:10:08 kristaps Exp $ */
/*
- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
+ * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
*
* Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
*
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <assert.h>
#include <err.h>
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_nescape(struct termp *,
+
+static void do_escaped(struct termp *, const char **);
+static void do_special(struct termp *,
const char *, size_t);
-static void term_chara(struct termp *, char);
-static void term_stringa(struct termp *,
+static void do_reserved(struct termp *,
const char *, size_t);
-static int term_isopendelim(const char *, int);
-static int term_isclosedelim(const char *, int);
+static void buffer(struct termp *, char);
+static void encode(struct termp *, char);
+static int isopendelim(const char *);
+static int isclosedelim(const char *);
void *
int
-terminal_run(void *arg, const struct man *man,
- const struct mdoc *mdoc)
+terminal_man(void *arg, const struct man *man)
{
struct termp *p;
p = (struct termp *)arg;
-
if (NULL == p->symtab)
p->symtab = term_ascii2htab();
- if (man)
- return(man_run(p, man));
- if (mdoc)
- return(mdoc_run(p, mdoc));
+ return(man_run(p, man));
+}
+
+
+int
+terminal_mdoc(void *arg, const struct mdoc *mdoc)
+{
+ struct termp *p;
- return(1);
+ p = (struct termp *)arg;
+ if (NULL == p->symtab)
+ p->symtab = term_ascii2htab();
+
+ return(mdoc_run(p, mdoc));
}
static int
-term_isclosedelim(const char *p, int len)
+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)
+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:
*
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;
+ 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;
+ 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++;
}
/*
- * 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++;
- }
}
+ 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) {
+ /* We need one blank after the tag. */
+ overstep = /* LINTED */
+ vis - maxvis + 1;
- if (p->flags & TERMP_NOBREAK) {
- if ( ! (TERMP_NONOBREAK & 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(' ');
+ }
}
}
-/*
- * 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)
+static void
+do_special(struct termp *p, const char *word, size_t len)
{
- int i, j, len;
+ const char *rhs;
+ size_t sz;
+ int i;
- len = (int)strlen(word);
+ rhs = term_a2ascii(p->symtab, word, len, &sz);
- if (p->flags & TERMP_LITERAL) {
- term_pword(p, word, len);
+ 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;
}
-
- /* 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);
- }
+ for (i = 0; i < (int)sz; i++)
+ encode(p, rhs[i]);
}
-/*
- * 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_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 = term_a2ascii(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;
- term_stringa(p, rhs, sz);
+ }
+ 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, int *i, int len)
+do_escaped(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)++;
+ do_special(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)++;
+ do_reserved(p, wp, 2);
+ *word = ++wp;
return;
case ('['):
break;
default:
- term_nescape(p, &word[*i], 1);
+ do_reserved(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) {
+ do_special(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);
+ do_special(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 (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 (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]);
- }
+ for (sv = word; *word; word++)
+ if ('\\' != *word)
+ encode(p, *word);
+ else
+ do_escaped(p, &word);
- if (term_isopendelim(word, len))
+ if (isopendelim(sv))
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.
*/
static void
-term_chara(struct termp *p, char c)
+buffer(struct termp *p, char c)
{
size_t s;
p->buf[(int)(p->col)++] = c;
}
+
+static void
+encode(struct termp *p, char c)
+{
+
+ if (' ' != c && TERMP_STYLE & p->flags) {
+ if (TERMP_BOLD & p->flags) {
+ buffer(p, c);
+ buffer(p, 8);
+ }
+ if (TERMP_UNDER & p->flags) {
+ buffer(p, '_');
+ buffer(p, 8);
+ }
+ }
+ buffer(p, c);
+}
git.ckatri.com / mandoc.git / blobdiff