=================================================================== RCS file: /cvs/mandoc/man.c,v retrieving revision 1.55 retrieving revision 1.61 diff -u -p -r1.55 -r1.61 --- mandoc/man.c 2010/03/27 10:04:56 1.55 +++ mandoc/man.c 2010/05/07 15:49:36 1.61 @@ -1,4 +1,4 @@ -/* $Id: man.c,v 1.55 2010/03/27 10:04:56 kristaps Exp $ */ +/* $Id: man.c,v 1.61 2010/05/07 15:49:36 kristaps Exp $ */ /* * Copyright (c) 2008, 2009 Kristaps Dzonsons * @@ -53,6 +53,7 @@ const char *const __man_merrnames[WERRMAX] = { "invalid nesting of roff declarations", /* WROFFNEST */ "scope in roff instructions broken", /* WROFFSCOPE */ "document title should be uppercase", /* WTITLECASE */ + "deprecated comment style", /* WBADCOMMENT */ }; const char *const __man_macronames[MAN_MAX] = { @@ -82,8 +83,6 @@ static int man_ptext(struct man *, int, char *); static int man_pmacro(struct man *, int, char *); static void man_free1(struct man *); static void man_alloc1(struct man *); -static int pstring(struct man *, int, int, - const char *, size_t); static int macrowarn(struct man *, int, const char *); @@ -317,35 +316,29 @@ man_block_alloc(struct man *m, int line, int pos, enum } -static int -pstring(struct man *m, int line, int pos, - const char *p, size_t len) +int +man_word_alloc(struct man *m, int line, int pos, const char *word) { struct man_node *n; - size_t sv; + size_t sv, len; + len = strlen(word); + n = man_node_alloc(line, pos, MAN_TEXT, MAN_MAX); n->string = mandoc_malloc(len + 1); - sv = strlcpy(n->string, p, len + 1); + sv = strlcpy(n->string, word, len + 1); /* Prohibit truncation. */ assert(sv < len + 1); if ( ! man_node_append(m, n)) return(0); + m->next = MAN_NEXT_SIBLING; return(1); } -int -man_word_alloc(struct man *m, int line, int pos, const char *word) -{ - - return(pstring(m, line, pos, word, strlen(word))); -} - - /* * Free all of the resources held by a node. This does NOT unlink a * node from its context; for that, see man_node_unlink(). @@ -375,9 +368,13 @@ man_node_delete(struct man *m, struct man_node *p) static int man_ptext(struct man *m, int line, char *buf) { - int i, j; - char sv; + int i; + /* Ignore bogus comments. */ + + if ('\\' == buf[0] && '.' == buf[1] && '\"' == buf[2]) + return(man_pwarn(m, line, 0, WBADCOMMENT)); + /* Literal free-form text whitespace is preserved. */ if (MAN_LITERAL & m->flags) { @@ -386,61 +383,32 @@ man_ptext(struct man *m, int line, char *buf) goto descope; } - /* First de-chunk and allocate words. */ + /* Pump blank lines directly into the backend. */ for (i = 0; ' ' == buf[i]; i++) /* Skip leading whitespace. */ ; if ('\0' == buf[i]) { - /* Trailing whitespace? */ - if (i && ' ' == buf[i - 1]) - if ( ! man_pwarn(m, line, i - 1, WTSPACE)) - return(0); - if ( ! pstring(m, line, 0, &buf[i], 0)) + /* Allocate a blank entry. */ + if ( ! man_word_alloc(m, line, 0, "")) return(0); goto descope; } - for (j = i; buf[i]; i++) { - if (' ' != buf[i]) - continue; + /* Warn if the last un-escaped character is whitespace. */ - /* Escaped whitespace. */ - if (i && ' ' == buf[i] && '\\' == buf[i - 1]) - continue; + i = (int)strlen(buf); + assert(i); - sv = buf[i]; - buf[i++] = '\0'; - - if ( ! pstring(m, line, j, &buf[j], (size_t)(i - j))) - return(0); - - /* Trailing whitespace? Check at overwritten byte. */ - - if (' ' == sv && '\0' == buf[i]) + if (' ' == buf[i - 1] || '\t' == buf[i - 1]) + if (1 == i || ('\\' != buf[i - 2])) if ( ! man_pwarn(m, line, i - 1, WTSPACE)) return(0); - for ( ; ' ' == buf[i]; i++) - /* Skip trailing whitespace. */ ; - - j = i; - - /* Trailing whitespace? */ - - if (' ' == buf[i - 1] && '\0' == buf[i]) - if ( ! man_pwarn(m, line, i - 1, WTSPACE)) - return(0); - - if ('\0' == buf[i]) - break; - } - - if (j != i && ! pstring(m, line, j, &buf[j], (size_t)(i - j))) + if ( ! man_word_alloc(m, line, 0, buf)) return(0); descope: - /* * Co-ordinate what happens with having a next-line scope open: * first close out the element scope (if applicable), then close @@ -478,23 +446,25 @@ macrowarn(struct man *m, int ln, const char *buf) int man_pmacro(struct man *m, int ln, char *buf) { - int i, j, ppos, fl; + int i, j, ppos; enum mant tok; char mac[5]; struct man_node *n; /* Comments and empties are quickly ignored. */ - fl = m->flags; - if ('\0' == buf[1]) return(1); i = 1; - if (' ' == buf[i]) { + /* + * Skip whitespace between the control character and initial + * text. "Whitespace" is both spaces and tabs. + */ + if (' ' == buf[i] || '\t' == buf[i]) { i++; - while (buf[i] && ' ' == buf[i]) + while (buf[i] && (' ' == buf[i] || '\t' == buf[i])) i++; if ('\0' == buf[i]) goto out; @@ -550,6 +520,9 @@ man_pmacro(struct man *m, int ln, char *buf) * Remove prior ELINE macro, as it's being clobbering by a new * macro. Note that NSCOPED macros do not close out ELINE * macros---they don't print text---so we let those slip by. + * NOTE: we don't allow roff blocks (NOCLOSE) to be embedded + * here because that would stipulate blocks as children of + * elements! */ if ( ! (MAN_NSCOPED & man_macros[tok].flags) && @@ -581,10 +554,18 @@ man_pmacro(struct man *m, int ln, char *buf) m->flags &= ~MAN_ELINE; } - /* Begin recursive parse sequence. */ + /* + * Save the fact that we're in the next-line for a block. In + * this way, embedded roff instructions can "remember" state + * when they exit. + */ - assert(man_macros[tok].fp); + if (MAN_BLINE & m->flags) + m->flags |= MAN_BPLINE; + /* Call to handler... */ + + assert(man_macros[tok].fp); if ( ! (*man_macros[tok].fp)(m, tok, ln, ppos, &i, buf)) goto err; @@ -592,15 +573,13 @@ out: /* * We weren't in a block-line scope when entering the * above-parsed macro, so return. - * - * FIXME: this prohibits the nesting of blocks (e.g., `de' and - * family) within BLINE or ELINE systems. This is annoying. */ - if ( ! (MAN_BLINE & fl)) { + if ( ! (MAN_BPLINE & m->flags)) { m->flags &= ~MAN_ILINE; return(1); } + m->flags &= ~MAN_BPLINE; /* * If we're in a block scope, then allow this macro to slip by