-/* $Id: mdoc_macro.c,v 1.4 2009/03/27 14:56:15 kristaps Exp $ */
+/* $Id: mdoc_macro.c,v 1.36 2009/09/20 17:24:57 kristaps Exp $ */
/*
- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
+ * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
*
* Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
*
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <assert.h>
#include <ctype.h>
#include "libmdoc.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.
- */
-
-/* FIXME: .Fl, .Ar, .Cd handling of `|'. */
-
-enum mwarn {
- WIGNE,
- WIMPBRK,
- WMACPARM,
- WOBS
-};
-
-enum merr {
- EOPEN,
- EQUOT,
- ENOCTX,
- ENOPARMS
-};
-
#define REWIND_REWIND (1 << 0)
#define REWIND_NOHALT (1 << 1)
#define REWIND_HALT (1 << 2)
static int rew_alt(int);
static int rew_dobreak(int, const struct mdoc_node *);
static int rew_elem(struct mdoc *, int);
-static int rew_impblock(struct mdoc *, int, int, int);
-static int rew_expblock(struct mdoc *, int, int, int);
-static int rew_subblock(enum mdoc_type,
- struct mdoc *, int, int, int);
-static int rew_last(struct mdoc *, struct mdoc_node *);
+static int rew_sub(enum mdoc_type, struct mdoc *,
+ int, int, int);
+static int rew_last(struct mdoc *,
+ const struct mdoc_node *);
static int append_delims(struct mdoc *, int, int *, char *);
-static int lookup(struct mdoc *, int, int, int, const char *);
-static int pwarn(struct mdoc *, int, int, enum mwarn);
-static int perr(struct mdoc *, int, int, enum merr);
+static int lookup(int, const char *);
+static int lookup_raw(const char *);
static int swarn(struct mdoc *, enum mdoc_type, int, int,
const struct mdoc_node *);
-#define nerr(m, n, t) perr((m), (n)->line, (n)->pos, (t))
-
/* Central table of library: who gets parsed how. */
const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
- { NULL, 0 }, /* \" */
+ { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ap */
{ in_line_eoln, MDOC_PROLOGUE }, /* Dd */
{ in_line_eoln, MDOC_PROLOGUE }, /* Dt */
{ in_line_eoln, MDOC_PROLOGUE }, /* Os */
{ blk_full, 0 }, /* Sh */
{ blk_full, 0 }, /* Ss */
- { in_line, 0 }, /* Pp */
+ { in_line_eoln, 0 }, /* Pp */
{ blk_part_imp, MDOC_PARSED }, /* D1 */
{ blk_part_imp, MDOC_PARSED }, /* Dl */
{ blk_full, MDOC_EXPLICIT }, /* Bd */
{ blk_exp_close, MDOC_EXPLICIT }, /* El */
{ blk_full, MDOC_PARSED }, /* It */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ad */
- { in_line, MDOC_PARSED }, /* An */
+ { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* An */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ar */
- { in_line_eoln, MDOC_CALLABLE }, /* Cd */
+ { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Cd */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Cm */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Dv */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Er */
{ in_line_eoln, 0 }, /* Fd */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Fl */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Fn */
- { in_line, MDOC_PARSED }, /* Ft */
+ { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ft */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ic */
- { in_line_eoln, 0 }, /* In */
+ { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* In */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Li */
- { in_line_eoln, 0 }, /* Nd */
+ { blk_full, 0 }, /* Nd */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Nm */
{ blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Op */
{ obsolete, 0 }, /* Ot */
{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Em */
{ blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Eo */
{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Fx */
- { in_line, MDOC_PARSED }, /* Ms */
+ { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ms */
{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* No */
{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ns */
{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Nx */
{ obsolete, 0 }, /* Fr */
{ in_line_eoln, 0 }, /* Ud */
{ in_line_eoln, 0 }, /* Lb */
- { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ap */
- { in_line, 0 }, /* Lp */
- { in_line, MDOC_PARSED }, /* Lk */
- { in_line, MDOC_PARSED }, /* Mt */
+ { in_line_eoln, 0 }, /* Lp */
+ { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Lk */
+ { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Mt */
{ blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Brq */
{ blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Bro */
{ blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Brc */
{ obsolete, 0 }, /* En */
{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Dx */
{ in_line_eoln, 0 }, /* %Q */
+ { in_line_eoln, 0 }, /* br */
+ { in_line_eoln, 0 }, /* sp */
};
const struct mdoc_macro * const mdoc_macros = __mdoc_macros;
-static int
-perr(struct mdoc *mdoc, int line, int pos, enum merr type)
-{
- char *p;
-
- p = NULL;
- switch (type) {
- case (EOPEN):
- p = "explicit scope still open on exit";
- break;
- case (EQUOT):
- p = "unterminated quotation";
- break;
- case (ENOCTX):
- p = "closure has no prior context";
- break;
- case (ENOPARMS):
- p = "unexpect line arguments";
- break;
- }
- assert(p);
- return(mdoc_perr(mdoc, line, pos, p));
-}
-
-
-static int
-pwarn(struct mdoc *mdoc, int line, int pos, enum mwarn type)
-{
- char *p;
-
- p = NULL;
- switch (type) {
- case (WIGNE):
- p = "ignoring empty element";
- break;
- case (WIMPBRK):
- p = "crufty end-of-line scope violation";
- break;
- case (WMACPARM):
- p = "macro-like parameter";
- break;
- case (WOBS):
- p = "macro marked obsolete";
- break;
- }
- assert(p);
- return(mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX, p));
-}
-
-
static int
swarn(struct mdoc *mdoc, enum mdoc_type type,
int line, int pos, const struct mdoc_node *p)
}
if ( ! (MDOC_IGN_SCOPE & mdoc->pflags))
- return(mdoc_perr(mdoc, line, pos,
+ return(mdoc_verr(mdoc, line, pos,
"%s scope breaks %s scope of %s",
tt, t, n));
- return(mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX,
+ return(mdoc_vwarn(mdoc, line, pos,
"%s scope breaks %s scope of %s",
tt, t, n));
}
* are errors.
*/
int
-mdoc_macroend(struct mdoc *mdoc)
+mdoc_macroend(struct mdoc *m)
{
struct mdoc_node *n;
/* Scan for open explicit scopes. */
- n = MDOC_VALID & mdoc->last->flags ?
- mdoc->last->parent : mdoc->last;
+ n = MDOC_VALID & m->last->flags ? m->last->parent : m->last;
for ( ; n; n = n->parent) {
if (MDOC_BLOCK != n->type)
continue;
if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags))
continue;
- return(nerr(mdoc, n, EOPEN));
+ return(mdoc_nerr(m, n, EOPEN));
}
- return(rew_last(mdoc, mdoc->first));
+ /* Rewind to the first. */
+
+ return(rew_last(m, m->first));
+}
+
+
+/*
+ * Look up a macro from within a subsequent context.
+ */
+static int
+lookup(int from, const char *p)
+{
+ /* FIXME: make -diag lists be un-PARSED. */
+
+ if ( ! (MDOC_PARSED & mdoc_macros[from].flags))
+ return(MDOC_MAX);
+ return(lookup_raw(p));
}
+
+/*
+ * Lookup a macro following the initial line macro.
+ */
static int
-lookup(struct mdoc *mdoc, int line, int pos, int from, const char *p)
+lookup_raw(const char *p)
{
int res;
- res = mdoc_tokhash_find(mdoc->htab, p);
- if (MDOC_PARSED & mdoc_macros[from].flags)
+ if (MDOC_MAX == (res = mdoc_hash_find(p)))
+ return(MDOC_MAX);
+ if (MDOC_CALLABLE & mdoc_macros[res].flags)
return(res);
- if (MDOC_MAX == res)
- return(res);
- if ( ! pwarn(mdoc, line, pos, WMACPARM))
- return(-1);
return(MDOC_MAX);
}
static int
-rew_last(struct mdoc *mdoc, struct mdoc_node *to)
+rew_last(struct mdoc *mdoc, const struct mdoc_node *to)
{
assert(to);
}
+/*
+ * Return the opening macro of a closing one, e.g., `Ec' has `Eo' as its
+ * matching pair.
+ */
static int
rew_alt(int tok)
{
case (MDOC_Qq):
/* FALLTHROUGH */
case (MDOC_Sq):
- assert(MDOC_HEAD != type);
assert(MDOC_TAIL != type);
if (type == p->type && tok == p->tok)
return(REWIND_REWIND);
if (type == p->type && tok == p->tok)
return(REWIND_REWIND);
break;
+ case (MDOC_Nd):
+ /* FALLTHROUGH */
case (MDOC_Ss):
assert(MDOC_TAIL != type);
if (type == p->type && tok == p->tok)
if (type == p->type && tok == p->tok)
return(REWIND_REWIND);
break;
-
/* Multi-line explicit scope close. */
case (MDOC_Ac):
/* FALLTHROUGH */
switch (tok) {
case (MDOC_It):
return(MDOC_It == p->tok);
+ case (MDOC_Nd):
+ return(MDOC_Nd == p->tok);
case (MDOC_Ss):
return(MDOC_Ss == p->tok);
case (MDOC_Sh):
+ if (MDOC_Nd == p->tok)
+ return(1);
if (MDOC_Ss == p->tok)
return(1);
return(MDOC_Sh == p->tok);
static int
-rew_subblock(enum mdoc_type type, struct mdoc *mdoc,
+rew_sub(enum mdoc_type t, struct mdoc *m,
int tok, int line, int ppos)
{
struct mdoc_node *n;
int c;
/* LINTED */
- for (n = mdoc->last; n; n = n->parent) {
- c = rew_dohalt(tok, type, n);
- if (REWIND_HALT == c)
- return(1);
- if (REWIND_REWIND == c)
- break;
- else if (rew_dobreak(tok, n))
- continue;
- if ( ! swarn(mdoc, type, line, ppos, n))
- return(0);
- }
-
- assert(n);
- return(rew_last(mdoc, n));
-}
-
-
-static int
-rew_expblock(struct mdoc *mdoc, int tok, int line, int ppos)
-{
- struct mdoc_node *n;
- int c;
-
- /* LINTED */
- for (n = mdoc->last; n; n = n->parent) {
- c = rew_dohalt(tok, MDOC_BLOCK, n);
- if (REWIND_HALT == c)
- return(perr(mdoc, line, ppos, ENOCTX));
+ for (n = m->last; n; n = n->parent) {
+ c = rew_dohalt(tok, t, n);
+ if (REWIND_HALT == c) {
+ if (MDOC_BLOCK != t)
+ return(1);
+ if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags))
+ return(1);
+ return(mdoc_perr(m, line, ppos, ENOCTX));
+ }
if (REWIND_REWIND == c)
break;
else if (rew_dobreak(tok, n))
continue;
- if ( ! swarn(mdoc, MDOC_BLOCK, line, ppos, n))
- return(0);
- }
-
- assert(n);
- return(rew_last(mdoc, n));
-}
-
-
-static int
-rew_impblock(struct mdoc *mdoc, int tok, int line, int ppos)
-{
- struct mdoc_node *n;
- int c;
-
- /* LINTED */
- for (n = mdoc->last; n; n = n->parent) {
- c = rew_dohalt(tok, MDOC_BLOCK, n);
- if (REWIND_HALT == c)
- return(1);
- else if (REWIND_REWIND == c)
- break;
- else if (rew_dobreak(tok, n))
- continue;
- if ( ! swarn(mdoc, MDOC_BLOCK, line, ppos, n))
+ if ( ! swarn(m, t, line, ppos, n))
return(0);
}
assert(n);
- return(rew_last(mdoc, n));
+ return(rew_last(m, n));
}
for (;;) {
lastarg = *pos;
- c = mdoc_args(mdoc, line, pos, buf, 0, &p);
+ c = mdoc_zargs(mdoc, line, pos, buf, ARGS_NOWARN, &p);
assert(ARGS_PHRASE != c);
if (ARGS_ERROR == c)
assert(mdoc_isdelim(p));
if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
}
return(1);
}
if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {
- if (0 == buf[*pos]) {
- if ( ! rew_subblock(MDOC_BODY, mdoc,
- tok, line, ppos))
+ if (buf[*pos])
+ if ( ! mdoc_pwarn(m, line, ppos, ENOLINE))
return(0);
- return(rew_expblock(mdoc, tok, line, ppos));
- }
- return(perr(mdoc, line, ppos, ENOPARMS));
+
+ if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
+ return(0);
+ return(rew_sub(MDOC_BLOCK, m, tok, line, ppos));
}
- if ( ! rew_subblock(MDOC_BODY, mdoc, tok, line, ppos))
+ if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
return(0);
- if (maxargs > 0) {
- if ( ! mdoc_tail_alloc(mdoc, line,
- ppos, rew_alt(tok)))
+ if (maxargs > 0)
+ if ( ! mdoc_tail_alloc(m, line, ppos, rew_alt(tok)))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
- }
- for (lastarg = ppos, flushed = j = 0; ; j++) {
+ for (flushed = j = 0; ; j++) {
lastarg = *pos;
if (j == maxargs && ! flushed) {
- if ( ! rew_expblock(mdoc, tok, line, ppos))
+ if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
return(0);
flushed = 1;
}
- c = mdoc_args(mdoc, line, pos, buf, tok, &p);
+ c = mdoc_args(m, line, pos, buf, tok, &p);
if (ARGS_ERROR == c)
return(0);
if (ARGS_EOLN == c)
break;
- if (-1 == (c = lookup(mdoc, line, lastarg, tok, p)))
- return(0);
- else if (MDOC_MAX != c) {
+ if (MDOC_MAX != (c = lookup(tok, p))) {
if ( ! flushed) {
- if ( ! rew_expblock(mdoc, tok,
- line, ppos))
+ if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
return(0);
flushed = 1;
}
- if ( ! mdoc_macro(mdoc, c, line, lastarg, pos, buf))
+ if ( ! mdoc_macro(m, c, line, lastarg, pos, buf))
return(0);
break;
}
- if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
+ if ( ! mdoc_word_alloc(m, line, lastarg, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
}
- if ( ! flushed && ! rew_expblock(mdoc, tok, line, ppos))
+ if ( ! flushed && ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
return(0);
if (ppos > 1)
return(1);
- return(append_delims(mdoc, line, pos, buf));
+ return(append_delims(m, line, pos, buf));
}
-/*
- * In-line macros where reserved words cause scope close-reopen.
- */
static int
in_line(MACRO_PROT_ARGS)
{
* usually because of reserved words) to squeak by.
*/
switch (tok) {
- case (MDOC_Lp):
+ case (MDOC_An):
/* FALLTHROUGH */
- case (MDOC_Pp):
- /* FALLTHROUGH */
- case (MDOC_Nm):
+ case (MDOC_Ar):
/* FALLTHROUGH */
case (MDOC_Fl):
/* FALLTHROUGH */
- case (MDOC_Ar):
+ case (MDOC_Lk):
+ /* FALLTHROUGH */
+ case (MDOC_Nm):
+ /* FALLTHROUGH */
+ case (MDOC_Pa):
nc = 1;
break;
default:
break;
}
- for (la = ppos, arg = NULL;; ) {
+ for (arg = NULL;; ) {
la = *pos;
- c = mdoc_argv(mdoc, line, tok, &arg, pos, buf);
+ c = mdoc_argv(m, line, tok, &arg, pos, buf);
if (ARGV_WORD == c) {
*pos = la;
for (cnt = 0, lastpunct = 1;; ) {
la = *pos;
- w = mdoc_args(mdoc, line, pos, buf, tok, &p);
+ w = mdoc_args(m, line, pos, buf, tok, &p);
if (ARGS_ERROR == w)
return(0);
/* Quoted words shouldn't be looked-up. */
- c = ARGS_QWORD == w ? MDOC_MAX :
- lookup(mdoc, line, la, tok, p);
+ c = ARGS_QWORD == w ? MDOC_MAX : lookup(tok, p);
/*
* In this case, we've located a submacro and must
* or raise a warning.
*/
- if (MDOC_MAX != c && -1 != c) {
- if (0 == lastpunct && ! rew_elem(mdoc, tok))
+ if (MDOC_MAX != c) {
+ if (0 == lastpunct && ! rew_elem(m, tok))
return(0);
if (nc && 0 == cnt) {
- if ( ! mdoc_elem_alloc(mdoc, line, ppos,
- tok, arg))
+ if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
- } else if ( ! nc && 0 == cnt)
- if ( ! pwarn(mdoc, line, ppos, WIGNE))
+ if ( ! rew_last(m, m->last))
return(0);
- c = mdoc_macro(mdoc, c, line, la, pos, buf);
+ } else if ( ! nc && 0 == cnt) {
+ mdoc_argv_free(arg);
+ if ( ! mdoc_pwarn(m, line, ppos, EIGNE))
+ return(0);
+ }
+ c = mdoc_macro(m, c, line, la, pos, buf);
if (0 == c)
return(0);
if (ppos > 1)
return(1);
- return(append_delims(mdoc, line, pos, buf));
- } else if (-1 == c)
- return(0);
+ return(append_delims(m, line, pos, buf));
+ }
/*
* Non-quote-enclosed punctuation. Set up our scope, if
d = mdoc_isdelim(p);
if (ARGS_QWORD != w && d) {
- if (0 == lastpunct && ! rew_elem(mdoc, tok))
+ if (0 == lastpunct && ! rew_elem(m, tok))
return(0);
lastpunct = 1;
} else if (lastpunct) {
- c = mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
- if (0 == c)
+ if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
lastpunct = 0;
}
if ( ! d)
cnt++;
- if ( ! mdoc_word_alloc(mdoc, line, la, p))
+ if ( ! mdoc_word_alloc(m, line, la, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
}
- if (0 == lastpunct && ! rew_elem(mdoc, tok))
+ if (0 == lastpunct && ! rew_elem(m, tok))
return(0);
/*
*
*/
if (nc && 0 == cnt) {
- c = mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
- if (0 == c)
+ if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
- } else if ( ! nc && 0 == cnt)
- if ( ! pwarn(mdoc, line, ppos, WIGNE))
+ if ( ! rew_last(m, m->last))
return(0);
+ } else if ( ! nc && 0 == cnt) {
+ mdoc_argv_free(arg);
+ if ( ! mdoc_pwarn(m, line, ppos, EIGNE))
+ return(0);
+ }
if (ppos > 1)
return(1);
- return(append_delims(mdoc, line, pos, buf));
+ return(append_delims(m, line, pos, buf));
}
-/*
- * Block full-explicit and full-implicit.
- */
static int
blk_full(MACRO_PROT_ARGS)
{
- int c, lastarg, reopen;
+ int c, lastarg, reopen, dohead;
struct mdoc_arg *arg;
char *p;
+ /*
+ * Whether to process a block-head section. If this is
+ * non-zero, then a head will be opened for all line arguments.
+ * If not, then the head will always be empty and only a body
+ * will be opened, which will stay open at the eoln.
+ */
+
+ switch (tok) {
+ case (MDOC_Nd):
+ dohead = 0;
+ break;
+ default:
+ dohead = 1;
+ break;
+ }
+
if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {
- if ( ! rew_subblock(MDOC_BODY, mdoc,
- tok, line, ppos))
+ if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
return(0);
- if ( ! rew_impblock(mdoc, tok, line, ppos))
+ if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
return(0);
}
for (arg = NULL;; ) {
lastarg = *pos;
- c = mdoc_argv(mdoc, line, tok, &arg, pos, buf);
+ c = mdoc_argv(m, line, tok, &arg, pos, buf);
if (ARGV_WORD == c) {
*pos = lastarg;
return(0);
}
- if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, arg))
+ if ( ! mdoc_block_alloc(m, line, ppos, tok, arg))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
if (0 == buf[*pos]) {
- if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_head_alloc(m, line, ppos, tok))
return(0);
- if ( ! rew_subblock(MDOC_HEAD, mdoc,
- tok, line, ppos))
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
return(0);
- if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
return(1);
}
- if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_head_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
+
+ /* Immediately close out head and enter body, if applicable. */
+
+ if (0 == dohead) {
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
+ return(0);
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
+ return(0);
+ }
for (reopen = 0;; ) {
lastarg = *pos;
- c = mdoc_args(mdoc, line, pos, buf, tok, &p);
+ c = mdoc_args(m, line, pos, buf, tok, &p);
if (ARGS_ERROR == c)
return(0);
if (ARGS_EOLN == c)
break;
if (ARGS_PHRASE == c) {
- if (reopen && ! mdoc_head_alloc
- (mdoc, line, ppos, tok))
+ assert(dohead);
+ if (reopen && ! mdoc_head_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
/*
* Phrases are self-contained macro phrases used
* in the columnar output of a macro. They need
* special handling.
*/
- if ( ! phrase(mdoc, line, lastarg, buf))
+ if ( ! phrase(m, line, lastarg, buf))
return(0);
- if ( ! rew_subblock(MDOC_HEAD, mdoc,
- tok, line, ppos))
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
return(0);
reopen = 1;
continue;
}
- if (-1 == (c = lookup(mdoc, line, lastarg, tok, p)))
- return(0);
-
- if (MDOC_MAX == c) {
- if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
+ if (MDOC_MAX == (c = lookup(tok, p))) {
+ if ( ! mdoc_word_alloc(m, line, lastarg, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
continue;
}
- if ( ! mdoc_macro(mdoc, c, line, lastarg, pos, buf))
+ if ( ! mdoc_macro(m, c, line, lastarg, pos, buf))
return(0);
break;
}
- if (1 == ppos && ! append_delims(mdoc, line, pos, buf))
- return(0);
- if ( ! rew_subblock(MDOC_HEAD, mdoc, tok, line, ppos))
+ if (1 == ppos && ! append_delims(m, line, pos, buf))
return(0);
- if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
+ /* If the body's already open, then just return. */
+ if (0 == dohead)
+ return(1);
+
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
+ return(0);
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
return(1);
}
-/*
- * Block partial-imnplicit scope.
- */
static int
blk_part_imp(MACRO_PROT_ARGS)
{
- int lastarg, c;
+ int la, c;
char *p;
struct mdoc_node *blk, *body, *n;
- if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, NULL))
- return(0);
- mdoc->next = MDOC_NEXT_CHILD;
- blk = mdoc->last;
+ /* If applicable, close out prior scopes. */
- if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_block_alloc(m, line, ppos, tok, NULL))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
-
- if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
+ /* Saved for later close-out. */
+ blk = m->last;
+ if ( ! mdoc_head_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
- body = mdoc->last;
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
+ return(0);
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
+ return(0);
+ /* Saved for later close-out. */
+ body = m->last;
- /* XXX - no known argument macros. */
+ /* Body argument processing. */
- for (lastarg = ppos;; ) {
- lastarg = *pos;
- c = mdoc_args(mdoc, line, pos, buf, tok, &p);
+ for (;;) {
+ la = *pos;
+ c = mdoc_args(m, line, pos, buf, tok, &p);
assert(ARGS_PHRASE != c);
if (ARGS_ERROR == c)
if (ARGS_EOLN == c)
break;
- if (-1 == (c = lookup(mdoc, line, lastarg, tok, p)))
- return(0);
- else if (MDOC_MAX == c) {
- if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
+ if (MDOC_MAX == (c = lookup(tok, p))) {
+ if ( ! mdoc_word_alloc(m, line, la, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
continue;
}
- if ( ! mdoc_macro(mdoc, c, line, lastarg, pos, buf))
+ if ( ! mdoc_macro(m, c, line, la, pos, buf))
return(0);
break;
}
- /*
- * Since we know what our context is, we can rewind directly to
- * it. This allows us to accomodate for our scope being
- * violated by another token.
+ /*
+ * If we can't rewind to our body, then our scope has already
+ * been closed by another macro (like `Oc' closing `Op'). This
+ * is ugly behaviour nodding its head to OpenBSD's overwhelming
+ * crufty use of `Op' breakage--XXX, deprecate in time.
*/
-
- for (n = mdoc->last; n; n = n->parent)
+ for (n = m->last; n; n = n->parent)
if (body == n)
break;
+ if (NULL == n && ! mdoc_nwarn(m, body, EIMPBRK))
+ return(0);
+ if (n && ! rew_last(m, body))
+ return(0);
- if (NULL == n && ! pwarn(mdoc, body->line, body->pos, WIMPBRK))
- return(0);
+ /* Standard appending of delimiters. */
- if (n && ! rew_last(mdoc, body))
+ if (1 == ppos && ! append_delims(m, line, pos, buf))
return(0);
- if (1 == ppos && ! append_delims(mdoc, line, pos, buf))
- return(0);
+ /* Rewind scope, if applicable. */
- if (n && ! rew_last(mdoc, blk))
+ if (n && ! rew_last(m, blk))
return(0);
return(1);
}
-/*
- * Block partial-explicit macros.
- */
static int
blk_part_exp(MACRO_PROT_ARGS)
{
- int lastarg, flushed, j, c, maxargs;
+ int la, flushed, j, c, maxargs;
char *p;
- lastarg = ppos;
- flushed = 0;
-
- /*
- * Number of arguments (head arguments). Only `Eo' has these,
- */
+ /* Number of head arguments. Only `Eo' has these, */
switch (tok) {
case (MDOC_Eo):
break;
}
- if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, NULL))
+ /* Begin the block scope. */
+
+ if ( ! mdoc_block_alloc(m, line, ppos, tok, NULL))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
+
+ /*
+ * If no head arguments, open and then close out a head, noting
+ * that we've flushed our terms. `flushed' means that we've
+ * flushed out the head and the body is open.
+ */
if (0 == maxargs) {
- if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_head_alloc(m, line, ppos, tok))
return(0);
- if ( ! rew_subblock(MDOC_HEAD, mdoc,
- tok, line, ppos))
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
return(0);
- if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
return(0);
flushed = 1;
- } else if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
- return(0);
+ } else {
+ if ( ! mdoc_head_alloc(m, line, ppos, tok))
+ return(0);
+ flushed = 0;
+ }
- mdoc->next = MDOC_NEXT_CHILD;
+ /* Process the head/head+body line arguments. */
for (j = 0; ; j++) {
- lastarg = *pos;
+ la = *pos;
if (j == maxargs && ! flushed) {
- if ( ! rew_subblock(MDOC_HEAD, mdoc,
- tok, line, ppos))
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
return(0);
flushed = 1;
- if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
}
- c = mdoc_args(mdoc, line, pos, buf, tok, &p);
+ c = mdoc_args(m, line, pos, buf, tok, &p);
assert(ARGS_PHRASE != c);
if (ARGS_ERROR == c)
if (ARGS_EOLN == c)
break;
- if (-1 == (c = lookup(mdoc, line, lastarg, tok, p)))
- return(0);
- else if (MDOC_MAX != c) {
+ if (MDOC_MAX != (c = lookup(tok, p))) {
if ( ! flushed) {
- if ( ! rew_subblock(MDOC_HEAD, mdoc,
- tok, line, ppos))
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
return(0);
flushed = 1;
- if ( ! mdoc_body_alloc(mdoc, line,
- ppos, tok))
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
}
- if ( ! mdoc_macro(mdoc, c, line, lastarg,
- pos, buf))
+ if ( ! mdoc_macro(m, c, line, la, pos, buf))
return(0);
break;
}
if ( ! flushed && mdoc_isdelim(p)) {
- if ( ! rew_subblock(MDOC_HEAD, mdoc,
- tok, line, ppos))
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
return(0);
flushed = 1;
- if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
}
- if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
+ if ( ! mdoc_word_alloc(m, line, la, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
}
+ /* Close the head and open the body, if applicable. */
+
if ( ! flushed) {
- if ( ! rew_subblock(MDOC_HEAD, mdoc, tok, line, ppos))
+ if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
return(0);
- if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
+ if ( ! mdoc_body_alloc(m, line, ppos, tok))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
}
+ /* Standard appending of delimiters. */
+
if (ppos > 1)
return(1);
- return(append_delims(mdoc, line, pos, buf));
+ return(append_delims(m, line, pos, buf));
}
-/*
- * In-line macros where reserved words signal closure of the macro.
- * Macros also have a fixed number of arguments.
- */
static int
in_line_argn(MACRO_PROT_ARGS)
{
- int lastarg, flushed, j, c, maxargs;
+ int la, flushed, j, c, maxargs;
struct mdoc_arg *arg;
char *p;
-
- /*
- * Fixed maximum arguments per macro. Some of these have none
- * and close as soon as the invocation is parsed.
- */
+ /* Fixed maximum arguments per macro, if applicable. */
switch (tok) {
case (MDOC_Ap):
break;
}
- for (lastarg = ppos, arg = NULL;; ) {
- lastarg = *pos;
- c = mdoc_argv(mdoc, line, tok, &arg, pos, buf);
+ /* Macro argument processing. */
+
+ for (arg = NULL;; ) {
+ la = *pos;
+ c = mdoc_argv(m, line, tok, &arg, pos, buf);
if (ARGV_WORD == c) {
- *pos = lastarg;
+ *pos = la;
break;
}
return(0);
}
- if ( ! mdoc_elem_alloc(mdoc, line, ppos, tok, arg))
+ /* Open the element scope. */
+
+ if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
+
+ /* Process element arguments. */
for (flushed = j = 0; ; j++) {
- lastarg = *pos;
+ la = *pos;
if (j == maxargs && ! flushed) {
- if ( ! rew_elem(mdoc, tok))
+ if ( ! rew_elem(m, tok))
return(0);
flushed = 1;
}
- c = mdoc_args(mdoc, line, pos, buf, tok, &p);
+ c = mdoc_args(m, line, pos, buf, tok, &p);
if (ARGS_ERROR == c)
return(0);
if (ARGS_EOLN == c)
break;
- if (-1 == (c = lookup(mdoc, line, lastarg, tok, p)))
- return(0);
- else if (MDOC_MAX != c) {
- if ( ! flushed && ! rew_elem(mdoc, tok))
+ if (MDOC_MAX != (c = lookup(tok, p))) {
+ if ( ! flushed && ! rew_elem(m, tok))
return(0);
flushed = 1;
- if ( ! mdoc_macro(mdoc, c, line, lastarg, pos, buf))
+ if ( ! mdoc_macro(m, c, line, la, pos, buf))
return(0);
break;
}
if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&
! flushed && mdoc_isdelim(p)) {
- if ( ! rew_elem(mdoc, tok))
+ if ( ! rew_elem(m, tok))
return(0);
flushed = 1;
}
- if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
+ if ( ! mdoc_word_alloc(m, line, la, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
}
- if ( ! flushed && ! rew_elem(mdoc, tok))
+ /* Close out and append delimiters. */
+
+ if ( ! flushed && ! rew_elem(m, tok))
return(0);
if (ppos > 1)
return(1);
- return(append_delims(mdoc, line, pos, buf));
+ return(append_delims(m, line, pos, buf));
}
-/*
- * In-line macro that spans an entire line. May be callable, but has no
- * subsequent parsed arguments.
- */
static int
in_line_eoln(MACRO_PROT_ARGS)
{
assert( ! (MDOC_PARSED & mdoc_macros[tok].flags));
- arg = NULL;
+ /* Parse macro arguments. */
- for (;;) {
+ for (arg = NULL; ; ) {
la = *pos;
- c = mdoc_argv(mdoc, line, tok, &arg, pos, buf);
+ c = mdoc_argv(m, line, tok, &arg, pos, buf);
if (ARGV_WORD == c) {
*pos = la;
return(0);
}
- if ( ! mdoc_elem_alloc(mdoc, line, ppos, tok, arg))
+ /* Open element scope. */
+
+ if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
return(0);
- mdoc->next = MDOC_NEXT_CHILD;
+ /* Parse argument terms. */
for (;;) {
la = *pos;
- w = mdoc_args(mdoc, line, pos, buf, tok, &p);
+ w = mdoc_args(m, line, pos, buf, tok, &p);
if (ARGS_ERROR == w)
return(0);
if (ARGS_EOLN == w)
break;
- c = ARGS_QWORD == w ? MDOC_MAX :
- lookup(mdoc, line, la, tok, p);
+ c = ARGS_QWORD == w ? MDOC_MAX : lookup(tok, p);
- if (MDOC_MAX != c && -1 != c) {
- if ( ! rew_elem(mdoc, tok))
+ if (MDOC_MAX != c) {
+ if ( ! rew_elem(m, tok))
return(0);
- return(mdoc_macro(mdoc, c, line, la, pos, buf));
- } else if (-1 == c)
- return(0);
+ return(mdoc_macro(m, c, line, la, pos, buf));
+ }
- if ( ! mdoc_word_alloc(mdoc, line, la, p))
+ if ( ! mdoc_word_alloc(m, line, la, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
}
- return(rew_elem(mdoc, tok));
+ /* Close out (no delimiters). */
+
+ return(rew_elem(m, tok));
}
obsolete(MACRO_PROT_ARGS)
{
- return(pwarn(mdoc, line, ppos, WOBS));
+ return(mdoc_pwarn(m, line, ppos, EOBS));
}
+/*
+ * Phrases occur within `Bl -column' entries, separated by `Ta' or tabs.
+ * They're unusual because they're basically free-form text until a
+ * macro is encountered.
+ */
static int
-phrase(struct mdoc *mdoc, int line, int ppos, char *buf)
+phrase(struct mdoc *m, int line, int ppos, char *buf)
{
- int i, la, c, quoted;
-
- /*
- * Parse over words in a phrase. We have to handle this
- * specially because we assume no calling context -- in normal
- * circumstances, we switch argument parsing based on whether
- * the parent macro accepts quotes, tabs, etc. Here, anything
- * goes.
- */
-
- for (i = ppos; buf[i]; ) {
- assert(' ' != buf[i]);
- la = i;
- quoted = 0;
+ int c, w, la, pos;
+ char *p;
- /*
- * Read to next token. If quoted (check not escaped),
- * scan ahead to next unescaped quote. If not quoted or
- * escape-quoted, then scan ahead to next space.
- */
+ for (pos = ppos; ; ) {
+ la = pos;
- if ((i && '\"' == buf[i] && '\\' != buf[i - 1]) ||
- (0 == i && '\"' == buf[i])) {
- for (la = ++i; buf[i]; i++)
- if ('\"' != buf[i])
- continue;
- else if ('\\' != buf[i - 1])
- break;
- if (0 == buf[i])
- return(perr(mdoc, line, la, EQUOT));
- quoted = 1;
- } else
- for ( ; buf[i]; i++)
- if (i && ' ' == buf[i]) {
- if ('\\' != buf[i - 1])
- break;
- } else if (' ' == buf[i])
- break;
-
- /* If not end-of-line, terminate argument. */
-
- if (buf[i])
- buf[i++] = 0;
-
- /* Read to next argument. */
-
- for ( ; buf[i] && ' ' == buf[i]; i++)
- /* Spin. */ ;
+ /* Note: no calling context! */
+ w = mdoc_zargs(m, line, &pos, buf, 0, &p);
- /*
- * If we're a non-quoted string, try to look up the
- * value as a macro and execute it, if found.
- */
+ if (ARGS_ERROR == w)
+ return(0);
+ if (ARGS_EOLN == w)
+ break;
- c = quoted ? MDOC_MAX :
- mdoc_tokhash_find(mdoc->htab, &buf[la]);
+ c = ARGS_QWORD == w ? MDOC_MAX : lookup_raw(p);
if (MDOC_MAX != c) {
- if ( ! mdoc_macro(mdoc, c, line, la, &i, buf))
+ if ( ! mdoc_macro(m, c, line, la, &pos, buf))
return(0);
- return(append_delims(mdoc, line, &i, buf));
- }
-
- /* A regular word or quoted string. */
+ return(append_delims(m, line, &pos, buf));
+ }
- if ( ! mdoc_word_alloc(mdoc, line, la, &buf[la]))
+ if ( ! mdoc_word_alloc(m, line, la, p))
return(0);
- mdoc->next = MDOC_NEXT_SIBLING;
}
return(1);
}
+
+
git.ckatri.com / mandoc.git / blobdiff