mandoc/term.c - diff

Return to term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/term.c between version 1.160 and 1.186

version 1.160, 2010/07/07 15:04:54

version 1.186, 2011/04/30 22:24:31

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 29

#include <string.h>

#include "mandoc.h"

#include "chars.h"

#include "out.h"

#include "term.h"

#include "main.h"

static void spec(struct termp *, const char *, size_t);

static void res(struct termp *, const char *, size_t);

static void buffera(struct termp *, const char *, size_t);

static void bufferc(struct termp *, char);

static void adjbuf(struct termp *p, size_t);

static void encode(struct termp *, const char *, size_t);

Line 49 term_free(struct termp *p)

Line 47 term_free(struct termp *p)

if (p->buf)

free(p->buf);

if (p->symtab)

chars_free(p->symtab);

mchars_free(p->symtab);

free(p);

}

Line 80 term_alloc(enum termenc enc)

Line 78 term_alloc(enum termenc enc)

{

struct termp *p;

p = calloc(1, sizeof(struct termp));

p = mandoc_calloc(1, sizeof(struct termp));

if (NULL == p) {

perror(NULL);

exit(EXIT_FAILURE);

}

p->enc = enc;

return(p);

}

Line 134 term_flushln(struct termp *p)

Line 127 term_flushln(struct termp *p)

size_t vbl; /* number of blanks to prepend to output */

size_t vend; /* end of word visual position on output */

size_t bp; /* visual right border position */

size_t dv; /* temporary for visual pos calculations */

int j; /* temporary loop index for p->buf */

int jhy; /* last hyph before overflow w/r/t j */

size_t maxvis; /* output position of visible boundary */

Line 145 term_flushln(struct termp *p)

Line 139 term_flushln(struct termp *p)

* an indentation, but can be, for tagged lists or columns, a

* small set of values.

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

dv = p->rmargin - p->offset;

maxvis = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;

dv = p->maxrmargin - p->offset;

mmax = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;

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

maxvis = (int)(p->rmargin - p->offset) - p->overstep < 0 ?

/* LINTED */

0 : p->rmargin - p->offset - p->overstep;

mmax = (int)(p->maxrmargin - p->offset) - p->overstep < 0 ?

/* LINTED */

0 : p->maxrmargin - p->offset - p->overstep;

bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;

* Indent the first line of a paragraph.

vbl = p->flags & TERMP_NOLPAD ? 0 : p->offset;

vbl = p->flags & TERMP_NOLPAD ? (size_t)0 : p->offset;

vis = vend = i = 0;

vis = vend = 0;

i = 0;

