-/* $Id: term.c,v 1.191 2011/05/15 22:29:50 kristaps Exp $ */
+/* $Id: term.c,v 1.201 2011/09/21 09:57:13 schwarze Exp $ */
/*
- * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
* Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
static void adjbuf(struct termp *p, int);
static void bufferc(struct termp *, char);
static void encode(struct termp *, const char *, size_t);
+static void encode1(struct termp *, int);
void
term_free(struct termp *p)
(*p->end)(p);
}
-
-struct termp *
-term_alloc(enum termenc enc)
-{
- struct termp *p;
-
- p = mandoc_calloc(1, sizeof(struct termp));
- p->enc = enc;
- return(p);
-}
-
-
/*
* Flush a line of text. A "line" is loosely defined as being something
* that should be followed by a newline, regardless of whether it's
*
* The following flags may be specified:
*
- * - TERMP_NOLPAD: when beginning to write the line, don't left-pad the
- * offset value. This is useful when doing columnar lists where the
- * prior column has right-padded.
- *
* - TERMP_NOBREAK: this is the most important and is used when making
- * columns. In short: don't print a newline and instead pad to the
- * right margin. Used in conjunction with TERMP_NOLPAD.
+ * columns. In short: don't print a newline and instead expect the
+ * next call to do the padding up to the start of the next column.
*
- * - TERMP_TWOSPACE: when padding, make sure there are at least two
- * space characters of padding. Otherwise, rather break the line.
+ * - TERMP_TWOSPACE: make sure there is room for 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
+ * overrunning, instead save the position and continue at that point
* when the next invocation.
*
* In-line line breaking:
bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
/*
- * Indent the first line of a paragraph.
+ * Calculate the required amount of padding.
*/
- vbl = p->flags & TERMP_NOLPAD ? (size_t)0 : p->offset;
+ vbl = p->offset + p->overstep > p->viscol ?
+ p->offset + p->overstep - p->viscol : 0;
vis = vend = 0;
i = 0;
if (vend > bp && 0 == jhy && vis > 0) {
vend -= vis;
(*p->endline)(p);
+ p->viscol = 0;
if (TERMP_NOBREAK & p->flags) {
- p->viscol = p->rmargin;
- (*p->advance)(p, p->rmargin);
+ vbl = p->rmargin;
vend += p->rmargin - p->offset;
- } else {
- p->viscol = 0;
+ } else
vbl = p->offset;
- }
/* Remove the p->overstep width. */
if (ASCII_HYPH == p->buf[i]) {
(*p->letter)(p, '-');
p->viscol += (*p->width)(p, '-');
- } else {
- (*p->letter)(p, p->buf[i]);
- p->viscol += (*p->width)(p, p->buf[i]);
+ continue;
}
+
+ (*p->letter)(p, p->buf[i]);
+ if (8 == p->buf[i])
+ p->viscol -= (*p->width)(p, p->buf[i-1]);
+ else
+ p->viscol += (*p->width)(p, p->buf[i]);
}
vis = vend;
}
* If there was trailing white space, it was not printed;
* so reset the cursor position accordingly.
*/
- vis -= vbl;
+ if (vis)
+ vis -= vbl;
p->col = 0;
p->overstep = 0;
* move it one step LEFT and flag the rest of the line
* to be longer.
*/
- if (p->overstep >= -1) {
- assert((int)maxvis + p->overstep >= 0);
- maxvis += (size_t)p->overstep;
- } else
+ if (p->overstep < -1)
p->overstep = 0;
+ return;
} else if (TERMP_DANGLE & p->flags)
return;
- /* Right-pad. */
- if (maxvis > vis +
+ /* If the column was overrun, break the line. */
+ if (maxvis <= vis +
((TERMP_TWOSPACE & p->flags) ? (*p->width)(p, ' ') : 0)) {
- p->viscol += maxvis - vis;
- (*p->advance)(p, maxvis - vis);
- vis += (maxvis - vis);
- } else { /* ...or newline break. */
(*p->endline)(p);
- p->viscol = p->rmargin;
- (*p->advance)(p, p->rmargin);
+ p->viscol = 0;
}
}
{
p->flags |= TERMP_NOSPACE;
- if (0 == p->col && 0 == p->viscol) {
- p->flags &= ~TERMP_NOLPAD;
- return;
- }
- term_flushln(p);
- p->flags &= ~TERMP_NOLPAD;
+ if (p->col || p->viscol)
+ term_flushln(p);
}
{
const char *seq, *cp;
char c;
- int sz;
+ int sz, uc;
size_t ssz;
enum mandoc_esc esc;
if (ESCAPE_ERROR == esc)
break;
+ if (TERMENC_ASCII != p->enc)
+ switch (esc) {
+ case (ESCAPE_UNICODE):
+ uc = mchars_num2uc(seq + 1, sz - 1);
+ if ('\0' == uc)
+ break;
+ encode1(p, uc);
+ continue;
+ case (ESCAPE_SPECIAL):
+ uc = mchars_spec2cp(p->symtab, seq, sz);
+ if (uc <= 0)
+ break;
+ encode1(p, uc);
+ continue;
+ default:
+ break;
+ }
+
switch (esc) {
+ case (ESCAPE_UNICODE):
+ encode1(p, '?');
+ break;
case (ESCAPE_NUMBERED):
- if ('\0' != (c = mchars_num2char(seq, sz)))
+ c = mchars_num2char(seq, sz);
+ if ('\0' != c)
encode(p, &c, 1);
break;
- case (ESCAPE_PREDEF):
- cp = mchars_res2str(p->symtab, seq, sz, &ssz);
- if (NULL != cp)
- encode(p, cp, ssz);
- break;
case (ESCAPE_SPECIAL):
cp = mchars_spec2str(p->symtab, seq, sz, &ssz);
if (NULL != cp)
case (ESCAPE_FONTITALIC):
term_fontrepl(p, TERMFONT_UNDER);
break;
+ case (ESCAPE_FONT):
+ /* FALLTHROUGH */
case (ESCAPE_FONTROMAN):
term_fontrepl(p, TERMFONT_NONE);
break;
p->buf[p->col++] = c;
}
+/*
+ * See encode().
+ * Do this for a single (probably unicode) value.
+ * Does not check for non-decorated glyphs.
+ */
+static void
+encode1(struct termp *p, int c)
+{
+ enum termfont f;
+
+ if (p->col + 4 >= p->maxcols)
+ adjbuf(p, p->col + 4);
+
+ f = term_fonttop(p);
+
+ if (TERMFONT_NONE == f) {
+ p->buf[p->col++] = c;
+ return;
+ } else if (TERMFONT_UNDER == f) {
+ p->buf[p->col++] = '_';
+ } else
+ p->buf[p->col++] = c;
+
+ p->buf[p->col++] = 8;
+ p->buf[p->col++] = c;
+}
+
static void
encode(struct termp *p, const char *word, size_t sz)
{
adjbuf(p, p->col + 1 + (len * 3));
for (i = 0; i < len; i++) {
- if ( ! isgraph((unsigned char)word[i])) {
+ if (ASCII_HYPH != word[i] &&
+ ! isgraph((unsigned char)word[i])) {
p->buf[p->col++] = word[i];
continue;
}
if (TERMFONT_UNDER == f)
p->buf[p->col++] = '_';
+ else if (ASCII_HYPH == word[i])
+ p->buf[p->col++] = '-';
else
p->buf[p->col++] = word[i];
size_t sz, rsz, i;
int ssz, c;
const char *seq, *rhs;
+ enum mandoc_esc esc;
static const char rej[] = { '\\', ASCII_HYPH, ASCII_NBRSP, '\0' };
/*
for (i = 0; i < rsz; i++)
sz += (*p->width)(p, *cp++);
+ c = 0;
switch (*cp) {
case ('\\'):
cp++;
- rhs = NULL;
- switch (mandoc_escape(&cp, &seq, &ssz)) {
- case (ESCAPE_ERROR):
+ esc = mandoc_escape(&cp, &seq, &ssz);
+ if (ESCAPE_ERROR == esc)
return(sz);
+
+ if (TERMENC_ASCII != p->enc)
+ switch (esc) {
+ case (ESCAPE_UNICODE):
+ c = mchars_num2uc
+ (seq + 1, ssz - 1);
+ if ('\0' == c)
+ break;
+ sz += (*p->width)(p, c);
+ continue;
+ case (ESCAPE_SPECIAL):
+ c = mchars_spec2cp
+ (p->symtab, seq, ssz);
+ if (c <= 0)
+ break;
+ sz += (*p->width)(p, c);
+ continue;
+ default:
+ break;
+ }
+
+ rhs = NULL;
+
+ switch (esc) {
+ case (ESCAPE_UNICODE):
+ sz += (*p->width)(p, '?');
+ break;
case (ESCAPE_NUMBERED):
c = mchars_num2char(seq, ssz);
if ('\0' != c)
sz += (*p->width)(p, c);
break;
- case (ESCAPE_PREDEF):
- rhs = mchars_res2str
- (p->symtab, seq, ssz, &rsz);
- break;
case (ESCAPE_SPECIAL):
rhs = mchars_spec2str
(p->symtab, seq, ssz, &rsz);
git.ckatri.com / mandoc.git / blobdiff