=================================================================== RCS file: /cvs/mandoc/term.c,v retrieving revision 1.96 retrieving revision 1.124 diff -u -p -r1.96 -r1.124 --- mandoc/term.c 2009/07/27 13:10:08 1.96 +++ mandoc/term.c 2009/11/07 14:14:16 1.124 @@ -1,4 +1,4 @@ -/* $Id: term.c,v 1.96 2009/07/27 13:10:08 kristaps Exp $ */ +/* $Id: term.c,v 1.124 2009/11/07 14:14:16 kristaps Exp $ */ /* * Copyright (c) 2008, 2009 Kristaps Dzonsons * @@ -15,32 +15,31 @@ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include -#include +#include #include #include #include +#include +#include "chars.h" +#include "out.h" #include "term.h" #include "man.h" #include "mdoc.h" +#include "main.h" -extern int man_run(struct termp *, - const struct man *); -extern int mdoc_run(struct termp *, - const struct mdoc *); +/* FIXME: accomodate non-breaking, non-collapsing white-space. */ +/* FIXME: accomodate non-breaking, collapsing white-space. */ static struct termp *term_alloc(enum termenc); static void term_free(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 buffer(struct termp *, char); static void encode(struct termp *, char); -static int isopendelim(const char *); -static int isclosedelim(const char *); void * @@ -51,32 +50,6 @@ ascii_alloc(void) } -int -terminal_man(void *arg, const struct man *man) -{ - struct termp *p; - - p = (struct termp *)arg; - if (NULL == p->symtab) - p->symtab = term_ascii2htab(); - - return(man_run(p, man)); -} - - -int -terminal_mdoc(void *arg, const struct mdoc *mdoc) -{ - struct termp *p; - - p = (struct termp *)arg; - if (NULL == p->symtab) - p->symtab = term_ascii2htab(); - - return(mdoc_run(p, mdoc)); -} - - void terminal_free(void *arg) { @@ -91,8 +64,8 @@ term_free(struct termp *p) if (p->buf) free(p->buf); - if (TERMENC_ASCII == p->enc && p->symtab) - term_asciifree(p->symtab); + if (p->symtab) + chars_free(p->symtab); free(p); } @@ -103,71 +76,17 @@ term_alloc(enum termenc enc) { struct termp *p; - if (NULL == (p = malloc(sizeof(struct termp)))) - err(1, "malloc"); - bzero(p, sizeof(struct termp)); + p = calloc(1, sizeof(struct termp)); + if (NULL == p) { + perror(NULL); + exit(EXIT_FAILURE); + } p->maxrmargin = 78; p->enc = enc; return(p); } -static int -isclosedelim(const char *p) -{ - - if ( ! (*p && 0 == *(p + 1))) - return(0); - - switch (*p) { - case('.'): - /* FALLTHROUGH */ - case(','): - /* FALLTHROUGH */ - case(';'): - /* FALLTHROUGH */ - case(':'): - /* FALLTHROUGH */ - case('?'): - /* FALLTHROUGH */ - case('!'): - /* FALLTHROUGH */ - case(')'): - /* FALLTHROUGH */ - case(']'): - /* FALLTHROUGH */ - case('}'): - return(1); - default: - break; - } - - return(0); -} - - -static int -isopendelim(const char *p) -{ - - if ( ! (*p && 0 == *(p + 1))) - return(0); - - switch (*p) { - case('('): - /* FALLTHROUGH */ - case('['): - /* FALLTHROUGH */ - case('{'): - return(1); - default: - break; - } - - return(0); -} - - /* * 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 @@ -202,38 +121,45 @@ isopendelim(const char *p) * If TERMP_NOBREAK is specified and the line overruns the right * margin, it will break and pad-right to the right margin after * writing. If maxrmargin is violated, it will break and continue - * writing from the right-margin, which will lead to the above - * scenario upon exit. - * - * Otherwise, the line will break at the right margin. Extremely long - * lines will cause the system to emit a warning (TODO: hyphenate, if - * possible). + * writing from the right-margin, which will lead to the above scenario + * upon exit. Otherwise, the line will break at the right margin. */ void term_flushln(struct termp *p) { - int i, j; - size_t vbl, vsz, vis, maxvis, mmax, bp; + int i; /* current input position in p->buf */ + size_t vis; /* current visual position on output */ + size_t vbl; /* number of blanks to prepend to output */ + size_t vsz; /* visual characters to write to output */ + size_t bp; /* visual right border position */ + int j; /* temporary loop index */ + size_t maxvis, mmax; static int overstep = 0; /* * First, establish the maximum columns of "visible" content. * This is usually the difference between the right-margin and * an indentation, but can be, for tagged lists or columns, a - * small set of values. + * small set of values. */ assert(p->offset < p->rmargin); - assert((int)(p->rmargin - p->offset) - overstep > 0); - maxvis = /* LINTED */ - p->rmargin - p->offset - overstep; - mmax = /* LINTED */ - p->maxrmargin - p->offset - overstep; + maxvis = (int)(p->rmargin - p->offset) - overstep < 0 ? + /* LINTED */ + 0 : p->rmargin - p->offset - overstep; + mmax = (int)(p->maxrmargin - p->offset) - overstep < 0 ? + /* LINTED */ + 0 : p->maxrmargin - p->offset - overstep; bp = TERMP_NOBREAK & p->flags ? mmax : maxvis; + + /* + * FIXME: if bp is zero, we still output the first word before + * breaking the line. + */ + vis = 0; - overstep = 0; /* * If in the standard case (left-justified), then begin with our @@ -287,6 +213,10 @@ term_flushln(struct termp *p) putchar(' '); vis = 0; } + /* Remove the overstep width. */ + bp += (int)/* LINTED */ + overstep; + overstep = 0; } else { for (j = 0; j < (int)vbl; j++) putchar(' '); @@ -299,11 +229,18 @@ term_flushln(struct termp *p) for ( ; i < (int)p->col; i++) { if (' ' == p->buf[i]) break; - putchar(p->buf[i]); + + /* The unit sep. is a non-breaking space. */ + if (31 == p->buf[i]) + putchar(' '); + else + putchar(p->buf[i]); } vis += vsz; } + p->col = 0; + overstep = 0; if ( ! (TERMP_NOBREAK & p->flags)) { putchar('\n'); @@ -389,10 +326,10 @@ do_special(struct termp *p, const char *word, size_t l size_t sz; int i; - rhs = term_a2ascii(p->symtab, word, len, &sz); + rhs = chars_a2ascii(p->symtab, word, len, &sz); if (NULL == rhs) { -#if 1 +#if 0 fputs("Unknown special character: ", stderr); for (i = 0; i < (int)len; i++) fputc(word[i], stderr); @@ -412,7 +349,7 @@ do_reserved(struct termp *p, const char *word, size_t size_t sz; int i; - rhs = term_a2res(p->symtab, word, len, &sz); + rhs = chars_a2res(p->symtab, word, len, &sz); if (NULL == rhs) { #if 0 @@ -429,132 +366,111 @@ do_reserved(struct termp *p, const char *word, size_t /* - * Handle an escape sequence: determine its length and pass it to the - * escape-symbol look table. Note that we assume mdoc(3) has validated - * the escape sequence (we assert upon badly-formed escape sequences). + * Handle pwords, partial words, which may be either a single word or a + * phrase that cannot be broken down (such as a literal string). This + * handles word styling. */ -static void -do_escaped(struct termp *p, const char **word) +void +term_word(struct termp *p, const char *word) { - int j; - const char *wp; + const char *sv, *seq; + int sz, meta; + size_t ssz; + enum roffdeco deco; - wp = *word; + sv = word; - if (0 == *(++wp)) { - *word = wp; - return; - } - - if ('(' == *wp) { - wp++; - if (0 == *wp || 0 == *(wp + 1)) { - *word = 0 == *wp ? wp : wp + 1; - return; + if (word[0] && '\0' == word[1]) + switch (word[0]) { + case('.'): + /* FALLTHROUGH */ + 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; } - do_special(p, wp, 2); - *word = ++wp; - return; + if ( ! (TERMP_NOSPACE & p->flags)) + buffer(p, ' '); - } else if ('*' == *wp) { - if (0 == *(++wp)) { - *word = wp; - return; - } + if ( ! (p->flags & TERMP_NONOSPACE)) + p->flags &= ~TERMP_NOSPACE; - switch (*wp) { - case ('('): - wp++; - if (0 == *wp || 0 == *(wp + 1)) { - *word = 0 == *wp ? wp : wp + 1; - return; - } + /* + * FIXME: it's faster to put the metafont conditional here, + * because most of the time we're not a metafont and can use + * strcspn and fwrite. + */ - do_reserved(p, wp, 2); - *word = ++wp; - return; - case ('['): - break; - default: - do_reserved(p, wp, 1); - *word = wp; - return; + while (*word) { + if ('\\' != *word) { + encode(p, *word); + word++; + continue; } - - } else if ('f' == *wp) { - if (0 == *(++wp)) { - *word = wp; - return; - } - switch (*wp) { - case ('B'): - p->flags |= TERMP_BOLD; + seq = ++word; + sz = a2roffdeco(&deco, &seq, &ssz); + + switch (deco) { + case (DECO_RESERVED): + do_reserved(p, seq, ssz); break; - case ('I'): - p->flags |= TERMP_UNDER; + case (DECO_SPECIAL): + do_special(p, seq, ssz); break; - case ('P'): - /* FALLTHROUGH */ - case ('R'): - p->flags &= ~TERMP_STYLE; + case (DECO_BOLD): + p->metamask = p->metafont; + p->metafont |= METAF_BOLD; break; + case (DECO_ITALIC): + p->metamask = p->metafont; + p->metafont |= METAF_UNDER; + break; + case (DECO_ROMAN): + p->metamask = p->metafont; + p->metafont &= ~METAF_UNDER; + p->metafont &= ~METAF_BOLD; + break; + case (DECO_PREVIOUS): + meta = p->metamask; + p->metamask = p->metafont; + p->metafont = meta; + break; default: break; } - - *word = wp; - return; - - } else if ('[' != *wp) { - do_special(p, wp, 1); - *word = wp; - return; + word += sz; } - wp++; - for (j = 0; *wp && ']' != *wp; wp++, j++) - /* Loop... */ ; - - if (0 == *wp) { - *word = wp; - return; - } - - do_special(p, wp - j, (size_t)j); - *word = wp; -} - - -/* - * Handle pwords, partial words, which may be either a single word or a - * phrase that cannot be broken down (such as a literal string). This - * handles word styling. - */ -void -term_word(struct termp *p, const char *word) -{ - const char *sv; - - if (isclosedelim(word)) - if ( ! (TERMP_IGNDELIM & p->flags)) + if (sv[0] && 0 == sv[1]) + switch (sv[0]) { + case('('): + /* FALLTHROUGH */ + case('['): + /* FALLTHROUGH */ + case('{'): p->flags |= TERMP_NOSPACE; - - if ( ! (TERMP_NOSPACE & p->flags)) - buffer(p, ' '); - - if ( ! (p->flags & TERMP_NONOSPACE)) - p->flags &= ~TERMP_NOSPACE; - - for (sv = word; *word; word++) - if ('\\' != *word) - encode(p, *word); - else - do_escaped(p, &word); - - if (isopendelim(sv)) - p->flags |= TERMP_NOSPACE; + break; + default: + break; + } } @@ -573,8 +489,10 @@ buffer(struct termp *p, char c) p->maxcols = 256; s = p->maxcols * 2; p->buf = realloc(p->buf, s); - if (NULL == p->buf) - err(1, "realloc"); + if (NULL == p->buf) { + perror(NULL); + exit(EXIT_FAILURE); + } p->maxcols = s; } p->buf[(int)(p->col)++] = c; @@ -585,15 +503,92 @@ static void encode(struct termp *p, char c) { - if (' ' != c && TERMP_STYLE & p->flags) { - if (TERMP_BOLD & p->flags) { - buffer(p, c); + if (isgraph((u_char)c)) { + if (p->under || METAF_UNDER & p->metafont) { + buffer(p, '_'); buffer(p, 8); } - if (TERMP_UNDER & p->flags) { - buffer(p, '_'); + if (p->bold || METAF_BOLD & p->metafont) { + buffer(p, c); buffer(p, 8); } } buffer(p, c); } + + +size_t +term_vspan(const struct roffsu *su) +{ + double r; + + switch (su->unit) { + case (SCALE_CM): + r = su->scale * 2; + break; + case (SCALE_IN): + r = su->scale * 6; + break; + case (SCALE_PC): + r = su->scale; + break; + case (SCALE_PT): + r = su->scale / 8; + break; + case (SCALE_MM): + r = su->scale / 1000; + break; + case (SCALE_VS): + r = su->scale; + break; + default: + r = su->scale - 1; + break; + } + + if (r < 0.0) + r = 0.0; + return(/* LINTED */(size_t) + r); +} + + +size_t +term_hspan(const struct roffsu *su) +{ + double r; + + /* XXX: CM, IN, and PT are approximations. */ + + switch (su->unit) { + case (SCALE_CM): + r = 4 * su->scale; + break; + case (SCALE_IN): + /* XXX: this is an approximation. */ + r = 10 * su->scale; + break; + case (SCALE_PC): + r = (10 * su->scale) / 6; + break; + case (SCALE_PT): + r = (10 * su->scale) / 72; + break; + case (SCALE_MM): + r = su->scale / 1000; /* FIXME: double-check. */ + break; + case (SCALE_VS): + r = su->scale * 2 - 1; /* FIXME: double-check. */ + break; + default: + r = su->scale; + break; + } + + if (r < 0.0) + r = 0.0; + return((size_t)/* LINTED */ + r); +} + +