while (i < (int)p->col) {

* Handle literal tab characters: collapse all

* subsequent tabs into a single huge set of spaces.

for (j = i; j < (int)p->col; j++) {

while (i < (int)p->col && '\t' == p->buf[i]) {

if ('\t' != p->buf[j])

break;

vend = (vis / p->tabwidth + 1) * p->tabwidth;

vbl += vend - vis;

vis = vend;

i++;

}

Line 184 term_flushln(struct termp *p)

Line 174 term_flushln(struct termp *p)

* space is printed according to regular spacing rules).

/* LINTED */

for (j = i, jhy = 0; j < (int)p->col; j++) {

for (jhy = 0; j < (int)p->col; j++) {

if ((j && ' ' == p->buf[j]) || '\t' == p->buf[j])

break;

Line 223 term_flushln(struct termp *p)

Line 212 term_flushln(struct termp *p)

/* Remove the p->overstep width. */

bp += (int)/* LINTED */

bp += (size_t)p->overstep;

p->overstep;

p->overstep = 0;

}

* Skip leading tabs, they were handled above.

while (i < (int)p->col && '\t' == p->buf[i])

i++;

/* Write out the [remaining] word. */

for ( ; i < (int)p->col; i++) {

if (vend > bp && jhy > 0 && i > jhy)

Line 241 term_flushln(struct termp *p)

Line 223 term_flushln(struct termp *p)

if ('\t' == p->buf[i])

break;

if (' ' == p->buf[i]) {

while (' ' == p->buf[i]) {

j = i;

vbl += (*p->width)(p, p->buf[i]);

while (' ' == p->buf[i])

i++;

}

dv = (size_t)(i - j) * (*p->width)(p, ' ');

vbl += dv;

vend += dv;

break;

}

if (ASCII_NBRSP == p->buf[i]) {

Line 271 term_flushln(struct termp *p)

Line 255 term_flushln(struct termp *p)

p->viscol += (*p->width)(p, p->buf[i]);

}

vend += vbl;

vis = vend;

}

* If there was trailing white space, it was not printed;

* so reset the cursor position accordingly.

vis -= vbl;

p->col = 0;

p->overstep = 0;

Line 286 term_flushln(struct termp *p)

Line 275 term_flushln(struct termp *p)

if (TERMP_HANG & p->flags) {

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

p->overstep = /* LINTED */

p->overstep = (int)(vis - maxvis + (*p->width)(p, ' '));

vis - maxvis + (*p->width)(p, ' ');

* Behave exactly the same way as groff:

Line 301 term_flushln(struct termp *p)

Line 289 term_flushln(struct termp *p)

if (p->overstep >= -1) {

assert((int)maxvis + p->overstep >= 0);

/* LINTED */

maxvis += (size_t)p->overstep;

maxvis += p->overstep;

} else

p->overstep = 0;

Line 310 term_flushln(struct termp *p)

Line 297 term_flushln(struct termp *p)

return;

/* Right-pad. */

if (maxvis > vis + /* LINTED */

if (maxvis > vis +

((TERMP_TWOSPACE & p->flags) ?

((TERMP_TWOSPACE & p->flags) ? (*p->width)(p, ' ') : 0)) {

(*p->width)(p, ' ') : 0)) {

p->viscol += maxvis - vis;

(*p->advance)(p, maxvis - vis);

vis += (maxvis - vis);

Line 360 term_vspace(struct termp *p)

Line 346 term_vspace(struct termp *p)

static void

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

{

char c;

if ('\0' != (c = mchars_num2char(word, len)))

encode(p, &c, 1);

}

static void

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

{

const char *rhs;

size_t sz;

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

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

if (rhs)

encode(p, rhs, sz);

else if (1 == len)

encode(p, word, len);

}

Line 377 res(struct termp *p, const char *word, size_t len)

Line 375 res(struct termp *p, const char *word, size_t len)

const char *rhs;

size_t sz;

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

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

if (rhs)

encode(p, rhs, sz);

}

Line 456 term_fontpop(struct termp *p)

Line 454 term_fontpop(struct termp *p)

void

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

{

const char *sv, *seq;

const char *seq;

int sz;

size_t ssz;

enum roffdeco deco;

enum mandoc_esc esc;

sv = word;

if (word[0] && '\0' == word[1])

switch (word[0]) {

case('.'):

/* FALLTHROUGH */

case(','):

/* FALLTHROUGH */

case(';'):

/* FALLTHROUGH */

case(':'):

/* FALLTHROUGH */

case('?'):

/* FALLTHROUGH */

case('!'):

/* FALLTHROUGH */

case(')'):

/* FALLTHROUGH */

case(']'):

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

p->flags |= TERMP_NOSPACE;

break;

default:

break;

}

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

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

if (TERMP_PREKEEP & p->flags)

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

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

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

p->flags &= ~TERMP_NOSPACE;

else

p->flags |= TERMP_NOSPACE;

p->flags &= ~TERMP_SENTENCE;

p->flags &= ~(TERMP_SENTENCE | TERMP_IGNDELIM);

/* FIXME: use strcspn. */

while ('\0' != *word) {

if ((ssz = strcspn(word, "\\")) > 0)

encode(p, word, ssz);

while (*word) {

word += (int)ssz;

if ('\\' != *word) {

if ('\\' != *word)

encode(p, word, 1);

word++;

continue;

}

seq = ++word;

word++;

sz = a2roffdeco(&deco, &seq, &ssz);

esc = mandoc_escape(&word, &seq, &sz);

if (ESCAPE_ERROR == esc)

break;

switch (deco) {

switch (esc) {

case (DECO_RESERVED):

case (ESCAPE_NUMBERED):

res(p, seq, ssz);

numbered(p, seq, sz);

break;

case (DECO_SPECIAL):

case (ESCAPE_PREDEF):

spec(p, seq, ssz);

res(p, seq, sz);

break;

case (DECO_BOLD):

case (ESCAPE_SPECIAL):

spec(p, seq, sz);

break;

case (ESCAPE_FONTBOLD):

term_fontrepl(p, TERMFONT_BOLD);

break;

case (DECO_ITALIC):

case (ESCAPE_FONTITALIC):

term_fontrepl(p, TERMFONT_UNDER);

break;

case (DECO_ROMAN):

case (ESCAPE_FONTROMAN):

term_fontrepl(p, TERMFONT_NONE);

break;

case (DECO_PREVIOUS):

case (ESCAPE_FONTPREV):

term_fontlast(p);

break;

default:

case (ESCAPE_NOSPACE):

if ('\0' == *word)

p->flags |= TERMP_NOSPACE;

break;

}

word += sz;

if (DECO_NOSPACE == deco && '\0' == *word)

p->flags |= TERMP_NOSPACE;

}

* Note that we don't process the pipe: the parser sees it as

* punctuation, but we don't in terms of typography.

if (sv[0] && 0 == sv[1])

switch (sv[0]) {

case('('):

/* FALLTHROUGH */

case('['):

p->flags |= TERMP_NOSPACE;

break;

default:

break;

}

Line 569 adjbuf(struct termp *p, size_t sz)

Line 532 adjbuf(struct termp *p, size_t sz)

while (sz >= p->maxcols)

p->maxcols <<= 2;

p->buf = realloc(p->buf, p->maxcols);

p->buf = mandoc_realloc(p->buf, p->maxcols);

if (NULL == p->buf) {

perror(NULL);

exit(EXIT_FAILURE);

}

static void

buffera(struct termp *p, const char *word, size_t sz)

{

if (p->col + sz >= p->maxcols)

adjbuf(p, p->col + sz);

memcpy(&p->buf[(int)p->col], word, sz);

p->col += sz;

}

static void

bufferc(struct termp *p, char c)

{

Line 613 encode(struct termp *p, const char *word, size_t sz)

Line 560 encode(struct termp *p, const char *word, size_t sz)

if (TERMFONT_NONE == (f = term_fonttop(p))) {

buffera(p, word, sz);

if (p->col + sz >= p->maxcols)

adjbuf(p, p->col + sz);

memcpy(&p->buf[(int)p->col], word, sz);

p->col += sz;

return;

}

/* Pre-buffer, assuming worst-case. */

if (p->col + 1 + (sz * 3) >= p->maxcols)

adjbuf(p, p->col + 1 + (sz * 3));

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

if ( ! isgraph((u_char)word[i])) {

bufferc(p, word[i]);

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

continue;

}

if (TERMFONT_UNDER == f)

bufferc(p, '_');

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

else

bufferc(p, word[i]);

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

bufferc(p, 8);

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

bufferc(p, word[i]);

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

}

Line 645 term_len(const struct termp *p, size_t sz)

Line 600 term_len(const struct termp *p, size_t sz)

size_t

term_strlen(const struct termp *p, const char *cp)

{

size_t sz;

size_t sz, rsz, i;

int ssz;

enum mandoc_esc esc;

const char *seq, *rhs;

for (sz = 0; *cp; cp++)

sz += (*p->width)(p, *cp);

* Account for escaped sequences within string length

* calculations. This follows the logic in term_word() as we

* must calculate the width of produced strings.

sz = 0;

while ('\0' != *cp)

switch (*cp) {

case ('\\'):

++cp;

esc = mandoc_escape(&cp, &seq, &ssz);

if (ESCAPE_ERROR == esc)

return(sz);

switch (esc) {

case (ESCAPE_PREDEF):

rhs = mchars_res2str

(p->symtab, seq, ssz, &rsz);

break;

case (ESCAPE_SPECIAL):

rhs = mchars_spec2str

(p->symtab, seq, ssz, &rsz);

if (ssz != 1 || rhs)

break;

rhs = seq;

rsz = ssz;

break;

default:

rhs = NULL;

break;

}

if (NULL == rhs)

break;

for (i = 0; i < rsz; i++)

sz += (*p->width)(p, *rhs++);

break;

case (ASCII_NBRSP):

sz += (*p->width)(p, ' ');

cp++;

break;

case (ASCII_HYPH):

sz += (*p->width)(p, '-');

cp++;

break;

default:

sz += (*p->width)(p, *cp++);

break;

}

return(sz);

}

CVSweb