=================================================================== RCS file: /cvs/mandoc/Attic/macro.c,v retrieving revision 1.58 retrieving revision 1.70 diff -u -p -r1.58 -r1.70 --- mandoc/Attic/macro.c 2009/03/08 11:41:22 1.58 +++ mandoc/Attic/macro.c 2009/03/12 16:30:50 1.70 @@ -1,4 +1,4 @@ -/* $Id: macro.c,v 1.58 2009/03/08 11:41:22 kristaps Exp $ */ +/* $Id: macro.c,v 1.70 2009/03/12 16:30:50 kristaps Exp $ */ /* * Copyright (c) 2008 Kristaps Dzonsons * @@ -21,26 +21,26 @@ #include #include #include -#ifdef __linux__ -#include -#endif +#include "private.h" + /* * This has scanning/parsing routines, each of which extract a macro and * its arguments and parameters, then know how to progress to the next * macro. */ -#include "private.h" +/* FIXME: .Fl, .Ar, .Cd handling of `|'. */ -static int macro_obsolete(MACRO_PROT_ARGS); -static int macro_constant(MACRO_PROT_ARGS); -static int macro_constant_scoped(MACRO_PROT_ARGS); -static int macro_constant_delimited(MACRO_PROT_ARGS); -static int macro_text(MACRO_PROT_ARGS); -static int macro_scoped(MACRO_PROT_ARGS); -static int macro_scoped_close(MACRO_PROT_ARGS); -static int macro_scoped_line(MACRO_PROT_ARGS); +static int macro_obsolete(MACRO_PROT_ARGS); +static int macro_constant(MACRO_PROT_ARGS); +static int macro_constant_scoped(MACRO_PROT_ARGS); +static int macro_constant_delimited(MACRO_PROT_ARGS); +static int macro_text(MACRO_PROT_ARGS); +static int macro_scoped(MACRO_PROT_ARGS); +static int macro_scoped_close(MACRO_PROT_ARGS); +static int macro_scoped_line(MACRO_PROT_ARGS); +static int macro_phrase(struct mdoc *, int, int, char *); #define REWIND_REWIND (1 << 0) #define REWIND_NOHALT (1 << 1) @@ -60,6 +60,8 @@ static int append_delims(struct mdoc *, int, int *, static int lookup(struct mdoc *, int, int, int, const char *); static int pwarn(struct mdoc *, int, int, int); static int perr(struct mdoc *, int, int, int); +static int scopewarn(struct mdoc *, enum mdoc_type, int, int, + const struct mdoc_node *); #define WMACPARM (1) #define WOBS (2) @@ -87,7 +89,7 @@ const struct mdoc_macro __mdoc_macros[MDOC_MAX] = { { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Ad */ { macro_text, MDOC_PARSED }, /* An */ { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Ar */ - { macro_constant, 0 }, /* Cd */ + { macro_constant, MDOC_CALLABLE }, /* Cd */ { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Cm */ { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Dv */ { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Er */ @@ -179,11 +181,50 @@ const struct mdoc_macro __mdoc_macros[MDOC_MAX] = { { macro_obsolete, 0 }, /* Fr */ { macro_constant, 0 }, /* Ud */ { macro_constant, 0 }, /* Lb */ + { macro_constant_delimited, MDOC_CALLABLE | MDOC_PARSED }, /* Ap */ + { macro_text, 0 }, /* Lp */ + { macro_text, MDOC_PARSED }, /* Lk */ + { macro_text, MDOC_PARSED }, /* Mt */ + { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Brq */ + { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Bro */ + { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Brc */ + { macro_constant, 0 }, /* %C */ }; const struct mdoc_macro * const mdoc_macros = __mdoc_macros; +/* + * This is called at the end of parsing. It must traverse up the tree, + * closing out open [implicit] scopes. Obviously, open explicit scopes + * are errors. + */ +int +macro_end(struct mdoc *mdoc) +{ + struct mdoc_node *n; + + assert(mdoc->first); + assert(mdoc->last); + + /* Scan for open explicit scopes. */ + + n = MDOC_VALID & mdoc->last->flags ? + mdoc->last->parent : mdoc->last; + + for ( ; n; n = n->parent) { + if (MDOC_BLOCK != n->type) + continue; + if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags)) + continue; + return(mdoc_nerr(mdoc, n, + "macro scope still open on exit")); + } + + return(rewind_last(mdoc, mdoc->first)); +} + + static int perr(struct mdoc *mdoc, int line, int pos, int type) { @@ -192,7 +233,7 @@ perr(struct mdoc *mdoc, int line, int pos, int type) switch (type) { case (ENOCTX): c = mdoc_perr(mdoc, line, pos, - "closing macro has prior context"); + "closing macro has no prior context"); break; case (ENOPARMS): c = mdoc_perr(mdoc, line, pos, @@ -228,6 +269,53 @@ pwarn(struct mdoc *mdoc, int line, int pos, int type) static int +scopewarn(struct mdoc *mdoc, enum mdoc_type type, + int line, int pos, const struct mdoc_node *p) +{ + const char *n, *t, *tt; + + n = t = ""; + tt = "block"; + + switch (type) { + case (MDOC_BODY): + tt = "multi-line"; + break; + case (MDOC_HEAD): + tt = "line"; + break; + default: + break; + } + + switch (p->type) { + case (MDOC_BLOCK): + n = mdoc_macronames[p->tok]; + t = "block"; + break; + case (MDOC_BODY): + n = mdoc_macronames[p->tok]; + t = "multi-line"; + break; + case (MDOC_HEAD): + n = mdoc_macronames[p->tok]; + t = "line"; + break; + default: + break; + } + + if ( ! (MDOC_IGN_SCOPE & mdoc->pflags)) + return(mdoc_perr(mdoc, line, pos, + "%s scope breaks %s scope of %s", + tt, t, n)); + return(mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX, + "%s scope breaks %s scope of %s", + tt, t, n)); +} + + +static int lookup(struct mdoc *mdoc, int line, int pos, int from, const char *p) { int res; @@ -274,6 +362,8 @@ rewind_alt(int tok) return(MDOC_Ao); case (MDOC_Bc): return(MDOC_Bo); + case (MDOC_Brc): + return(MDOC_Bro); case (MDOC_Dc): return(MDOC_Do); case (MDOC_Ec): @@ -323,6 +413,8 @@ rewind_dohalt(int tok, enum mdoc_type type, const stru /* FALLTHROUGH */ case (MDOC_Bq): /* FALLTHROUGH */ + case (MDOC_Brq): + /* FALLTHROUGH */ case (MDOC_D1): /* FALLTHROUGH */ case (MDOC_Dl): @@ -377,6 +469,8 @@ rewind_dohalt(int tok, enum mdoc_type type, const stru /* FALLTHROUGH */ case (MDOC_Bo): /* FALLTHROUGH */ + case (MDOC_Bro): + /* FALLTHROUGH */ case (MDOC_Do): /* FALLTHROUGH */ case (MDOC_Eo): @@ -403,6 +497,8 @@ rewind_dohalt(int tok, enum mdoc_type type, const stru /* FALLTHROUGH */ case (MDOC_Bc): /* FALLTHROUGH */ + case (MDOC_Brc): + /* FALLTHROUGH */ case (MDOC_Dc): /* FALLTHROUGH */ case (MDOC_Ec): @@ -512,9 +608,8 @@ rewind_subblock(enum mdoc_type type, struct mdoc *mdoc break; else if (rewind_dobreak(tok, n)) continue; - return(mdoc_perr(mdoc, line, ppos, - "scope breaks %s", MDOC_ROOT == n->type ? - "" : mdoc_macronames[n->tok])); + if ( ! scopewarn(mdoc, type, line, ppos, n)) + return(0); } assert(n); @@ -537,9 +632,8 @@ rewind_expblock(struct mdoc *mdoc, int tok, int line, break; else if (rewind_dobreak(tok, n)) continue; - return(mdoc_perr(mdoc, line, ppos, - "scope breaks %s", MDOC_ROOT == n->type ? - "" : mdoc_macronames[n->tok])); + if ( ! scopewarn(mdoc, MDOC_BLOCK, line, ppos, n)) + return(0); } assert(n); @@ -562,9 +656,8 @@ rewind_impblock(struct mdoc *mdoc, int tok, int line, break; else if (rewind_dobreak(tok, n)) continue; - return(mdoc_perr(mdoc, line, ppos, - "scope breaks %s", MDOC_ROOT == n->type ? - "" : mdoc_macronames[n->tok])); + if ( ! scopewarn(mdoc, MDOC_BLOCK, line, ppos, n)) + return(0); } assert(n); @@ -751,7 +844,7 @@ macro_text(MACRO_PROT_ARGS) for (;;) { la = *pos; w = mdoc_args(mdoc, line, pos, buf, tok, &p); - assert(ARGS_PHRASE != c); + assert(ARGS_PHRASE != w); if (ARGS_ERROR == w) return(0); @@ -760,9 +853,13 @@ macro_text(MACRO_PROT_ARGS) if (ARGS_PUNCT == w) break; + /* Quoted words shouldn't be looked-up. */ + c = ARGS_QWORD == w ? MDOC_MAX : lookup(mdoc, line, la, tok, p); + /* MDOC_MAX (not a macro) or -1 (error). */ + if (MDOC_MAX != c && -1 != c) { if (0 == lastpunct && ! rewind_elem(mdoc, tok)) return(0); @@ -775,7 +872,7 @@ macro_text(MACRO_PROT_ARGS) } else if (-1 == c) return(0); - /* FIXME: .Fl and .Ar handling of `|'. */ + /* Non-quote-enclosed punctuation. */ if (ARGS_QWORD != w && mdoc_isdelim(p)) { if (0 == lastpunct && ! rewind_elem(mdoc, tok)) @@ -826,12 +923,14 @@ macro_text(MACRO_PROT_ARGS) * TEXT (`Another.') * * Note that the `.It' macro, possibly the most difficult (as it has - * embedded scope, etc.) is handled by this routine. + * embedded scope, etc.) is handled by this routine. It handles + * columnar output, where columns are "phrases" and denote multiple + * block heads. */ static int macro_scoped(MACRO_PROT_ARGS) { - int c, lastarg; + int c, lastarg, reopen; struct mdoc_arg *arg; char *p; @@ -883,6 +982,9 @@ macro_scoped(MACRO_PROT_ARGS) if ( ! mdoc_head_alloc(mdoc, line, ppos, tok)) return(0); + + /* Indicate that columnar scope shouldn't be reopened. */ + reopen = 0; mdoc->next = MDOC_NEXT_CHILD; for (;;) { @@ -894,16 +996,24 @@ macro_scoped(MACRO_PROT_ARGS) if (ARGS_EOLN == c) break; if (ARGS_PHRASE == c) { + if (reopen && ! mdoc_head_alloc(mdoc, line, ppos, tok)) + return(0); + mdoc->next = MDOC_NEXT_CHILD; + /* - if ( ! mdoc_phrase(mdoc, line, lastarg, buf)) + * Phrases are self-contained macro phrases used + * in the columnar output of a macro. They need + * special handling. + */ + if ( ! macro_phrase(mdoc, line, lastarg, buf)) return(0); - */ + if ( ! rewind_subblock(MDOC_HEAD, mdoc, tok, line, ppos)) + return(0); + + reopen = 1; continue; } - /* FIXME: if .It -column, the lookup must be for a - * sub-line component. BLAH. */ - if (-1 == (c = lookup(mdoc, line, lastarg, tok, p))) return(0); @@ -1158,6 +1268,8 @@ macro_constant_delimited(MACRO_PROT_ARGS) */ switch (tok) { + case (MDOC_Ap): + /* FALLTHROUGH */ case (MDOC_No): /* FALLTHROUGH */ case (MDOC_Ns): @@ -1282,8 +1394,6 @@ macro_constant(MACRO_PROT_ARGS) struct mdoc_arg *arg; char *p; - assert( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)); - arg = NULL; for (;;) { @@ -1343,32 +1453,44 @@ macro_obsolete(MACRO_PROT_ARGS) } -/* - * This is called at the end of parsing. It must traverse up the tree, - * closing out open [implicit] scopes. Obviously, open explicit scopes - * are errors. - */ -int -macro_end(struct mdoc *mdoc) +static int +macro_phrase(struct mdoc *mdoc, int line, int ppos, char *buf) { - struct mdoc_node *n; + int i, la, c; - assert(mdoc->first); - assert(mdoc->last); + for (i = ppos; buf[i]; ) { + assert(' ' != buf[i]); - /* Scan for open explicit scopes. */ + la = i; + if ('\"' == buf[i]) { + la = ++i; + while (buf[i] && '\"' != buf[i]) + i++; + if (0 == buf[i]) + return(mdoc_err(mdoc, "unterminated quoted parameter")); + } else + while (buf[i] && ! isspace ((unsigned char)buf[i])) + i++; - n = MDOC_VALID & mdoc->last->flags ? - mdoc->last->parent : mdoc->last; + if (buf[i]) + buf[i++] = 0; - for ( ; n; n = n->parent) { - if (MDOC_BLOCK != n->type) - continue; - if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags)) - continue; - return(mdoc_nerr(mdoc, n, - "macro scope still open on exit")); + while (buf[i] && isspace((unsigned char)buf[i])) + i++; + + if (MDOC_MAX != (c = mdoc_tokhash_find(mdoc->htab, &buf[la]))) { + if ( ! mdoc_macro(mdoc, c, line, la, &i, buf)) + return(0); + return(append_delims(mdoc, line, &i, buf)); + } + + if ( ! mdoc_word_alloc(mdoc, line, la, &buf[la])) + return(0); + mdoc->next = MDOC_NEXT_SIBLING; + + while (buf[i] && isspace((unsigned char)buf[i])) + i++; } - return(rewind_last(mdoc, mdoc->first)); + return(1); }