=================================================================== RCS file: /cvs/mandoc/term.c,v retrieving revision 1.167 retrieving revision 1.186 diff -u -p -r1.167 -r1.186 --- mandoc/term.c 2010/08/20 01:02:07 1.167 +++ mandoc/term.c 2011/04/30 22:24:31 1.186 @@ -1,7 +1,7 @@ -/* $Id: term.c,v 1.167 2010/08/20 01:02:07 schwarze Exp $ */ +/* $Id: term.c,v 1.186 2011/04/30 22:24:31 kristaps Exp $ */ /* * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons - * Copyright (c) 2010 Ingo Schwarze + * Copyright (c) 2010, 2011 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -29,13 +29,11 @@ #include #include "mandoc.h" -#include "chars.h" #include "out.h" #include "term.h" #include "main.h" -static void spec(struct termp *, enum roffdeco, - const char *, size_t); +static void spec(struct termp *, const char *, size_t); static void res(struct termp *, const char *, size_t); static void bufferc(struct termp *, char); static void adjbuf(struct termp *p, size_t); @@ -49,7 +47,7 @@ term_free(struct termp *p) if (p->buf) free(p->buf); if (p->symtab) - chars_free(p->symtab); + mchars_free(p->symtab); free(p); } @@ -80,12 +78,7 @@ term_alloc(enum termenc enc) { struct termp *p; - p = calloc(1, sizeof(struct termp)); - if (NULL == p) { - perror(NULL); - exit(MANDOCLEVEL_SYSERR); - } - + p = mandoc_calloc(1, sizeof(struct termp)); p->enc = enc; return(p); } @@ -134,6 +127,7 @@ 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 */ @@ -145,36 +139,32 @@ 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++) { - if ('\t' != p->buf[j]) - break; + while (i < (int)p->col && '\t' == p->buf[i]) { vend = (vis / p->tabwidth + 1) * p->tabwidth; vbl += vend - vis; vis = vend; + i++; } /* @@ -184,8 +174,7 @@ term_flushln(struct termp *p) * space is printed according to regular spacing rules). */ - /* LINTED */ - for (jhy = 0; j < (int)p->col; j++) { + for (j = i, jhy = 0; j < (int)p->col; j++) { if ((j && ' ' == p->buf[j]) || '\t' == p->buf[j]) break; @@ -223,17 +212,10 @@ term_flushln(struct termp *p) /* Remove the p->overstep width. */ - bp += (int)/* LINTED */ - p->overstep; + bp += (size_t)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) @@ -244,7 +226,9 @@ term_flushln(struct termp *p) j = i; while (' ' == p->buf[i]) i++; - vbl += (i - j) * (*p->width)(p, ' '); + dv = (size_t)(i - j) * (*p->width)(p, ' '); + vbl += dv; + vend += dv; break; } if (ASCII_NBRSP == p->buf[i]) { @@ -271,10 +255,15 @@ 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; @@ -286,8 +275,7 @@ term_flushln(struct termp *p) if (TERMP_HANG & p->flags) { /* We need one blank after the tag. */ - p->overstep = /* LINTED */ - vis - maxvis + (*p->width)(p, ' '); + p->overstep = (int)(vis - maxvis + (*p->width)(p, ' ')); /* * Behave exactly the same way as groff: @@ -301,8 +289,7 @@ term_flushln(struct termp *p) */ if (p->overstep >= -1) { assert((int)maxvis + p->overstep >= 0); - /* LINTED */ - maxvis += p->overstep; + maxvis += (size_t)p->overstep; } else p->overstep = 0; @@ -310,9 +297,8 @@ term_flushln(struct termp *p) return; /* Right-pad. */ - if (maxvis > vis + /* LINTED */ - ((TERMP_TWOSPACE & p->flags) ? - (*p->width)(p, ' ') : 0)) { + if (maxvis > vis + + ((TERMP_TWOSPACE & p->flags) ? (*p->width)(p, ' ') : 0)) { p->viscol += maxvis - vis; (*p->advance)(p, maxvis - vis); vis += (maxvis - vis); @@ -360,15 +346,25 @@ term_vspace(struct termp *p) static void -spec(struct termp *p, enum roffdeco d, const char *word, size_t len) +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_spec2str(p->symtab, word, len, &sz); + rhs = mchars_spec2str(p->symtab, word, len, &sz); if (rhs) encode(p, rhs, sz); - else if (DECO_SSPECIAL == d) + else if (1 == len) encode(p, word, len); } @@ -379,7 +375,7 @@ res(struct termp *p, const char *word, size_t len) const char *rhs; size_t sz; - rhs = chars_res2str(p->symtab, word, len, &sz); + rhs = mchars_res2str(p->symtab, word, len, &sz); if (rhs) encode(p, rhs, sz); } @@ -458,37 +454,11 @@ 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) @@ -505,63 +475,51 @@ term_word(struct termp *p, const char *word) else p->flags |= TERMP_NOSPACE; - p->flags &= ~TERMP_SENTENCE; + p->flags &= ~(TERMP_SENTENCE | TERMP_IGNDELIM); - while (*word) { + while ('\0' != *word) { if ((ssz = strcspn(word, "\\")) > 0) encode(p, word, ssz); - word += ssz; + word += (int)ssz; if ('\\' != *word) continue; - seq = ++word; - sz = a2roffdeco(&deco, &seq, &ssz); + word++; + esc = mandoc_escape(&word, &seq, &sz); + if (ESCAPE_ERROR == esc) + break; - switch (deco) { - case (DECO_RESERVED): - res(p, seq, ssz); + switch (esc) { + case (ESCAPE_NUMBERED): + numbered(p, seq, sz); break; - case (DECO_SPECIAL): - /* FALLTHROUGH */ - case (DECO_SSPECIAL): - spec(p, deco, seq, ssz); + case (ESCAPE_PREDEF): + 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; } + } } @@ -574,11 +532,7 @@ adjbuf(struct termp *p, size_t sz) while (sz >= p->maxcols) p->maxcols <<= 2; - p->buf = realloc(p->buf, p->maxcols); - if (NULL == p->buf) { - perror(NULL); - exit(MANDOCLEVEL_SYSERR); - } + p->buf = mandoc_realloc(p->buf, p->maxcols); } @@ -646,10 +600,64 @@ 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); }