-/* $Id: macro.c,v 1.7 2008/12/28 00:34:20 kristaps Exp $ */
+/* $Id: macro.c,v 1.11 2008/12/29 18:08:44 kristaps Exp $ */
/*
* Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
*
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
+#ifdef __linux__
+#include <time.h>
+#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 append_delims(struct mdoc *, int, int *, char *);
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;
case (MDOC_Bd):
assert(mdoc->last);
- for (node = mdoc->last->parent; node; node = node->parent) {
+ node = mdoc->last->parent;
+ /* LINTED */
+ for ( ; node; node = node->parent) {
if (node->type != MDOC_BLOCK)
continue;
if (node->data.block.tok != MDOC_Bd)
}
+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[])
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();
if ( ! mdoc_isdelim(args[j])) {
/* Words are appended to the array of arguments. */
j++;
- lastpunct = 1;
+ lastpunct = 0;
goto again;
}
lastpunct = 1;
goto again;
-
/* NOTREACHED */
}
return(0);
if (0 == j) {
- if (xstrcmp("$Mdocdate: December 28 2008 $", args[j])) {
+ if (xstrcmp("$Mdocdate: December 29 2008 $", args[j])) {
mdoc->meta.date = time(NULL);
goto again;
} else if (xstrcmp("$Mdocdate:", args[j]))
}
+/*
+ * 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)
{
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;
}
+ /* 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_Sh):
+ case (MDOC_D1):
/* FALLTHROUGH */
- case (MDOC_Ss):
- if ( ! scope_rewind_imp(mdoc, ppos, tok))
+ 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 */
+}
+
+
+/*
+ * 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;
}
+ mdoc_block_alloc(mdoc, ppos, tok, 0, NULL);
+ mdoc_head_alloc(mdoc, ppos, tok, 0, NULL);
+
+ /* Process line parameters. */
+
j = 0;
lastarg = ppos;
return(mdoc_err(mdoc, tok, lastarg, ERR_ARGS_MANY));
lastarg = *pos;
+ c = mdoc_args(mdoc, tok, pos, buf, ARGS_DELIM, &p);
- switch (mdoc_args(mdoc, tok, pos, buf, 0, &args[j])) {
+ 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(append_scoped(mdoc, tok, ppos, j, _CC(args), 0, NULL));
+ 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;
}
- /* Command found. */
+again:
+ lastarg = *pos;
- if (MDOC_MAX != mdoc_find(mdoc, args[j]))
- if ( ! mdoc_warn(mdoc, tok, lastarg, WARN_SYNTAX_MACLIKE))
+ 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 */
+ }
- /* Word found. */
+ /* Accepts no arguments: flush out symbol and continue. */
- j++;
- goto again;
+ 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_scoped_line(MACRO_PROT_ARGS)
+macro_constant(MACRO_PROT_ARGS)
{
+ int lastarg, j;
+ char *args[MDOC_LINEARG_MAX];
- return(1);
+ 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 */
}
git.ckatri.com / mandoc.git / blobdiff