=================================================================== RCS file: /cvs/mandoc/Attic/mdocterm.c,v retrieving revision 1.7 retrieving revision 1.23 diff -u -p -r1.7 -r1.23 --- mandoc/Attic/mdocterm.c 2009/02/23 15:34:53 1.7 +++ mandoc/Attic/mdocterm.c 2009/03/01 23:23:55 1.23 @@ -1,4 +1,4 @@ - /* $Id: mdocterm.c,v 1.7 2009/02/23 15:34:53 kristaps Exp $ */ +/* $Id: mdocterm.c,v 1.23 2009/03/01 23:23:55 kristaps Exp $ */ /* * Copyright (c) 2008 Kristaps Dzonsons * @@ -16,6 +16,8 @@ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ +#include + #include #include #include @@ -31,6 +33,34 @@ #include "mmain.h" #include "term.h" +#define TERMSYM_RBRACK "]" +#define TERMSYM_LBRACK "[" +#define TERMSYM_LARROW "<-" +#define TERMSYM_RARROW "->" +#define TERMSYM_UARROW "^" +#define TERMSYM_DARROW "v" +#define TERMSYM_LSQUOTE "`" +#define TERMSYM_RSQUOTE "\'" +#define TERMSYM_SQUOTE "\'" +#define TERMSYM_LDQUOTE "``" +#define TERMSYM_RDQUOTE "\'\'" +#define TERMSYM_DQUOTE "\"" +#define TERMSYM_LT "<" +#define TERMSYM_GT ">" +#define TERMSYM_LE "<=" +#define TERMSYM_GE ">=" +#define TERMSYM_EQ "==" +#define TERMSYM_NEQ "!=" +#define TERMSYM_ACUTE "\'" +#define TERMSYM_GRAVE "`" +#define TERMSYM_PI "pi" +#define TERMSYM_PLUSMINUS "+=" +#define TERMSYM_INF "oo" +#define TERMSYM_INF2 "infinity" +#define TERMSYM_NAN "NaN" +#define TERMSYM_BAR "|" +#define TERMSYM_BULLET "o" + #ifdef __NetBSD__ #define xisspace(x) isspace((int)(x)) #else @@ -44,6 +74,7 @@ enum termstyle { }; static void body(struct termp *, + struct termpair *, const struct mdoc_meta *, const struct mdoc_node *); static void header(struct termp *, @@ -54,6 +85,8 @@ static void footer(struct termp *, static void pword(struct termp *, const char *, size_t); static void pescape(struct termp *, const char *, size_t *, size_t); +static void nescape(struct termp *, + const char *, size_t); static void chara(struct termp *, char); static void stringa(struct termp *, const char *); static void style(struct termp *, enum termstyle); @@ -79,7 +112,7 @@ main(int argc, char *argv[]) if (NULL == (mdoc = mmain_mdoc(p))) mmain_exit(p, 1); - termp.maxrmargin = 80; /* XXX */ + termp.maxrmargin = 78; /* XXX */ termp.rmargin = termp.maxrmargin; termp.maxcols = 1024; termp.offset = termp.col = 0; @@ -89,7 +122,7 @@ main(int argc, char *argv[]) err(1, "malloc"); header(&termp, mdoc_meta(mdoc)); - body(&termp, mdoc_meta(mdoc), mdoc_node(mdoc)); + body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc)); footer(&termp, mdoc_meta(mdoc)); free(termp.buf); @@ -130,7 +163,6 @@ flushln(struct termp *p) * If we're literal, print out verbatim. */ if (p->flags & TERMP_LITERAL) { - /* FIXME: count non-printing chars. */ for (i = 0; i < p->col; i++) putchar(p->buf[i]); putchar('\n'); @@ -141,9 +173,10 @@ flushln(struct termp *p) for (i = 0; i < p->col; i++) { /* * Count up visible word characters. Control sequences - * (starting with the CSI) aren't counted. + * (starting with the CSI) aren't counted. A space + * generates a non-printing word, which is valid (the + * space is printed according to regular spacing rules). */ - assert( ! xisspace(p->buf[i])); /* LINTED */ for (j = i, vsz = 0; j < p->col; j++) { @@ -155,26 +188,29 @@ flushln(struct termp *p) } else vsz++; } - assert(vsz > 0); /* + * If we're breaking normally... + * * If a word is too long and we're within a line, put it * on the next line. Puke if we're being asked to write * something that will exceed the right margin (i.e., - * from a fresh line or when we're not allowed to break - * the line with TERMP_NOBREAK). + * from a fresh line). + * + * If we're not breaking... + * + * Don't let the visible size exceed the full margin. */ - if (vis && vis + vsz >= maxvis) { - /* FIXME */ - if (p->flags & TERMP_NOBREAK) + if ( ! (TERMP_NOBREAK & p->flags)) { + if (vis && vis + vsz > maxvis) { + putchar('\n'); + for (j = 0; j < p->offset; j++) + putchar(' '); + vis = 0; + } else if (vis + vsz > maxvis) errx(1, "word breaks right margin"); - putchar('\n'); - for (j = 0; j < p->offset; j++) - putchar(' '); - vis = 0; - } else if (vis + vsz >= maxvis) - /* FIXME */ + } else if (vis + vsz > p->maxrmargin) errx(1, "word breaks right margin"); /* @@ -194,13 +230,21 @@ flushln(struct termp *p) } } + if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) { + putchar('\n'); + for (i = 0; i < p->rmargin; i++) + putchar(' '); + p->col = 0; + return; + } + /* * If we're not to right-marginalise it (newline), then instead * pad to the right margin and stay off. */ if (p->flags & TERMP_NOBREAK) { - for ( ; vis <= maxvis; vis++) + for ( ; vis < maxvis; vis++) putchar(' '); } else putchar('\n'); @@ -218,9 +262,12 @@ newln(struct termp *p) * vertical space. */ p->flags |= TERMP_NOSPACE; - if (0 == p->col) + if (0 == p->col) { + p->flags &= ~TERMP_NOLPAD; return; + } flushln(p); + p->flags &= ~TERMP_NOLPAD; } @@ -251,9 +298,16 @@ static void chara(struct termp *p, char c) { - /* TODO: dynamically expand the buffer. */ - if (p->col + 1 >= p->maxcols) - errx(1, "line overrun"); + /* + * Insert a single character into the line-buffer. If the + * buffer's space is exceeded, then allocate more space. + */ + if (p->col + 1 >= p->maxcols) { + p->buf = realloc(p->buf, p->maxcols * 2); + if (NULL == p->buf) + err(1, "malloc"); + p->maxcols *= 2; + } p->buf[(p->col)++] = c; } @@ -286,27 +340,125 @@ style(struct termp *p, enum termstyle esc) static void +nescape(struct termp *p, const char *word, size_t len) +{ + + switch (len) { + case (1): + if ('q' == word[0]) + stringa(p, TERMSYM_DQUOTE); + break; + case (2): + if ('r' == word[0] && 'B' == word[1]) + stringa(p, TERMSYM_RBRACK); + else if ('l' == word[0] && 'B' == word[1]) + stringa(p, TERMSYM_LBRACK); + else if ('l' == word[0] && 'q' == word[1]) + stringa(p, TERMSYM_LDQUOTE); + else if ('r' == word[0] && 'q' == word[1]) + stringa(p, TERMSYM_RDQUOTE); + else if ('o' == word[0] && 'q' == word[1]) + stringa(p, TERMSYM_LSQUOTE); + else if ('a' == word[0] && 'q' == word[1]) + stringa(p, TERMSYM_RSQUOTE); + else if ('<' == word[0] && '-' == word[1]) + stringa(p, TERMSYM_LARROW); + else if ('-' == word[0] && '>' == word[1]) + stringa(p, TERMSYM_RARROW); + else if ('b' == word[0] && 'u' == word[1]) + stringa(p, TERMSYM_BULLET); + else if ('<' == word[0] && '=' == word[1]) + stringa(p, TERMSYM_LE); + else if ('>' == word[0] && '=' == word[1]) + stringa(p, TERMSYM_GE); + else if ('=' == word[0] && '=' == word[1]) + stringa(p, TERMSYM_EQ); + else if ('+' == word[0] && '-' == word[1]) + stringa(p, TERMSYM_PLUSMINUS); + else if ('u' == word[0] && 'a' == word[1]) + stringa(p, TERMSYM_UARROW); + else if ('d' == word[0] && 'a' == word[1]) + stringa(p, TERMSYM_DARROW); + else if ('a' == word[0] && 'a' == word[1]) + stringa(p, TERMSYM_ACUTE); + else if ('g' == word[0] && 'a' == word[1]) + stringa(p, TERMSYM_GRAVE); + else if ('!' == word[0] && '=' == word[1]) + stringa(p, TERMSYM_NEQ); + else if ('i' == word[0] && 'f' == word[1]) + stringa(p, TERMSYM_INF); + else if ('n' == word[0] && 'a' == word[1]) + stringa(p, TERMSYM_NAN); + else if ('b' == word[0] && 'a' == word[1]) + stringa(p, TERMSYM_BAR); + + /* Deprecated forms. */ + else if ('B' == word[0] && 'a' == word[1]) + stringa(p, TERMSYM_BAR); + else if ('I' == word[0] && 'f' == word[1]) + stringa(p, TERMSYM_INF2); + else if ('G' == word[0] && 'e' == word[1]) + stringa(p, TERMSYM_GE); + else if ('G' == word[0] && 't' == word[1]) + stringa(p, TERMSYM_GT); + else if ('L' == word[0] && 'e' == word[1]) + stringa(p, TERMSYM_LE); + else if ('L' == word[0] && 'q' == word[1]) + stringa(p, TERMSYM_LDQUOTE); + else if ('L' == word[0] && 't' == word[1]) + stringa(p, TERMSYM_LT); + else if ('N' == word[0] && 'a' == word[1]) + stringa(p, TERMSYM_NAN); + else if ('N' == word[0] && 'e' == word[1]) + stringa(p, TERMSYM_NEQ); + else if ('P' == word[0] && 'i' == word[1]) + stringa(p, TERMSYM_PI); + else if ('P' == word[0] && 'm' == word[1]) + stringa(p, TERMSYM_PLUSMINUS); + else if ('R' == word[0] && 'q' == word[1]) + stringa(p, TERMSYM_RDQUOTE); + break; + default: + break; + } +} + + +static void pescape(struct termp *p, const char *word, size_t *i, size_t len) { + size_t j; (*i)++; assert(*i < len); + /* + * Handle an escape sequence. This must manage both groff-style + * escapes and mdoc-style escapes. + */ + if ('(' == word[*i]) { /* Two-character escapes. */ (*i)++; assert(*i + 1 < len); + nescape(p, &word[*i], 2); + (*i)++; + return; - if ('r' == word[*i] && 'B' == word[*i + 1]) - chara(p, ']'); - else if ('l' == word[*i] && 'B' == word[*i + 1]) - chara(p, '['); - else if ('<' == word[*i] && '-' == word[*i + 1]) - stringa(p, "<-"); - else if ('-' == word[*i] && '>' == word[*i + 1]) - stringa(p, "->"); - + } else if ('*' == word[*i]) { (*i)++; + assert(*i < len); + switch (word[*i]) { + case ('('): + (*i)++; + assert(*i + 1 < len); + nescape(p, &word[*i], 2); + (*i)++; + return; + default: + break; + } + nescape(p, &word[*i], 1); return; } else if ('[' != word[*i]) { @@ -320,14 +472,25 @@ pescape(struct termp *p, const char *word, size_t *i, /* FALLTHROUGH */ case ('-'): /* FALLTHROUGH */ + case (' '): + /* FALLTHROUGH */ case ('.'): chara(p, word[*i]); + break; + case ('e'): + chara(p, '\\'); + break; default: break; } return; } - /* n-character escapes. */ + + (*i)++; + for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++) + /* Loop... */ ; + + nescape(p, &word[*i - j], j); } @@ -336,14 +499,24 @@ pword(struct termp *p, const char *word, size_t len) { size_t i; - /*assert(len > 0);*/ /* Can be, if literal. */ + /* + * 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. + */ if ( ! (p->flags & TERMP_NOSPACE) && ! (p->flags & TERMP_LITERAL)) chara(p, ' '); - p->flags &= ~TERMP_NOSPACE; + if ( ! (p->flags & TERMP_NONOSPACE)) + p->flags &= ~TERMP_NOSPACE; + /* + * XXX - if literal and underlining, this will underline the + * spaces between literal words. + */ + if (p->flags & TERMP_BOLD) style(p, STYLE_BOLD); if (p->flags & TERMP_UNDERLINE) @@ -368,6 +541,13 @@ word(struct termp *p, const char *word) { size_t i, j, len; + /* + * Break apart a word into tokens. If we're a literal word, + * then don't. This doesn't handle zero-length words (there + * should be none) and makes sure that pword doesn't get spaces + * or nil words unless literal. + */ + if (p->flags & TERMP_LITERAL) { pword(p, word, strlen(word)); return; @@ -387,7 +567,14 @@ word(struct termp *p, const char *word) if ( ! xisspace(word[i])) { j++; continue; + } + + /* Escaped spaces don't delimit... */ + if (i > 0 && xisspace(word[i]) && '\\' == word[i - 1]) { + j++; + continue; } + if (0 == j) continue; assert(i >= j); @@ -402,37 +589,56 @@ word(struct termp *p, const char *word) static void -body(struct termp *p, const struct mdoc_meta *meta, +body(struct termp *p, struct termpair *ppair, + const struct mdoc_meta *meta, const struct mdoc_node *node) { int dochild; + struct termpair pair; + /* + * This is the main function for printing out nodes. It's + * constituted of PRE and POST functions, which correspond to + * prefix and infix processing. + */ + /* Pre-processing. */ dochild = 1; + pair.ppair = ppair; + pair.type = 0; + pair.offset = pair.rmargin = 0; + pair.flag = 0; + pair.count = 0; if (MDOC_TEXT != node->type) { if (termacts[node->tok].pre) - if ( ! (*termacts[node->tok].pre)(p, meta, node)) + if ( ! (*termacts[node->tok].pre)(p, &pair, meta, node)) dochild = 0; } else /* MDOC_TEXT == node->type */ word(p, node->data.text.string); /* Children. */ + if (TERMPAIR_FLAG & pair.type) + p->flags |= pair.flag; + if (dochild && node->child) - body(p, meta, node->child); + body(p, &pair, meta, node->child); + if (TERMPAIR_FLAG & pair.type) + p->flags &= ~pair.flag; + /* Post-processing. */ if (MDOC_TEXT != node->type) if (termacts[node->tok].post) - (*termacts[node->tok].post)(p, meta, node); + (*termacts[node->tok].post)(p, &pair, meta, node); /* Siblings. */ if (node->next) - body(p, meta, node->next); + body(p, ppair, meta, node->next); } @@ -441,7 +647,6 @@ footer(struct termp *p, const struct mdoc_meta *meta) { struct tm *tm; char *buf, *os; - size_t sz, osz, ssz, i; if (NULL == (buf = malloc(p->rmargin))) err(1, "malloc"); @@ -457,27 +662,32 @@ footer(struct termp *p, const struct mdoc_meta *meta) #endif err(1, "strftime"); - osz = strlcpy(os, meta->os, p->rmargin); + (void)strlcpy(os, meta->os, p->rmargin); - sz = strlen(buf); - ssz = sz + osz + 1; + /* + * This is /slightly/ different from regular groff output + * because we don't have page numbers. Print the following: + * + * OS MDOCDATE + */ - if (ssz > p->rmargin) { - ssz -= p->rmargin; - assert(ssz <= osz); - os[osz - ssz] = 0; - ssz = 1; - } else - ssz = p->rmargin - ssz + 1; + vspace(p); - printf("\n"); - printf("%s", os); - for (i = 0; i < ssz; i++) - printf(" "); + p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; + p->rmargin = p->maxrmargin - strlen(buf); + p->offset = 0; - printf("%s\n", buf); - fflush(stdout); + word(p, os); + flushln(p); + p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; + p->offset = p->rmargin; + p->rmargin = p->maxrmargin; + p->flags &= ~TERMP_NOBREAK; + + word(p, buf); + flushln(p); + free(buf); free(os); } @@ -486,16 +696,21 @@ footer(struct termp *p, const struct mdoc_meta *meta) static void header(struct termp *p, const struct mdoc_meta *meta) { - char *buf, *title; - const char *pp, *msec; - size_t ssz, tsz, ttsz, i;; + char *buf, *title, *bufp, *vbuf; + const char *pp; + struct utsname uts; + p->rmargin = p->maxrmargin; + p->offset = 0; + if (NULL == (buf = malloc(p->rmargin))) err(1, "malloc"); if (NULL == (title = malloc(p->rmargin))) err(1, "malloc"); + if (NULL == (vbuf = malloc(p->rmargin))) + err(1, "malloc"); - if (NULL == (pp = mdoc_vol2a(meta->vol))) + if (NULL == (pp = mdoc_vol2a(meta->vol))) { switch (meta->msec) { case (MSEC_1): /* FALLTHROUGH */ @@ -520,56 +735,75 @@ header(struct termp *p, const struct mdoc_meta *meta) pp = mdoc_vol2a(VOL_KM); break; default: - /* FIXME: capitalise. */ - if (NULL == (pp = mdoc_msec2a(meta->msec))) - pp = mdoc_msec2a(MSEC_local); break; } - assert(pp); + } + vbuf[0] = 0; - tsz = strlcpy(buf, pp, p->rmargin); - assert(tsz < p->rmargin); + if (pp) { + if (-1 == uname(&uts)) + err(1, "uname"); + (void)strlcat(vbuf, uts.sysname, p->rmargin); + (void)strlcat(vbuf, " ", p->rmargin); + } else if (NULL == (pp = mdoc_msec2a(meta->msec))) + pp = mdoc_msec2a(MSEC_local); - if ((pp = mdoc_arch2a(meta->arch))) { - tsz = strlcat(buf, " (", p->rmargin); - assert(tsz < p->rmargin); - tsz = strlcat(buf, pp, p->rmargin); - assert(tsz < p->rmargin); - tsz = strlcat(buf, ")", p->rmargin); - assert(tsz < p->rmargin); - } + (void)strlcat(vbuf, pp, p->rmargin); - ttsz = strlcpy(title, meta->title, p->rmargin); + /* + * The header is strange. It has three components, which are + * really two with the first duplicated. It goes like this: + * + * IDENTIFIER TITLE IDENTIFIER + * + * The IDENTIFIER is NAME(SECTION), which is the command-name + * (if given, or "unknown" if not) followed by the manual page + * section. These are given in `Dt'. The TITLE is a free-form + * string depending on the manual volume. If not specified, it + * switches on the manual section. + */ - if (NULL == (msec = mdoc_msec2a(meta->msec))) - msec = ""; + if (mdoc_arch2a(meta->arch)) + (void)snprintf(buf, p->rmargin, "%s (%s)", + vbuf, mdoc_arch2a(meta->arch)); + else + (void)strlcpy(buf, vbuf, p->rmargin); - ssz = (2 * (ttsz + 2 + strlen(msec))) + tsz + 2; + pp = mdoc_msec2a(meta->msec); - if (ssz > p->rmargin) { - if ((ssz -= p->rmargin) % 2) - ssz++; - ssz /= 2; + (void)snprintf(title, p->rmargin, "%s(%s)", + meta->title, pp ? pp : ""); + + for (bufp = title; *bufp; bufp++) + *bufp = toupper(*bufp); - assert(ssz <= ttsz); - title[ttsz - ssz] = 0; - ssz = 1; - } else - ssz = ((p->rmargin - ssz) / 2) + 1; + p->offset = 0; + p->rmargin = (p->maxrmargin - strlen(buf)) / 2; + p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; - printf("%s(%s)", title, msec); + word(p, title); + flushln(p); - for (i = 0; i < ssz; i++) - printf(" "); + p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; + p->offset = p->rmargin; + p->rmargin = p->maxrmargin - strlen(title); - printf("%s", buf); + word(p, buf); + flushln(p); - for (i = 0; i < ssz; i++) - printf(" "); + p->offset = p->rmargin; + p->rmargin = p->maxrmargin; + p->flags &= ~TERMP_NOBREAK; + p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; - printf("%s(%s)\n", title, msec); - fflush(stdout); + word(p, title); + flushln(p); + p->rmargin = p->maxrmargin; + p->offset = 0; + p->flags &= ~TERMP_NOSPACE; + free(title); + free(vbuf); free(buf); }