=================================================================== RCS file: /cvs/mandoc/roff.c,v retrieving revision 1.78 retrieving revision 1.80 diff -u -p -r1.78 -r1.80 --- mandoc/roff.c 2010/05/16 22:28:33 1.78 +++ mandoc/roff.c 2010/05/17 00:37:26 1.80 @@ -1,4 +1,4 @@ -/* $Id: roff.c,v 1.78 2010/05/16 22:28:33 kristaps Exp $ */ +/* $Id: roff.c,v 1.80 2010/05/17 00:37:26 kristaps Exp $ */ /* * Copyright (c) 2010 Kristaps Dzonsons * @@ -28,26 +28,21 @@ #define ROFF_CTL(c) \ ('.' == (c) || '\'' == (c)) -#if 0 -#define ROFF_MDEBUG(p, str) \ - fprintf(stderr, "%s: %s (%d:%d)\n", (str), \ - roffs[(p)->last->tok].name, \ - (p)->last->line, (p)->last->col) -#else -#define ROFF_MDEBUG(p, str) while (/* CONSTCOND */ 0) -#endif enum rofft { + ROFF_am, + ROFF_ami, + ROFF_am1, + ROFF_de, + ROFF_dei, + ROFF_de1, ROFF_if, ROFF_ig, ROFF_cblock, ROFF_ccond, #if 0 - ROFF_am, - ROFF_ami, - ROFF_de, - ROFF_dei, - ROFF_close, + ROFF_ie, + ROFF_el, #endif ROFF_MAX }; @@ -58,13 +53,19 @@ struct roff { void *data; /* privdata for messages */ }; +enum roffrule { + ROFFRULE_ALLOW, + ROFFRULE_DENY +}; + struct roffnode { enum rofft tok; /* type of node */ struct roffnode *parent; /* up one in stack */ - char *end; /* end-token: custom */ int line; /* parse line */ int col; /* parse col */ - int endspan; + char *end; /* end-rules: custom token */ + int endspan; /* end-rules: next-line or infty */ + enum roffrule rule; }; #define ROFF_ARGS struct roff *r, /* parse ctx */ \ @@ -80,22 +81,33 @@ typedef enum rofferr (*roffproc)(ROFF_ARGS); struct roffmac { const char *name; /* macro name */ - roffproc proc; - roffproc text; + roffproc proc; /* process new macro */ + roffproc text; /* process as child text of macro */ + roffproc sub; /* process as child of macro */ + int flags; +#define ROFFMAC_STRUCT (1 << 0) /* always interpret */ }; -static enum rofferr roff_if(ROFF_ARGS); -static enum rofferr roff_if_text(ROFF_ARGS); -static enum rofferr roff_ig(ROFF_ARGS); -static enum rofferr roff_ig_text(ROFF_ARGS); +static enum rofferr roff_block(ROFF_ARGS); +static enum rofferr roff_block_text(ROFF_ARGS); +static enum rofferr roff_block_sub(ROFF_ARGS); static enum rofferr roff_cblock(ROFF_ARGS); static enum rofferr roff_ccond(ROFF_ARGS); +static enum rofferr roff_if(ROFF_ARGS); +static enum rofferr roff_if_text(ROFF_ARGS); +static enum rofferr roff_if_sub(ROFF_ARGS); const struct roffmac roffs[ROFF_MAX] = { - { "if", roff_if, roff_if_text }, - { "ig", roff_ig, roff_ig_text }, - { ".", roff_cblock, NULL }, - { "\\}", roff_ccond, NULL }, + { "am", roff_block, roff_block_text, roff_block_sub, 0 }, + { "ami", roff_block, roff_block_text, roff_block_sub, 0 }, + { "am1", roff_block, roff_block_text, roff_block_sub, 0 }, + { "de", roff_block, roff_block_text, roff_block_sub, 0 }, + { "dei", roff_block, roff_block_text, roff_block_sub, 0 }, + { "de1", roff_block, roff_block_text, roff_block_sub, 0 }, + { "if", roff_if, roff_if_text, roff_if_sub, ROFFMAC_STRUCT }, + { "ig", roff_block, roff_block_text, roff_block_sub, 0 }, + { ".", roff_cblock, NULL, NULL, 0 }, + { "\\}", roff_ccond, NULL, NULL, 0 }, }; static void roff_free1(struct roff *); @@ -162,6 +174,7 @@ roffnode_push(struct roff *r, enum rofft tok, int line p->parent = r->last; p->line = line; p->col = col; + p->rule = p->parent ? p->parent->rule : ROFFRULE_DENY; r->last = p; return(1); @@ -215,69 +228,44 @@ roff_parseln(struct roff *r, int ln, char **bufp, size_t *szp, int pos, int *offs) { enum rofft t; - int ppos, i, j, wtf; + int ppos; + /* + * First, if a scope is open and we're not a macro, pass the + * text through the macro's filter. If a scope isn't open and + * we're not a macro, just let it through. + */ + if (r->last && ! ROFF_CTL((*bufp)[pos])) { - /* - * If a scope is open and we're not a macro, pass it - * through our text detector and continue as quickly as - * possible. - */ t = r->last->tok; assert(roffs[t].text); return((*roffs[t].text) (r, t, bufp, szp, ln, pos, pos, offs)); } else if ( ! ROFF_CTL((*bufp)[pos])) - /* - * Don't do anything if we're free-form text. - */ return(ROFF_CONT); - /* A macro-ish line with a possibly-open macro context. */ + /* + * If a scope is open, go to the child handler for that macro, + * as it may want to preprocess before doing anything with it. + */ - wtf = 0; - - if (r->last && r->last->end) { - /* - * We have a scope open that has a custom end-macro - * handler. Try to match it against the input. - */ - i = pos + 1; - while (' ' == (*bufp)[i] || '\t' == (*bufp)[i]) - i++; - - for (j = 0; r->last->end[j]; j++, i++) - if ((*bufp)[i] != r->last->end[j]) - break; - - if ('\0' == r->last->end[j] && - ('\0' == (*bufp)[i] || - ' ' == (*bufp)[i] || - '\t' == (*bufp)[i])) { - roffnode_pop(r); - roffnode_cleanscope(r); - wtf = 1; - } + if (r->last) { + t = r->last->tok; + assert(roffs[t].sub); + return((*roffs[t].sub) + (r, t, bufp, szp, ln, pos, pos, offs)); } + /* + * Lastly, as we've no scope open, try to look up and execute + * the new macro. If no macro is found, simply return and let + * the compilers handle it. + */ + ppos = pos; - if (ROFF_MAX == (t = roff_parse(*bufp, &pos))) { - /* - * This is some of groff's stranger behaviours. If we - * encountered a custom end-scope tag and that tag also - * happens to be a "real" macro, then we need to try - * interpreting it again as a real macro. If it's not, - * then return ignore. Else continue. - */ - if (wtf) - return(ROFF_IGN); - else if (NULL == r->last) - return(ROFF_CONT); + if (ROFF_MAX == (t = roff_parse(*bufp, &pos))) + return(ROFF_CONT); - /* FIXME: this assumes that we ignore!? */ - return(ROFF_IGN); - } - assert(roffs[t].proc); return((*roffs[t].proc) (r, t, bufp, szp, ln, ppos, pos, offs)); @@ -341,6 +329,11 @@ static enum rofferr roff_cblock(ROFF_ARGS) { + /* + * A block-close `..' should only be invoked as a child of an + * ignore macro, otherwise raise a warning and just ignore it. + */ + if (NULL == r->last) { if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) return(ROFF_ERR); @@ -357,7 +350,6 @@ roff_cblock(ROFF_ARGS) if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL)) return(ROFF_ERR); - ROFF_MDEBUG(r, "closing ignore block"); roffnode_pop(r); roffnode_cleanscope(r); return(ROFF_IGN); @@ -372,7 +364,6 @@ roffnode_cleanscope(struct roff *r) while (r->last) { if (--r->last->endspan < 0) break; - ROFF_MDEBUG(r, "closing implicit scope"); roffnode_pop(r); } } @@ -405,7 +396,6 @@ roff_ccond(ROFF_ARGS) if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL)) return(ROFF_ERR); - ROFF_MDEBUG(r, "closing explicit scope"); roffnode_pop(r); roffnode_cleanscope(r); return(ROFF_IGN); @@ -414,18 +404,27 @@ roff_ccond(ROFF_ARGS) /* ARGSUSED */ static enum rofferr -roff_ig(ROFF_ARGS) +roff_block(ROFF_ARGS) { int sv; size_t sz; + if (ROFF_ig != tok && '\0' == (*bufp)[pos]) { + if ( ! (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL)) + return(ROFF_ERR); + return(ROFF_IGN); + } else if (ROFF_ig != tok) { + while ((*bufp)[pos] && ' ' != (*bufp)[pos]) + pos++; + while (' ' == (*bufp)[pos]) + pos++; + } + if ( ! roffnode_push(r, tok, ln, ppos)) return(ROFF_ERR); - if ('\0' == (*bufp)[pos]) { - ROFF_MDEBUG(r, "opening ignore block"); + if ('\0' == (*bufp)[pos]) return(ROFF_IGN); - } sv = pos; while ((*bufp)[pos] && ' ' != (*bufp)[pos] && @@ -441,6 +440,9 @@ roff_ig(ROFF_ARGS) assert(pos > sv); sz = (size_t)(pos - sv); + if (1 == sz && '.' == (*bufp)[sv]) + return(ROFF_IGN); + r->last->end = malloc(sz + 1); if (NULL == r->last->end) { @@ -451,8 +453,6 @@ roff_ig(ROFF_ARGS) memcpy(r->last->end, *bufp + sv, sz); r->last->end[(int)sz] = '\0'; - ROFF_MDEBUG(r, "opening explicit ignore block"); - if ((*bufp)[pos]) if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL)) return(ROFF_ERR); @@ -463,9 +463,95 @@ roff_ig(ROFF_ARGS) /* ARGSUSED */ static enum rofferr -roff_ig_text(ROFF_ARGS) +roff_if_sub(ROFF_ARGS) { + enum rofft t; + enum roffrule rr; + ppos = pos; + rr = r->last->rule; + roffnode_cleanscope(r); + + if (ROFF_MAX == (t = roff_parse(*bufp, &pos))) + return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT); + + /* + * A denied conditional must evaluate its children if and only + * if they're either structurally required (such as loops and + * conditionals) or a closing macro. + */ + if (ROFFRULE_DENY == rr) + if ( ! (ROFFMAC_STRUCT & roffs[t].flags)) + if (ROFF_ccond != t) + return(ROFF_IGN); + + assert(roffs[t].proc); + return((*roffs[t].proc) + (r, t, bufp, szp, ln, ppos, pos, offs)); +} + + +/* ARGSUSED */ +static enum rofferr +roff_block_sub(ROFF_ARGS) +{ + enum rofft t; + int i, j; + + /* + * First check whether a custom macro exists at this level. If + * it does, then check against it. This is some of groff's + * stranger behaviours. If we encountered a custom end-scope + * tag and that tag also happens to be a "real" macro, then we + * need to try interpreting it again as a real macro. If it's + * not, then return ignore. Else continue. + */ + + if (r->last->end) { + i = pos + 1; + while (' ' == (*bufp)[i] || '\t' == (*bufp)[i]) + i++; + + for (j = 0; r->last->end[j]; j++, i++) + if ((*bufp)[i] != r->last->end[j]) + break; + + if ('\0' == r->last->end[j] && + ('\0' == (*bufp)[i] || + ' ' == (*bufp)[i] || + '\t' == (*bufp)[i])) { + roffnode_pop(r); + roffnode_cleanscope(r); + + if (ROFF_MAX != roff_parse(*bufp, &pos)) + return(ROFF_RERUN); + return(ROFF_IGN); + } + } + + /* + * If we have no custom end-query or lookup failed, then try + * pulling it out of the hashtable. + */ + + ppos = pos; + t = roff_parse(*bufp, &pos); + + /* If we're not a comment-end, then throw it away. */ + if (ROFF_cblock != t) + return(ROFF_IGN); + + assert(roffs[t].proc); + return((*roffs[t].proc)(r, t, bufp, + szp, ln, ppos, pos, offs)); +} + + +/* ARGSUSED */ +static enum rofferr +roff_block_text(ROFF_ARGS) +{ + return(ROFF_IGN); } @@ -482,10 +568,8 @@ roff_if_text(ROFF_ARGS) return(ROFF_IGN); } - if (ep > st && '\\' != *(ep - 1)) { - ROFF_MDEBUG(r, "closing explicit scope (in-line)"); + if (ep > st && '\\' != *(ep - 1)) roffnode_pop(r); - } roffnode_cleanscope(r); return(ROFF_IGN); @@ -533,11 +617,9 @@ roff_if(ROFF_ARGS) r->last->endspan = 1; if ('\\' == (*bufp)[pos] && '{' == (*bufp)[pos + 1]) { - ROFF_MDEBUG(r, "opening explicit scope"); r->last->endspan = -1; pos += 2; - } else - ROFF_MDEBUG(r, "opening implicit scope"); + } /* * If there are no arguments on the line, the next-line scope is