mandoc/term.c - diff

Return to term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/term.c between version 1.76 and 1.94

version 1.76, 2009/06/11 07:26:35

version 1.94, 2009/07/27 12:02:49

Line 31 extern int mdoc_run(struct termp *,

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 **);

static void term_pescape(struct termp *,

const char *, int *, int);

static void term_nescape(struct termp *,

const char *, size_t);

static void term_chara(struct termp *, char);

static void term_sescape(struct termp *,

static void term_stringa(struct termp *,

const char *, size_t);

static int term_isopendelim(const char *, int);

static void term_chara(struct termp *, char);

static int term_isclosedelim(const char *, int);

static void term_encodea(struct termp *, char);

static int term_isopendelim(const char *);

static int term_isclosedelim(const char *);

void *

Line 106 term_alloc(enum termenc enc)

Line 105 term_alloc(enum termenc enc)

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) {

Line 147 term_isclosedelim(const char *p, int len)

Line 146 term_isclosedelim(const char *p, int len)

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) {

Line 177 term_isopendelim(const char *p, int len)

Line 176 term_isopendelim(const char *p, int len)

* 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

* The usage of termp:flags is as follows:

* critical importance here. Their behaviour 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

Line 188 term_isopendelim(const char *p, int len)

Line 186 term_isopendelim(const char *p, int len)

* 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:

* If TERMP_NOBREAK is specified and the line overruns the right

Line 201 term_isopendelim(const char *p, int len)

Line 207 term_isopendelim(const char *p, int len)

* 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.

Line 216 term_flushln(struct termp *p)

Line 229 term_flushln(struct termp *p)

assert(p->offset < p->rmargin);

maxvis = p->rmargin - p->offset;

assert((int)(p->rmargin - p->offset) - overstep > 0);

mmax = p->maxrmargin - p->offset;

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

Line 242 term_flushln(struct termp *p)

Line 261 term_flushln(struct termp *p)

/* 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

* Choose the number of blanks to prepend: no blank at the

* break-point and already in-line, break to the next

* beginning of a line, one between words -- but do not

* line and start writing. If we're at the line start,

* actually write them yet.

* then write out the word (TODO: hyphenate) and break

* in a subsequent loop invocation.

vbl = (size_t)(0 == vis ? 0 : 1);

if ( ! (TERMP_NOBREAK & p->flags)) {

if (vis && vis + vsz > bp) {

* Find out whether we would exceed the right margin.

putchar('\n');

* 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) {

} else {

putchar('\n');

for (j = 0; j < (int)vbl; j++)

for (j = 0; j < (int)p->rmargin; j++)

putchar(' ');

vis = p->rmargin - p->offset;

vis += vbl;

}

* Write out the word and a trailing space. Omit the

* Finally, write out the word.

* space if we're the last word in the line or beyond

* our breakpoint.

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 ( ! (TERMP_NOBREAK & p->flags)) {

* If we've overstepped our maximum visible no-break space, then

putchar('\n');

* 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;

return;

}

if (TERMP_HANG & p->flags) {

* If we're not to right-marginalise it (newline), then instead

/* We need one blank after the tag. */

* pad to the right margin and stay off.

overstep = /* LINTED */

vis - maxvis + 1;

if (p->flags & TERMP_NOBREAK) {

if ( ! (TERMP_NONOBREAK & p->flags))

* Behave exactly the same way as groff:

for ( ; vis < maxvis; vis++)

* If we have overstepped the margin, temporarily move

putchar(' ');

* it to the right and flag the rest of the line to be

} else

* shorter.

putchar('\n');

* 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;

p->col = 0;

} else if (TERMP_DANGLE & p->flags)

return;

