=================================================================== RCS file: /cvs/mandoc/Attic/macro.c,v retrieving revision 1.6 retrieving revision 1.11 diff -u -p -r1.6 -r1.11 --- mandoc/Attic/macro.c 2008/12/23 05:30:49 1.6 +++ mandoc/Attic/macro.c 2008/12/29 18:08:44 1.11 @@ -1,4 +1,4 @@ -/* $Id: macro.c,v 1.6 2008/12/23 05:30:49 kristaps Exp $ */ +/* $Id: macro.c,v 1.11 2008/12/29 18:08:44 kristaps Exp $ */ /* * Copyright (c) 2008 Kristaps Dzonsons * @@ -21,185 +21,118 @@ #include #include #include +#ifdef __linux__ +#include +#endif #include "private.h" +/* FIXME: maxlineargs should be per LINE, no per TOKEN. */ + #define _CC(p) ((const char **)p) static int scope_rewind_exp(struct mdoc *, int, int, int); +static int scope_rewind_imp(struct mdoc *, int, int); static int append_text(struct mdoc *, int, int, int, char *[]); +static int append_const(struct mdoc *, int, int, int, char *[]); static int append_scoped(struct mdoc *, int, int, int, const char *[], int, const struct mdoc_arg *); -static int args_next(struct mdoc *, int, - int *, char *, char **); -static int argv_next(struct mdoc *, int, - int *, char *, struct mdoc_arg *); -static int args_next_quoted(struct mdoc *, int, - int *, char *, char **); +static int append_delims(struct mdoc *, int, int *, char *); static int -args_next_quoted(struct mdoc *mdoc, int tok, - int *pos, char *buf, char **v) +append_delims(struct mdoc *mdoc, int tok, int *pos, char *buf) { + int c, lastarg; + char *p; if (0 == buf[*pos]) - return(0); + return(1); - assert( ! isspace(buf[*pos])); + mdoc_msg(mdoc, *pos, "`%s' flushing punctuation", + mdoc_macronames[tok]); - if ('\"' != buf[*pos]) - return(args_next(mdoc, tok, pos, buf, v)); - - *v = &buf[++(*pos)]; - - while (buf[*pos] && '\"' != buf[*pos]) - (*pos)++; - - if (0 == buf[*pos]) { - (void)mdoc_err(mdoc, tok, *pos, ERR_SYNTAX_UNQUOTE); - return(-1); + for (;;) { + lastarg = *pos; + c = mdoc_args(mdoc, tok, pos, buf, 0, &p); + if (ARGS_ERROR == c) + return(0); + else if (ARGS_EOLN == c) + break; + assert(mdoc_isdelim(p)); + mdoc_word_alloc(mdoc, lastarg, p); } - buf[(*pos)++] = 0; - if (0 == buf[*pos]) - return(1); - - while (buf[*pos] && isspace(buf[*pos])) - (*pos)++; - - if (0 == buf[*pos]) - if ( ! mdoc_warn(mdoc, tok, *pos, WARN_SYNTAX_WS_EOLN)) - return(-1); - return(1); } static int -scope_rewind_exp(struct mdoc *mdoc, int ppos, int tok, int dst) +scope_rewind_imp(struct mdoc *mdoc, int ppos, int tok) { struct mdoc_node *n; + int t; + n = mdoc->last ? mdoc->last->parent : NULL; + /* LINTED */ - for (n = mdoc->last; n; n = n->parent) { + for ( ; n; n = n->parent) { if (MDOC_BLOCK != n->type) continue; - if (dst == n->data.block.tok) + if (tok == (t = n->data.block.tok)) break; + if ( ! (MDOC_EXPLICIT & mdoc_macros[t].flags)) + continue; return(mdoc_err(mdoc, tok, ppos, ERR_SCOPE_BREAK)); } - if (NULL == (mdoc->last = n)) - return(mdoc_err(mdoc, tok, ppos, ERR_SCOPE_NOCTX)); + if (n) { + mdoc->last = n; + mdoc_msg(mdoc, ppos, "scope: rewound implicit `%s'", + mdoc_macronames[tok]); + return(1); + } - mdoc_msg(mdoc, ppos, "scope: rewound `%s' to `%s'", - mdoc_macronames[tok], mdoc_macronames[dst]); - + mdoc_msg(mdoc, ppos, "scope: new implicit `%s'", + mdoc_macronames[tok]); return(1); } static int -argv_next(struct mdoc *mdoc, int tok, - int *pos, char *buf, struct mdoc_arg *v) +scope_rewind_exp(struct mdoc *mdoc, int ppos, int tok, int dst) { - char *argv; - int i, val; + struct mdoc_node *n; - if (0 == buf[*pos]) - return(0); + assert(mdoc->last); - assert( ! isspace(buf[*pos])); - - if ('-' != buf[*pos]) { - (void)mdoc_err(mdoc, tok, *pos, ERR_SYNTAX_ARGS); - return(-1); + /* LINTED */ + for (n = mdoc->last->parent; n; n = n->parent) { + if (MDOC_BLOCK != n->type) + continue; + if (dst == n->data.block.tok) + break; + return(mdoc_err(mdoc, tok, ppos, ERR_SCOPE_BREAK)); } - i = *pos; - argv = &buf[++(*pos)]; + if (NULL == (mdoc->last = n)) + return(mdoc_err(mdoc, tok, ppos, ERR_SCOPE_NOCTX)); - while (buf[*pos] && ! isspace(buf[*pos])) - (*pos)++; + mdoc_msg(mdoc, ppos, "scope: rewound explicit `%s' to `%s'", + mdoc_macronames[tok], mdoc_macronames[dst]); - if (buf[*pos]) - buf[(*pos)++] = 0; - - /* - * XXX This is a little bit ugly. The mdoc_argv structure - * points to a pointer array, which we allocate on-the-fly in - * this function. If there's any failure, we need to release - * this memory, which is done by the caller of this function - * with mdoc_argv_free. Ew. This should be simpler. - */ - - if (MDOC_ARG_MAX == (val = mdoc_argv_lookup(tok, argv))) { - (void)mdoc_err(mdoc, tok, i, ERR_SYNTAX_BADARG); - return(-1); - } - - while (buf[*pos] && isspace(buf[*pos])) - (*pos)++; - - if ( ! mdoc_argv_parse(mdoc, tok, val, v, pos, buf)) - return(-1); - return(1); } static int -args_next(struct mdoc *mdoc, int tok, - int *pos, char *buf, char **v) -{ - - if (0 == buf[*pos]) - return(0); - - assert( ! isspace(buf[*pos])); - - if ('\"' == buf[*pos]) { - (void)mdoc_err(mdoc, tok, *pos, ERR_SYNTAX_QUOTE); - return(-1); - } - - *v = &buf[*pos]; - - /* Scan ahead to end of token. */ - - while (buf[*pos] && ! isspace(buf[*pos])) - (*pos)++; - - if (buf[*pos] && buf[*pos + 1] && '\\' == buf[*pos]) { - (void)mdoc_err(mdoc, tok, *pos, ERR_SYNTAX_WS); - return(-1); - } - - if (0 == buf[*pos]) - return(1); - - /* Scan ahead over trailing whitespace. */ - - buf[(*pos)++] = 0; - while (buf[*pos] && isspace(buf[*pos])) - (*pos)++; - - if (0 == buf[*pos]) - if ( ! mdoc_warn(mdoc, tok, *pos, WARN_SYNTAX_WS_EOLN)) - return(-1); - - return(1); -} - - -static int append_scoped(struct mdoc *mdoc, int tok, int pos, int sz, const char *args[], int argc, const struct mdoc_arg *argv) { - enum mdoc_sec sec; + enum mdoc_sec sec; + struct mdoc_node *node; switch (tok) { /* ======= ADD MORE MACRO CHECKS BELOW. ======= */ @@ -224,6 +157,19 @@ append_scoped(struct mdoc *mdoc, int tok, int pos, if (0 == sz) return(mdoc_err(mdoc, tok, pos, ERR_ARGS_GE1)); break; + + case (MDOC_Bd): + assert(mdoc->last); + node = mdoc->last->parent; + /* LINTED */ + for ( ; node; node = node->parent) { + if (node->type != MDOC_BLOCK) + continue; + if (node->data.block.tok != MDOC_Bd) + continue; + return(mdoc_err(mdoc, tok, pos, ERR_SCOPE_NONEST)); + } + break; case (MDOC_Bl): break; @@ -242,6 +188,72 @@ append_scoped(struct mdoc *mdoc, int tok, int pos, static int +append_const(struct mdoc *mdoc, int tok, + int pos, int sz, char *args[]) +{ + + switch (tok) { + /* ======= ADD MORE MACRO CHECKS BELOW. ======= */ + case (MDOC_At): + /* This needs special handling. */ + if (0 == sz) + break; + else if (sz > 2) + return(mdoc_err(mdoc, tok, pos, ERR_ARGS_LE2)); + + if (ATT_DEFAULT != mdoc_atoatt(args[0])) { + mdoc_elem_alloc(mdoc, pos, tok, 0, + NULL, 1, _CC(&args[0])); + } else { + mdoc_elem_alloc(mdoc, pos, tok, + 0, NULL, 0, NULL); + if (mdoc_isdelim(args[0])) + return(mdoc_err(mdoc, tok, pos, ERR_SYNTAX_NOPUNCT)); + mdoc_word_alloc(mdoc, pos, args[0]); + } + + if (1 == sz) + return(1); + if (mdoc_isdelim(args[1])) + return(mdoc_err(mdoc, tok, pos, ERR_SYNTAX_NOPUNCT)); + mdoc_word_alloc(mdoc, pos, args[1]); + return(1); + + case (MDOC_Bx): + /* FALLTHROUGH */ + case (MDOC_Bsx): + /* FALLTHROUGH */ + case (MDOC_Os): + /* FALLTHROUGH */ + case (MDOC_Fx): + /* FALLTHROUGH */ + case (MDOC_Nx): + assert(sz <= 1); + break; + + case (MDOC_Ux): + assert(0 == sz); + break; + + case (MDOC_Bt): + /* FALLTHROUGH */ + case (MDOC_Ud): + if (0 == sz) + break; + return(mdoc_err(mdoc, tok, pos, ERR_ARGS_EQ0)); + + /* ======= ADD MORE MACRO CHECKS ABOVE. ======= */ + default: + abort(); + /* NOTREACHED */ + } + + mdoc_elem_alloc(mdoc, pos, tok, 0, NULL, (size_t)sz, _CC(args)); + return(1); +} + + +static int append_text(struct mdoc *mdoc, int tok, int pos, int sz, char *args[]) { @@ -251,6 +263,13 @@ append_text(struct mdoc *mdoc, int tok, switch (tok) { /* ======= ADD MORE MACRO CHECKS BELOW. ======= */ + case (MDOC_Pp): + if (0 == sz) + break; + if ( ! mdoc_warn(mdoc, tok, pos, WARN_ARGS_EQ0)) + return(0); + break; + case (MDOC_Ft): /* FALLTHROUGH */ case (MDOC_Li): @@ -265,12 +284,15 @@ append_text(struct mdoc *mdoc, int tok, if ( ! mdoc_warn(mdoc, tok, pos, WARN_ARGS_GE1)) return(0); break; + case (MDOC_Ar): /* FALLTHROUGH */ case (MDOC_Cm): /* FALLTHROUGH */ case (MDOC_Fl): + /* These can have no arguments. */ break; + case (MDOC_Ad): /* FALLTHROUGH */ case (MDOC_Em): @@ -297,8 +319,7 @@ append_text(struct mdoc *mdoc, int tok, /* NOTREACHED */ } - mdoc_elem_alloc(mdoc, pos, tok, 0, - NULL, (size_t)sz, _CC(args)); + mdoc_elem_alloc(mdoc, pos, tok, 0, NULL, (size_t)sz, _CC(args)); return(1); } @@ -306,62 +327,115 @@ append_text(struct mdoc *mdoc, int tok, int macro_text(MACRO_PROT_ARGS) { - int lastarg, c, lasttok, lastpunct, j; + int lastarg, lastpunct, c, j; char *args[MDOC_LINEARG_MAX], *p; - lasttok = ppos; - lastpunct = 0; - j = 0; - if (SEC_PROLOGUE == mdoc->sec_lastn) return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE)); -again: - lastarg = *pos; + /* Token pre-processing. */ + switch (tok) { + case (MDOC_Pp): + /* `.Pp' ignored when following `.Sh' or `.Ss'. */ + assert(mdoc->last); + if (MDOC_BODY != mdoc->last->type) + break; + switch (mdoc->last->data.body.tok) { + case (MDOC_Ss): + /* FALLTHROUGH */ + case (MDOC_Sh): + if ( ! mdoc_warn(mdoc, tok, ppos, WARN_IGN_AFTER_BLK)) + return(0); + return(1); + default: + break; + } + break; + default: + break; + } + + /* Process line parameters. */ + + j = 0; + lastarg = ppos; + lastpunct = 0; + +again: if (j == MDOC_LINEARG_MAX) return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); - c = args_next(mdoc, tok, pos, buf, &args[j]); - - if (-1 == c) + + /* + * Parse out the next argument, unquoted and unescaped. If + * we're a word (which may be punctuation followed eventually by + * a real word), then fall into checking for callables. If + * only punctuation remains and we're the first, then flush + * arguments, punctuation and exit; else, return to the caller. + */ + + lastarg = *pos; + + switch (mdoc_args(mdoc, tok, pos, buf, ARGS_DELIM, &args[j])) { + case (ARGS_ERROR): return(0); - if (0 == c && ! lastpunct) - return(append_text(mdoc, tok, lasttok, j, args)); - else if (0 == c) - return(1); + case (ARGS_WORD): + break; + case (ARGS_PUNCT): + if ( ! lastpunct && ! append_text(mdoc, tok, ppos, j, args)) + return(0); + if (ppos > 1) + return(1); + return(append_delims(mdoc, tok, pos, buf)); + case (ARGS_EOLN): + if (lastpunct) + return(1); + return(append_text(mdoc, tok, ppos, j, args)); + default: + abort(); + /* NOTREACHED */ + } - /* Command found. */ + /* + * Command found. First flush out arguments, then call the + * command. If we're the line macro when it exits, flush + * terminal punctuation. + */ if (MDOC_MAX != (c = mdoc_find(mdoc, args[j]))) { - if ( ! lastpunct) - if ( ! append_text(mdoc, tok, lasttok, j, args)) - return(0); - return(mdoc_macro(mdoc, c, lastarg, pos, buf)); + if ( ! lastpunct && ! append_text(mdoc, tok, ppos, j, args)) + return(0); + if ( ! mdoc_macro(mdoc, c, lastarg, pos, buf)) + return(0); + if (ppos > 1) + return(1); + return(append_delims(mdoc, tok, pos, buf)); } - /* Word found. */ + /* Word/non-term-punctuation found. */ if ( ! mdoc_isdelim(args[j])) { + /* Words are appended to the array of arguments. */ j++; + lastpunct = 0; goto again; } - /* Punctuation found. */ + /* + * For punctuation, flush all collected words, then flush + * punctuation, then start collecting again. Of course, this + * is non-terminal punctuation. + */ - p = args[j]; /* Save argument (NULL-ified in append). */ + p = args[j]; + if ( ! lastpunct && ! append_text(mdoc, tok, ppos, j, args)) + return(0); - if ( ! lastpunct) - if ( ! append_text(mdoc, tok, lasttok, j, args)) - return(0); - - args[j] = p; - - mdoc_word_alloc(mdoc, lastarg, args[j]); - lastpunct = 1; + mdoc_word_alloc(mdoc, lastarg, p); j = 0; + lastpunct = 1; goto again; - /* NOTREACHED */ } @@ -369,7 +443,7 @@ again: int macro_prologue_dtitle(MACRO_PROT_ARGS) { - int c, lastarg, j; + int lastarg, j; char *args[MDOC_LINEARG_MAX]; if (SEC_PROLOGUE != mdoc->sec_lastn) @@ -380,15 +454,16 @@ macro_prologue_dtitle(MACRO_PROT_ARGS) return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE_REP)); j = -1; + lastarg = ppos; again: - lastarg = *pos; - if (j == MDOC_LINEARG_MAX) return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); - c = args_next(mdoc, tok, pos, buf, &args[++j]); - if (0 == c) { + lastarg = *pos; + + switch (mdoc_args(mdoc, tok, pos, buf, 0, &args[++j])) { + case (ARGS_EOLN): if (mdoc->meta.title) return(1); if ( ! mdoc_warn(mdoc, tok, ppos, WARN_ARGS_GE1)) @@ -396,9 +471,12 @@ again: (void)xstrlcpy(mdoc->meta.title, "UNTITLED", META_TITLE_SZ); return(1); - } else if (-1 == c) + case (ARGS_ERROR): return(0); - + default: + break; + } + if (MDOC_MAX != mdoc_find(mdoc, args[j]) && ! mdoc_warn (mdoc, tok, lastarg, WARN_SYNTAX_MACLIKE)) return(0); @@ -406,13 +484,13 @@ again: if (0 == j) { if (xstrlcpy(mdoc->meta.title, args[0], META_TITLE_SZ)) goto again; - return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGS)); + return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGFORM)); } else if (1 == j) { mdoc->meta.msec = mdoc_atomsec(args[1]); if (MSEC_DEFAULT != mdoc->meta.msec) goto again; - return(mdoc_err(mdoc, tok, -1, ERR_SYNTAX_ARGS)); + return(mdoc_err(mdoc, tok, -1, ERR_SYNTAX_ARGFORM)); } else if (2 == j) { mdoc->meta.vol = mdoc_atovol(args[2]); @@ -421,7 +499,7 @@ again: mdoc->meta.arch = mdoc_atoarch(args[2]); if (ARCH_DEFAULT != mdoc->meta.arch) goto again; - return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGS)); + return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGFORM)); } return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); @@ -431,7 +509,7 @@ again: int macro_prologue_os(MACRO_PROT_ARGS) { - int c, lastarg, j; + int lastarg, j; char *args[MDOC_LINEARG_MAX]; if (SEC_PROLOGUE != mdoc->sec_lastn) @@ -442,24 +520,29 @@ macro_prologue_os(MACRO_PROT_ARGS) return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE_REP)); j = -1; + lastarg = ppos; again: - lastarg = *pos; - if (j == MDOC_LINEARG_MAX) return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); - c = args_next_quoted(mdoc, tok, pos, buf, &args[++j]); - if (0 == c) { + lastarg = *pos; + + switch (mdoc_args(mdoc, tok, pos, buf, + ARGS_QUOTED, &args[++j])) { + case (ARGS_EOLN): mdoc->sec_lastn = mdoc->sec_last = SEC_BODY; return(1); - } else if (-1 == c) + case (ARGS_ERROR): return(0); + default: + break; + } if ( ! xstrlcat(mdoc->meta.os, args[j], sizeof(mdoc->meta.os))) - return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGS)); + return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGFORM)); if ( ! xstrlcat(mdoc->meta.os, " ", sizeof(mdoc->meta.os))) - return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGS)); + return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGFORM)); goto again; /* NOTREACHED */ @@ -469,7 +552,7 @@ again: int macro_prologue_ddate(MACRO_PROT_ARGS) { - int c, lastarg, j; + int lastarg, j; char *args[MDOC_LINEARG_MAX], date[64]; if (SEC_PROLOGUE != mdoc->sec_lastn) @@ -481,30 +564,33 @@ macro_prologue_ddate(MACRO_PROT_ARGS) j = -1; date[0] = 0; + lastarg = ppos; again: - lastarg = *pos; - if (j == MDOC_LINEARG_MAX) return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); - c = args_next(mdoc, tok, pos, buf, &args[++j]); - if (0 == c) { + lastarg = *pos; + switch (mdoc_args(mdoc, tok, pos, buf, 0, &args[++j])) { + case (ARGS_EOLN): if (mdoc->meta.date) return(1); mdoc->meta.date = mdoc_atotime(date); if (mdoc->meta.date) return(1); - return(mdoc_err(mdoc, tok, ppos, ERR_SYNTAX_ARGS)); - } else if (-1 == c) + return(mdoc_err(mdoc, tok, ppos, ERR_SYNTAX_ARGFORM)); + case (ARGS_ERROR): return(0); + default: + break; + } if (MDOC_MAX != mdoc_find(mdoc, args[j]) && ! mdoc_warn (mdoc, tok, lastarg, WARN_SYNTAX_MACLIKE)) return(0); if (0 == j) { - if (xstrcmp("$Mdocdate: December 23 2008 $", args[j])) { + if (xstrcmp("$Mdocdate: December 29 2008 $", args[j])) { mdoc->meta.date = time(NULL); goto again; } else if (xstrcmp("$Mdocdate:", args[j])) @@ -514,9 +600,9 @@ again: goto again; if ( ! xstrlcat(date, args[j], sizeof(date))) - return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGS)); + return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGFORM)); if ( ! xstrlcat(date, " ", sizeof(date))) - return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGS)); + return(mdoc_err(mdoc, tok, lastarg, ERR_SYNTAX_ARGFORM)); goto again; /* NOTREACHED */ @@ -528,6 +614,7 @@ macro_scoped_explicit(MACRO_PROT_ARGS) { int c, lastarg, j; struct mdoc_arg argv[MDOC_LINEARG_MAX]; + struct mdoc_node *n; if (SEC_PROLOGUE == mdoc->sec_lastn) return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE)); @@ -541,17 +628,43 @@ macro_scoped_explicit(MACRO_PROT_ARGS) switch (tok) { case (MDOC_El): return(scope_rewind_exp(mdoc, ppos, tok, MDOC_Bl)); + case (MDOC_Ed): + return(scope_rewind_exp(mdoc, ppos, tok, MDOC_Bd)); default: break; } assert(MDOC_EXPLICIT & mdoc_macros[tok].flags); + /* Token pre-processing. */ + + switch (tok) { + case (MDOC_Bl): + /* FALLTHROUGH */ + case (MDOC_Bd): + /* `.Pp' ignored when preceding `.Bl' or `.Bd'. */ + assert(mdoc->last); + if (MDOC_ELEM != mdoc->last->type) + break; + if (MDOC_Pp != mdoc->last->data.elem.tok) + break; + if ( ! mdoc_warn(mdoc, tok, ppos, WARN_IGN_BEFORE_BLK)) + return(0); + assert(mdoc->last->prev); + n = mdoc->last; + mdoc->last = mdoc->last->prev; + mdoc->last->next = NULL; + mdoc_node_free(n); + break; + default: + break; + } + lastarg = *pos; for (j = 0; j < MDOC_LINEARG_MAX; j++) { lastarg = *pos; - c = argv_next(mdoc, tok, pos, buf, &argv[j]); + c = mdoc_argv(mdoc, tok, &argv[j], pos, buf); if (0 == c) break; else if (1 == c) @@ -572,10 +685,22 @@ macro_scoped_explicit(MACRO_PROT_ARGS) } +/* + * Implicity-scoped macros, like `.Ss', have a scope that terminates + * with a subsequent call to the same macro. Implicit macros cannot + * break the scope of explicitly-scoped macros; however, they can break + * the scope of other implicit macros (so `.Sh' can break `.Ss'). This + * is ok with macros like `.It' because they exist only within an + * explicit context. + * + * These macros put line arguments (which it's allowed to have) into the + * HEAD section and open a BODY scope to be used until the macro scope + * closes. + */ int macro_scoped_implicit(MACRO_PROT_ARGS) { - int t, c, lastarg, j; + int lastarg, j; char *args[MDOC_LINEARG_MAX]; struct mdoc_node *n; @@ -584,53 +709,370 @@ macro_scoped_implicit(MACRO_PROT_ARGS) if (SEC_PROLOGUE == mdoc->sec_lastn) return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE)); - /* FIXME: put into scope_rewind_imp(). */ + /* Token pre-processing. */ - /* LINTED */ - for (n = mdoc->last; n; n = n->parent) { - if (MDOC_BLOCK != n->type) - continue; - if (tok == (t = n->data.block.tok)) + switch (tok) { + case (MDOC_Ss): + /* FALLTHROUGH */ + case (MDOC_Sh): + /* `.Pp' ignored when preceding `.Ss' or `.Sh'. */ + if (NULL == mdoc->last) break; - if ( ! (MDOC_EXPLICIT & mdoc_macros[t].flags)) - continue; - return(mdoc_err(mdoc, tok, ppos, ERR_SCOPE_BREAK)); + if (MDOC_ELEM != mdoc->last->type) + break; + if (MDOC_Pp != mdoc->last->data.elem.tok) + break; + if ( ! mdoc_warn(mdoc, tok, ppos, WARN_IGN_BEFORE_BLK)) + return(0); + assert(mdoc->last->prev); + n = mdoc->last; + mdoc_msg(mdoc, ppos, "removing prior `Pp' macro"); + mdoc->last = mdoc->last->prev; + mdoc->last->next = NULL; + mdoc_node_free(n); + break; + default: + break; } - if (n) { - mdoc->last = n; - mdoc_msg(mdoc, ppos, "scope: rewound `%s'", - mdoc_macronames[tok]); - } else - mdoc_msg(mdoc, ppos, "scope: new `%s'", - mdoc_macronames[tok]); + /* Rewind our scope. */ + if ( ! scope_rewind_imp(mdoc, ppos, tok)) + return(0); + j = 0; + lastarg = ppos; + /* + * Process until we hit a line. Note that current implicit + * macros don't have any arguments, so we don't need to do any + * argument processing. + */ + again: + if (j == MDOC_LINEARG_MAX) + return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); + lastarg = *pos; + switch (mdoc_args(mdoc, tok, pos, buf, 0, &args[j])) { + case (ARGS_ERROR): + return(0); + case (ARGS_EOLN): + return(append_scoped(mdoc, tok, ppos, j, _CC(args), 0, NULL)); + default: + break; + } + + if (MDOC_MAX != mdoc_find(mdoc, args[j])) + if ( ! mdoc_warn(mdoc, tok, lastarg, WARN_SYNTAX_MACLIKE)) + return(0); + + j++; + goto again; + /* NOTREACHED */ +} + + +/* + * A line-scoped macro opens a scope for the contents of its line, which + * are placed under the HEAD node. Punctuation trailing the line is put + * as a sibling to the HEAD node, under the BLOCK node. + */ +int +macro_scoped_line(MACRO_PROT_ARGS) +{ + int lastarg, c, j; + char *p; + struct mdoc_node *n; + + if (SEC_PROLOGUE == mdoc->sec_lastn) + return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE)); + + assert(1 == ppos); + + /* Token pre-processing. */ + + switch (tok) { + case (MDOC_D1): + /* FALLTHROUGH */ + case (MDOC_Dl): + /* These can't be nested in a display block. */ + assert(mdoc->last); + for (n = mdoc->last->parent ; n; n = n->parent) + if (MDOC_BLOCK != n->type) + continue; + else if (MDOC_Bd == n->data.block.tok) + break; + if (NULL == n) + break; + return(mdoc_err(mdoc, tok, ppos, ERR_SCOPE_NONEST)); + default: + break; + } + + /* + * All line-scoped macros have a HEAD and optionally a BODY + * section. We open our scope here; when we exit this function, + * we'll rewind our scope appropriately. + */ + + mdoc_block_alloc(mdoc, ppos, tok, 0, NULL); + mdoc_head_alloc(mdoc, ppos, tok, 0, NULL); + + /* Process line parameters. */ + + j = 0; + lastarg = ppos; + +again: if (j == MDOC_LINEARG_MAX) return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); - c = args_next(mdoc, tok, pos, buf, &args[j]); - - if (-1 == c) + + lastarg = *pos; + c = mdoc_args(mdoc, tok, pos, buf, ARGS_DELIM, &p); + + switch (c) { + case (ARGS_ERROR): return(0); - if (0 == c) - return(append_scoped(mdoc, tok, ppos, - j, _CC(args), 0, NULL)); + case (ARGS_WORD): + break; + case (ARGS_PUNCT): + if ( ! append_delims(mdoc, tok, pos, buf)) + return(0); + return(scope_rewind_imp(mdoc, ppos, tok)); + case (ARGS_EOLN): + return(scope_rewind_imp(mdoc, ppos, tok)); + default: + abort(); + /* NOTREACHED */ + } - /* Command found. */ + if (MDOC_MAX != (c = mdoc_find(mdoc, p))) { + if ( ! mdoc_macro(mdoc, c, lastarg, pos, buf)) + return(0); + if ( ! append_delims(mdoc, tok, pos, buf)) + return(0); + return(scope_rewind_imp(mdoc, ppos, tok)); + } - if (MDOC_MAX != (c = mdoc_find(mdoc, args[j]))) - if ( ! mdoc_warn(mdoc, tok, lastarg, WARN_SYNTAX_MACLIKE)) + if (mdoc_isdelim(p)) + j = 0; + + mdoc_word_alloc(mdoc, lastarg, p); + goto again; + /* NOTREACHED */ +} + + +/* + * Partial-line scope is identical to line scope (macro_scoped_line()) + * except that trailing punctuation is appended to the BLOCK, instead of + * contained within the HEAD. + */ +int +macro_scoped_pline(MACRO_PROT_ARGS) +{ + int lastarg, c, j; + char *p; + + if (SEC_PROLOGUE == mdoc->sec_lastn) + return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE)); + + /* Token pre-processing. */ + + switch (tok) { + case (MDOC_Ql): + if ( ! mdoc_warn(mdoc, tok, ppos, WARN_COMPAT_TROFF)) return(0); + break; + default: + break; + } - /* Word found. */ + mdoc_block_alloc(mdoc, ppos, tok, 0, NULL); + mdoc_head_alloc(mdoc, ppos, tok, 0, NULL); - j++; + /* Process line parameters. */ + + j = 0; + lastarg = ppos; + +again: + if (j == MDOC_LINEARG_MAX) + return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); + + lastarg = *pos; + c = mdoc_args(mdoc, tok, pos, buf, ARGS_DELIM, &p); + + switch (c) { + case (ARGS_ERROR): + return(0); + case (ARGS_WORD): + break; + case (ARGS_PUNCT): + if ( ! scope_rewind_imp(mdoc, ppos, tok)) + return(0); + if (ppos > 1) + return(1); + return(append_delims(mdoc, tok, pos, buf)); + case (ARGS_EOLN): + return(scope_rewind_imp(mdoc, ppos, tok)); + default: + abort(); + /* NOTREACHED */ + } + + if (MDOC_MAX != (c = mdoc_find(mdoc, p))) { + if ( ! mdoc_macro(mdoc, c, lastarg, pos, buf)) + return(0); + if ( ! scope_rewind_imp(mdoc, ppos, tok)) + return(0); + if (ppos > 1) + return(1); + return(append_delims(mdoc, tok, pos, buf)); + } + + if (mdoc_isdelim(p)) + j = 0; + + mdoc_word_alloc(mdoc, lastarg, p); goto again; + /* NOTREACHED */ +} + +/* + * A delimited-constant macro is similar to a general text macro: the + * macro is followed by a 0 or 1 arguments (possibly-unspecified) then + * terminating punctuation, other words, or another callable macro. + */ +int +macro_constant_delimited(MACRO_PROT_ARGS) +{ + int lastarg, flushed, c, maxargs; + char *p, *pp; + + if (SEC_PROLOGUE == mdoc->sec_lastn) + return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE)); + + /* Process line parameters. */ + + lastarg = ppos; + flushed = 0; + + /* Token pre-processing. */ + + switch (tok) { + case (MDOC_Ux): + maxargs = 0; + break; + default: + maxargs = 1; + break; + } + +again: + lastarg = *pos; + + switch (mdoc_args(mdoc, tok, pos, buf, ARGS_DELIM, &p)) { + case (ARGS_ERROR): + return(0); + case (ARGS_WORD): + break; + case (ARGS_PUNCT): + if ( ! flushed && ! append_const(mdoc, tok, ppos, 0, &p)) + return(0); + if (ppos > 1) + return(1); + return(append_delims(mdoc, tok, pos, buf)); + case (ARGS_EOLN): + if (flushed) + return(1); + return(append_const(mdoc, tok, ppos, 0, &p)); + default: + abort(); + /* NOTREACHED */ + } + + /* Accepts no arguments: flush out symbol and continue. */ + + if (0 == maxargs) { + pp = p; + if ( ! append_const(mdoc, tok, ppos, 0, &p)) + return(0); + p = pp; + flushed = 1; + } + + if (MDOC_MAX != (c = mdoc_find(mdoc, p))) { + if ( ! flushed && ! append_const(mdoc, tok, ppos, 0, &p)) + return(0); + if ( ! mdoc_macro(mdoc, c, lastarg, pos, buf)) + return(0); + if (ppos > 1) + return(1); + return(append_delims(mdoc, tok, pos, buf)); + } + + /* + * We only accept one argument; subsequent tokens are considered + * as literal words (until a macro). + */ + + if ( ! flushed && ! mdoc_isdelim(p)) { + if ( ! append_const(mdoc, tok, ppos, 1, &p)) + return(0); + flushed = 1; + goto again; + } else if ( ! flushed) { + pp = p; + if ( ! append_const(mdoc, tok, ppos, 0, &p)) + return(0); + p = pp; + flushed = 1; + } + + mdoc_word_alloc(mdoc, lastarg, p); + goto again; /* NOTREACHED */ } + +int +macro_constant(MACRO_PROT_ARGS) +{ + int lastarg, j; + char *args[MDOC_LINEARG_MAX]; + + if (SEC_PROLOGUE == mdoc->sec_lastn) + return(mdoc_err(mdoc, tok, ppos, ERR_SEC_PROLOGUE)); + + j = 0; + +again: + if (j == MDOC_LINEARG_MAX) + return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY)); + + lastarg = *pos; + + switch (mdoc_args(mdoc, tok, pos, buf, 0, &args[j])) { + case (ARGS_ERROR): + return(0); + case (ARGS_WORD): + break; + case (ARGS_EOLN): + return(append_const(mdoc, tok, ppos, j, args)); + default: + abort(); + /* NOTREACHED */ + } + + if (MDOC_MAX != mdoc_find(mdoc, args[j])) + if ( ! mdoc_warn(mdoc, tok, lastarg, WARN_SYNTAX_MACLIKE)) + return(0); + + j++; + goto again; + /* NOTREACHED */ +}