diff options
| -rw-r--r-- | macro.c | 202 | ||||
| -rw-r--r-- | mdoc.c | 33 | ||||
| -rw-r--r-- | mdocml.c | 20 | ||||
| -rw-r--r-- | private.h | 3 |
4 files changed, 214 insertions, 44 deletions
@@ -44,7 +44,8 @@ append_delims(struct mdoc *mdoc, int tok, int *pos, char *buf) if (0 == buf[*pos]) return(1); - mdoc_msg(mdoc, *pos, "appending delimiters"); + mdoc_msg(mdoc, *pos, "`%s' flushing punctuation", + mdoc_macronames[tok]); for (;;) { lastarg = *pos; @@ -309,8 +310,12 @@ again: 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(); @@ -338,7 +343,7 @@ again: if ( ! mdoc_isdelim(args[j])) { /* Words are appended to the array of arguments. */ j++; - lastpunct = 1; + lastpunct = 0; goto again; } @@ -357,7 +362,6 @@ again: lastpunct = 1; goto again; - /* NOTREACHED */ } @@ -607,6 +611,18 @@ 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) { @@ -636,6 +652,7 @@ macro_scoped_implicit(MACRO_PROT_ARGS) 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); @@ -644,20 +661,20 @@ macro_scoped_implicit(MACRO_PROT_ARGS) break; } - switch (tok) { - case (MDOC_Sh): - /* FALLTHROUGH */ - case (MDOC_Ss): - if ( ! scope_rewind_imp(mdoc, ppos, tok)) - return(0); - break; - default: - break; - } + /* 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)); @@ -673,24 +690,171 @@ again: break; } - /* Command found. */ - if (MDOC_MAX != mdoc_find(mdoc, args[j])) if ( ! mdoc_warn(mdoc, tok, lastarg, WARN_SYNTAX_MACLIKE)) return(0); - /* Word found. */ - 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; - return(1); + 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)); + + 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 ( ! 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 */ + } + + 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_isdelim(p)) + j = 0; + + mdoc_word_alloc(mdoc, lastarg, p); + goto again; + /* NOTREACHED */ } + + +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) { + default: + break; + } + + 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)); + + 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 */ +} + @@ -90,8 +90,8 @@ const struct mdoc_macro __mdoc_macros[MDOC_MAX] = { { macro_scoped_implicit, 0 }, /* Sh */ { macro_scoped_implicit, 0 }, /* Ss */ { macro_text, 0 }, /* Pp */ - { NULL, 0 }, /* D1 */ - { NULL, 0 }, /* Dl */ + { macro_scoped_line, 0 }, /* D1 */ + { macro_scoped_line, 0 }, /* Dl */ { macro_scoped_explicit, MDOC_EXPLICIT }, /* Bd */ { macro_scoped_explicit, 0 }, /* Ed */ { macro_scoped_explicit, MDOC_EXPLICIT }, /* Bl */ @@ -166,7 +166,7 @@ const struct mdoc_macro __mdoc_macros[MDOC_MAX] = { { NULL, 0 }, /* Qc */ { NULL, 0 }, /* Ql */ { NULL, 0 }, /* Qo */ - { NULL, 0 }, /* Qq */ + { macro_scoped_pline, MDOC_CALLABLE }, /* Qq */ { NULL, 0 }, /* Re */ { NULL, 0 }, /* Rs */ { NULL, 0 }, /* Sc */ @@ -336,6 +336,8 @@ mdoc_macro(struct mdoc *mdoc, int tok, int ppos, int *pos, char *buf) return(0); } + /*mdoc_msg(mdoc, ppos, "calling `%s'", mdoc_macronames[tok]);*/ + return((*mdoc_macros[tok].fp)(mdoc, tok, ppos, pos, buf)); } @@ -407,35 +409,25 @@ mdoc_node_append(struct mdoc *mdoc, int pos, struct mdoc_node *p) switch (p->type) { case (MDOC_BODY): - switch (mdoc->last->type) { - case (MDOC_BLOCK): - p->parent = mdoc->last; - mdoc->last->child = p; - act = "child"; - break; - case (MDOC_HEAD): - p->parent = mdoc->last->parent; - mdoc->last->next = p; - p->prev = mdoc->last; - act = "sibling"; - break; - default: - abort(); - /* NOTREACHED */ - } + p->parent = mdoc->last->parent; + mdoc->last->next = p; + p->prev = mdoc->last; + act = "sibling"; break; + case (MDOC_HEAD): assert(mdoc->last->type == MDOC_BLOCK); p->parent = mdoc->last; mdoc->last->child = p; act = "child"; break; + default: switch (mdoc->last->type) { case (MDOC_BODY): /* FALLTHROUGH */ case (MDOC_HEAD): - p->parent = mdoc->last->parent; + p->parent = mdoc->last; mdoc->last->child = p; act = "child"; break; @@ -455,6 +447,7 @@ mdoc_node_append(struct mdoc *mdoc, int pos, struct mdoc_node *p) } +/* FIXME: deprecate paramsz, params. */ void mdoc_head_alloc(struct mdoc *mdoc, int pos, int tok, size_t paramsz, const char **params) @@ -181,13 +181,16 @@ buf_begin(struct md_parse *p) static void print_node(const struct mdoc_node *n, int indent) { - const char *p, *t; - int i, j; - size_t argc; - struct mdoc_arg *argv; + const char *p, *t; + int i, j; + size_t argc, sz; + char **params; + struct mdoc_arg *argv; argv = NULL; argc = 0; + params = NULL; + sz = 0; switch (n->type) { case (MDOC_TEXT): @@ -202,6 +205,8 @@ print_node(const struct mdoc_node *n, int indent) case (MDOC_HEAD): p = mdoc_macronames[n->data.head.tok]; t = "block-head"; + params = n->data.head.args; + sz = n->data.head.sz; break; case (MDOC_ELEM): assert(NULL == n->child); @@ -209,6 +214,8 @@ print_node(const struct mdoc_node *n, int indent) t = "element"; argv = n->data.elem.argv; argc = n->data.elem.argc; + params = n->data.elem.args; + sz = n->data.elem.sz; break; case (MDOC_BLOCK): p = mdoc_macronames[n->data.block.tok]; @@ -231,6 +238,9 @@ print_node(const struct mdoc_node *n, int indent) (void)printf(" \"%s\"", argv[i].value[j]); } + for (i = 0; i < (int)sz; i++) + (void)printf(" \"%s\"", params[i]); + (void)printf("\n"); if (n->child) @@ -340,7 +350,7 @@ msg_err(void *arg, int tok, int col, enum mdoc_err type) fmt = "scope: closure macro `%s' has no context"; break; case (ERR_SCOPE_NONEST): - fmt = "scope: macro `%s' may not be nested"; + fmt = "scope: macro `%s' may not be nested in the current context"; break; case (ERR_MACRO_NOTSUP): fmt = "macro `%s' not supported"; @@ -37,6 +37,7 @@ struct mdoc_macro { int flags; #define MDOC_CALLABLE (1 << 0) #define MDOC_EXPLICIT (1 << 1) +#define MDOC_PPOST (1 << 2) /* Linescope: punctuation post-line. */ }; extern const struct mdoc_macro *const mdoc_macros; @@ -96,6 +97,8 @@ char *xstrdup(const char *); int macro_text(MACRO_PROT_ARGS); int macro_scoped_implicit(MACRO_PROT_ARGS); int macro_scoped_explicit(MACRO_PROT_ARGS); +int macro_scoped_line(MACRO_PROT_ARGS); +int macro_scoped_pline(MACRO_PROT_ARGS); int macro_prologue_ddate(MACRO_PROT_ARGS); int macro_prologue_dtitle(MACRO_PROT_ARGS); int macro_prologue_os(MACRO_PROT_ARGS); |