/* 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(' ');

}

Line 356 term_vspace(struct termp *p)

Line 388 term_vspace(struct termp *p)

* Break apart a word into "pwords" (partial-words, usually from

* Determine the symbol indicated by an escape sequences, that is, one

* breaking up a phrase into individual words) and, eventually, put them

* starting with a backslash. Once done, we pass this value into the

* into the output buffer. If we're a literal word, then don't break up

* output buffer by way of the symbol table.

* the word and put it verbatim into the output buffer.

void

static void

term_word(struct termp *p, const char *word)

term_nescape(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) {

if (NULL == rhs)

term_pword(p, word, len);

return;

}

for (i = 0; i < (int)sz; i++)

term_encodea(p, rhs[i]);

/* 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

* output buffer by way of the symbol table.

static void

term_nescape(struct termp *p, const char *word, size_t len)

term_sescape(struct termp *p, const char *word, size_t len)

{

const char *rhs;

size_t sz;

int i;

if (NULL == (rhs = term_a2ascii(p->symtab, word, len, &sz)))

rhs = term_a2res(p->symtab, word, len, &sz);

if (NULL == rhs)

return;

term_stringa(p, rhs, sz);

for (i = 0; i < (int)sz; i++)

term_encodea(p, rhs[i]);

}

Line 422 term_nescape(struct termp *p, const char *word, size_t

Line 430 term_nescape(struct termp *p, const char *word, size_t

* 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]) {

if ('(' == *wp) {

(*i)++;

wp++;

if (*i + 1 >= len)

if (0 == *wp || 0 == *(wp + 1)) {

*word = 0 == *wp ? wp : wp + 1;

return;

}

term_nescape(p, &word[*i], 2);

term_nescape(p, wp, 2);

(*i)++;

*word = ++wp;

return;

} else if ('*' == word[*i]) {

} else if ('*' == *wp) {

(*i)++;

if (0 == *(++wp)) {

if (*i >= len)

*word = wp;

return;

}

switch (word[*i]) {

switch (*wp) {

case ('('):

(*i)++;

wp++;

if (*i + 1 >= len)

if (0 == *wp || 0 == *(wp + 1)) {

*word = 0 == *wp ? wp : wp + 1;

return;

}

term_nescape(p, &word[*i], 2);

term_sescape(p, wp, 2);

(*i)++;

*word = ++wp;

return;

case ('['):

break;

default:

term_nescape(p, &word[*i], 1);

term_sescape(p, wp, 1);

*word = wp;

return;

}

} else if ('f' == word[*i]) {

} else if ('f' == *wp) {

(*i)++;

if (0 == *(++wp)) {

if (*i >= len)

*word = wp;

return;

switch (word[*i]) {

}

switch (*wp) {

case ('B'):

p->flags |= TERMP_BOLD;

break;

Line 478 term_pescape(struct termp *p, const char *word, int *i

Line 499 term_pescape(struct termp *p, const char *word, int *i

default:

break;

}

*word = wp;

return;

} else if ('[' != word[*i]) {

} else if ('[' != *wp) {

term_nescape(p, &word[*i], 1);

term_nescape(p, wp, 1);

*word = wp;

return;

}

(*i)++;

wp++;

for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)

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;

}

Line 501 term_pescape(struct termp *p, const char *word, int *i

Line 528 term_pescape(struct termp *p, const char *word, int *i

* phrase that cannot be broken down (such as a literal string). This

* handles word styling.

static void

void

term_pword(struct termp *p, const char *word, int len)

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;

Line 521 term_pword(struct termp *p, const char *word, int len)

Line 548 term_pword(struct termp *p, const char *word, int len)

* before the word.

for (i = 0; i < len; i++) {

for (sv = word; *word; word++)

if ('\\' == word[i]) {

if ('\\' != *word)

term_pescape(p, word, &i, len);

term_encodea(p, *word);

continue;

else

}

term_pescape(p, &word);

if (TERMP_STYLE & p->flags) {

if (term_isopendelim(sv))

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]);

}

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

* size.

Line 597 term_chara(struct termp *p, char c)

Line 581 term_chara(struct termp *p, char c)

p->buf[(int)(p->col)++] = c;

}

static void

term_encodea(struct termp *p, char c)

{

if (' ' != c && 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);

}

CVSweb