static int
post_root(POST_ARGS)
{
int erc;
struct mdoc_node *n;
erc = 0;
/* Check that we have a finished prologue. */
if ( ! (MDOC_PBODY & mdoc->flags)) {
erc++;
mdoc_nmsg(mdoc, mdoc->first, MANDOCERR_NODOCPROLOG);
}
n = mdoc->first;
assert(n);
/* Check that we begin with a proper `Sh'. */
if (NULL == n->child) {
erc++;
mdoc_nmsg(mdoc, n, MANDOCERR_NODOCBODY);
} else if (MDOC_BLOCK != n->child->type ||
MDOC_Sh != n->child->tok) {
erc++;
/* Can this be lifted? See rxdebug.1 for example. */
mdoc_nmsg(mdoc, n, MANDOCERR_NODOCBODY);
}
return(erc ? 0 : 1);
}
static int
concat(struct mdoc *m, char *p, const struct mdoc_node *n, size_t sz)
{
p[0] = '\0';
/*
* Concatenate sibling nodes together. All siblings must be of
* type MDOC_TEXT or an assertion is raised. Concatenation is
* separated by a single whitespace. Returns 0 on fatal (string
* overrun) error.
*/
for ( ; n; n = n->next) {
assert(MDOC_TEXT == n->type);
if (strlcat(p, n->string, sz) >= sz) {
mdoc_nmsg(m, n, MANDOCERR_MEM);
return(0);
}
if (NULL == n->next)
continue;
if (strlcat(p, " ", sz) >= sz) {
mdoc_nmsg(m, n, MANDOCERR_MEM);
return(0);
}
}
return(1);
}
static int
post_sh_body(POST_ARGS)
{
struct mdoc_node *n;
if (SEC_NAME != mdoc->lastsec)
return(1);
/*
* Warn if the NAME section doesn't contain the `Nm' and `Nd'
* macros (can have multiple `Nm' and one `Nd'). Note that the
* children of the BODY declaration can also be "text".
*/
if (NULL == (n = mdoc->last->child)) {
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADNAMESEC);
return(1);
}
for ( ; n && n->next; n = n->next) {
if (MDOC_ELEM == n->type && MDOC_Nm == n->tok)
continue;
if (MDOC_TEXT == n->type)
continue;
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADNAMESEC);
}
assert(n);
if (MDOC_BLOCK == n->type && MDOC_Nd == n->tok)
return(1);
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADNAMESEC);
return(1);
}
static int
post_bl(POST_ARGS)
{
struct mdoc_node *n;
if (MDOC_HEAD == mdoc->last->type)
return(post_bl_head(mdoc));
if (MDOC_BLOCK == mdoc->last->type)
return(post_bl_block(mdoc));
if (MDOC_BODY != mdoc->last->type)
return(1);
for (n = mdoc->last->child; n; n = n->next) {
switch (n->tok) {
case (MDOC_Lp):
/* FALLTHROUGH */
case (MDOC_Pp):
mdoc_nmsg(mdoc, n, MANDOCERR_CHILD);
/* FALLTHROUGH */
case (MDOC_It):
/* FALLTHROUGH */
case (MDOC_Sm):
continue;
default:
break;
}
mdoc_nmsg(mdoc, n, MANDOCERR_SYNTCHILD);
return(0);
}
return(1);
}
static int
post_os(POST_ARGS)
{
struct mdoc_node *n;
char buf[BUFSIZ];
#ifndef OSNAME
struct utsname utsname;
#endif
n = mdoc->last;
/*
* Set the operating system by way of the `Os' macro. Note that
* if an argument isn't provided and -DOSNAME="\"foo\"" is
* provided during compilation, this value will be used instead
* of filling in "sysname release" from uname().
*/
if (mdoc->meta.os)
free(mdoc->meta.os);
if ( ! concat(mdoc, buf, n->child, BUFSIZ))
return(0);
/* XXX: yes, these can all be dynamically-adjusted buffers, but
* it's really not worth the extra hackery.
*/
if ('\0' == buf[0]) {
#ifdef OSNAME
if (strlcat(buf, OSNAME, BUFSIZ) >= BUFSIZ) {
mdoc_nmsg(mdoc, n, MANDOCERR_MEM);
return(0);
}
#else /*!OSNAME */
if (uname(&utsname)) {
mdoc_nmsg(mdoc, n, MANDOCERR_UNAME);
mdoc->meta.os = mandoc_strdup("UNKNOWN");
return(post_prol(mdoc));
}
if (strlcat(buf, utsname.sysname, BUFSIZ) >= BUFSIZ) {
mdoc_nmsg(mdoc, n, MANDOCERR_MEM);
return(0);
}
if (strlcat(buf, " ", BUFSIZ) >= BUFSIZ) {
mdoc_nmsg(mdoc, n, MANDOCERR_MEM);
return(0);
}
if (strlcat(buf, utsname.release, BUFSIZ) >= BUFSIZ) {
mdoc_nmsg(mdoc, n, MANDOCERR_MEM);
return(0);
}
#endif /*!OSNAME*/
}
mdoc->meta.os = mandoc_strdup(buf);
return(1);
}
static int
pre_dd(PRE_ARGS)
{
if (mdoc->meta.title || mdoc->meta.os)
mdoc_nmsg(mdoc, n, MANDOCERR_PROLOGOOO);
if (mdoc->meta.date)
mdoc_nmsg(mdoc, n, MANDOCERR_PROLOGREP);
return(1);
}
static int
post_dd(POST_ARGS)
{
char buf[DATESIZE];
struct mdoc_node *n;
n = mdoc->last;
if (NULL == n->child) {
mdoc->meta.date = time(NULL);
return(1);
}
if ( ! concat(mdoc, buf, n->child, DATESIZE))
return(0);
mdoc->meta.date = mandoc_a2time
(MTIME_MDOCDATE | MTIME_CANONICAL, buf);
if (0 == mdoc->meta.date) {
mdoc_nmsg(mdoc, n, MANDOCERR_BADDATE);
mdoc->meta.date = time(NULL);
}
return(1);
}
static int
pre_par(PRE_ARGS)
{
if (NULL == mdoc->last)
return(1);
if (MDOC_ELEM != n->type && MDOC_BLOCK != n->type)
return(1);
/*
* Don't allow prior `Lp' or `Pp' prior to a paragraph-type
* block: `Lp', `Pp', or non-compact `Bd' or `Bl'.
*/
if (MDOC_Pp != mdoc->last->tok && MDOC_Lp != mdoc->last->tok)
return(1);
if (MDOC_Bl == n->tok && n->norm->Bl.comp)
return(1);
if (MDOC_Bd == n->tok && n->norm->Bd.comp)
return(1);
if (MDOC_It == n->tok && n->parent->norm->Bl.comp)
return(1);
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_IGNPAR);
mdoc_node_delete(mdoc, mdoc->last);
return(1);
}
static int
post_eoln(POST_ARGS)
{
if (mdoc->last->child)
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_ARGSLOST);
return(1);
}
static int
pre_std(PRE_ARGS)
{
if (n->args && 1 == n->args->argc)
if (MDOC_Std == n->args->argv[0].arg)
return(1);
mdoc_nmsg(mdoc, n, MANDOCERR_NOARGV);
return(1);
}
static int
ebool(struct mdoc *mdoc)
{
if (NULL == mdoc->last->child) {
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_MACROEMPTY);
mdoc_node_delete(mdoc, mdoc->last);
return(1);
}
check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 1);
assert(MDOC_TEXT == mdoc->last->child->type);
if (0 == strcmp(mdoc->last->child->string, "on"))
return(1);
if (0 == strcmp(mdoc->last->child->string, "off"))
return(1);
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADBOOL);
return(1);
}
static int
post_ignpar(POST_ARGS)
{
struct mdoc_node *np;
if (MDOC_BODY != mdoc->last->type)
return(1);
if (NULL != (np = mdoc->last->child))
if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {
mdoc_nmsg(mdoc, np, MANDOCERR_IGNPAR);
mdoc_node_delete(mdoc, np);
}
if (NULL != (np = mdoc->last->last))
if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {
mdoc_nmsg(mdoc, np, MANDOCERR_IGNPAR);
mdoc_node_delete(mdoc, np);
}
return(1);
}
static void
check_argv(struct mdoc *m, struct mdoc_node *n, struct mdoc_argv *v)
{
int i;
for (i = 0; i < (int)v->sz; i++)
check_text(m, v->line, v->pos, v->value[i]);
/* FIXME: move to post_std(). */
if (MDOC_Std == v->arg)
if ( ! (v->sz || m->meta.name))
mdoc_nmsg(m, n, MANDOCERR_NONAME);
}
static int
post_st(POST_ARGS)
{
struct mdoc_node *ch;
const char *p;
if (NULL == (ch = mdoc->last->child)) {
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_MACROEMPTY);
mdoc_node_delete(mdoc, mdoc->last);
return(1);
}
assert(MDOC_TEXT == ch->type);
if (NULL == (p = mdoc_a2st(ch->string))) {
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADSTANDARD);
mdoc_node_delete(mdoc, mdoc->last);
} else {
free(ch->string);
ch->string = mandoc_strdup(p);
}
return(1);
}
static int
post_bl_block_width(POST_ARGS)
{
size_t width;
int i;
enum mdoct tok;
struct mdoc_node *n;
char buf[NUMSIZ];
n = mdoc->last;
/*
* Calculate the real width of a list from the -width string,
* which may contain a macro (with a known default width), a
* literal string, or a scaling width.
*
* If the value to -width is a macro, then we re-write it to be
* the macro's width as set in share/tmac/mdoc/doc-common.
*/
if (0 == strcmp(n->norm->Bl.width, "Ds"))
width = 6;
else if (MDOC_MAX == (tok = mdoc_hash_find(n->norm->Bl.width)))
return(1);
else if (0 == (width = mdoc_macro2len(tok))) {
mdoc_nmsg(mdoc, n, MANDOCERR_BADWIDTH);
return(1);
}
/* The value already exists: free and reallocate it. */
assert(n->args);
for (i = 0; i < (int)n->args->argc; i++)
if (MDOC_Width == n->args->argv[i].arg)
break;
assert(i < (int)n->args->argc);
snprintf(buf, NUMSIZ, "%zun", width);
free(n->args->argv[i].value[0]);
n->args->argv[i].value[0] = mandoc_strdup(buf);
/* Set our width! */
n->norm->Bl.width = n->args->argv[i].value[0];
return(1);
}
/*
* 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
mdoc_macroend(struct mdoc *m)
{
struct mdoc_node *n;
/* Scan for open explicit scopes. */
n = MDOC_VALID & m->last->flags ? m->last->parent : m->last;
for ( ; n; n = n->parent)
if (MDOC_BLOCK == n->type &&
MDOC_EXPLICIT & mdoc_macros[n->tok].flags)
mdoc_nmsg(m, n, MANDOCERR_SCOPEEXIT);
/* Rewind to the first. */
return(rew_last(m, m->first));
}
static int
pre_display(PRE_ARGS)
{
struct mdoc_node *node;
if (MDOC_BLOCK != n->type)
return(1);
for (node = mdoc->last->parent; node; node = node->parent)
if (MDOC_BLOCK == node->type)
if (MDOC_Bd == node->tok)
break;
if (node)
mdoc_nmsg(mdoc, n, MANDOCERR_NESTEDDISP);
return(1);
}
static int
post_an(POST_ARGS)
{
struct mdoc_node *np;
np = mdoc->last;
if (AUTH__NONE != np->norm->An.auth && np->child) {
check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0);
return(1);
}
/*
* FIXME: make this ewarn and make sure that the front-ends
* don't print the arguments.
*/
if (AUTH__NONE != np->norm->An.auth || np->child)
return(1);
mdoc_nmsg(mdoc, np, MANDOCERR_NOARGS);
return(1);
}
static int
post_nm(POST_ARGS)
{
char buf[BUFSIZ];
/* If no child specified, make sure we have the meta name. */
if (NULL == mdoc->last->child && NULL == mdoc->meta.name) {
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NONAME);
return(1);
} else if (mdoc->meta.name)
return(1);
/* If no meta name, set it from the child. */
if ( ! concat(mdoc, buf, mdoc->last->child, BUFSIZ))
return(0);
mdoc->meta.name = mandoc_strdup(buf);
return(1);
}
/*
* 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
mdoc_macroend(struct mdoc *m)
{
struct mdoc_node *n;
/* Scan for open explicit scopes. */
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;
mdoc_nmsg(m, n, MANDOCERR_SYNTSCOPE);
return(0);
}
/* Rewind to the first. */
return(rew_last(m, m->first));
}
static int
post_vt(POST_ARGS)
{
const struct mdoc_node *n;
/*
* The Vt macro comes in both ELEM and BLOCK form, both of which
* have different syntaxes (yet more context-sensitive
* behaviour). ELEM types must have a child; BLOCK types,
* specifically the BODY, should only have TEXT children.
*/
if (MDOC_ELEM == mdoc->last->type)
return(eerr_ge1(mdoc));
if (MDOC_BODY != mdoc->last->type)
return(1);
for (n = mdoc->last->child; n; n = n->next)
if (MDOC_TEXT != n->type)
mdoc_nmsg(mdoc, n, MANDOCERR_CHILD);
return(1);
}
static int
post_at(POST_ARGS)
{
const char *p, *q;
char *buf;
size_t sz;
/*
* If we have a child, look it up in the standard keys. If a
* key exist, use that instead of the child; if it doesn't,
* prefix "AT&T UNIX " to the existing data.
*/
if (NULL == mdoc->last->child)
return(1);
assert(MDOC_TEXT == mdoc->last->child->type);
p = mdoc_a2att(mdoc->last->child->string);
if (p) {
free(mdoc->last->child->string);
mdoc->last->child->string = mandoc_strdup(p);
} else {
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADATT);
p = "AT&T UNIX ";
q = mdoc->last->child->string;
sz = strlen(p) + strlen(q) + 1;
buf = mandoc_malloc(sz);
strlcpy(buf, p, sz);
strlcat(buf, q, sz);
free(mdoc->last->child->string);
mdoc->last->child->string = buf;
}
return(1);
}
static int
post_sh_head(POST_ARGS)
{
char buf[BUFSIZ];
enum mdoc_sec sec;
/*
* Process a new section. Sections are either "named" or
* "custom". Custom sections are user-defined, while named ones
* follow a conventional order and may only appear in certain
* manual sections.
*/
if ( ! concat(mdoc, buf, mdoc->last->child, BUFSIZ))
return(0);
sec = mdoc_str2sec(buf);
/* The NAME should be first. */
if (SEC_NAME != sec && SEC_NONE == mdoc->lastnamed)
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NAMESECFIRST);
/* The SYNOPSIS gets special attention in other areas. */
if (SEC_SYNOPSIS == sec)
mdoc->flags |= MDOC_SYNOPSIS;
else
mdoc->flags &= ~MDOC_SYNOPSIS;
/* Mark our last section. */
mdoc->lastsec = sec;
/* We don't care about custom sections after this. */
if (SEC_CUSTOM == sec)
return(1);
/*
* Check whether our non-custom section is being repeated or is
* out of order.
*/
if (sec == mdoc->lastnamed)
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_SECREP);
if (sec < mdoc->lastnamed)
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_SECOOO);
/* Mark the last named section. */
mdoc->lastnamed = sec;
/* Check particular section/manual conventions. */
assert(mdoc->meta.msec);
switch (sec) {
case (SEC_RETURN_VALUES):
/* FALLTHROUGH */
case (SEC_ERRORS):
/* FALLTHROUGH */
case (SEC_LIBRARY):
if (*mdoc->meta.msec == '2')
break;
if (*mdoc->meta.msec == '3')
break;
if (*mdoc->meta.msec == '9')
break;
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_SECMSEC);
break;
default:
break;
}
return(1);
}
static int
post_bf(POST_ARGS)
{
struct mdoc_node *np;
enum mdocargt arg;
/*
* Unlike other data pointers, these are "housed" by the HEAD
* element, which contains the goods.
*/
if (MDOC_HEAD != mdoc->last->type) {
if (ENDBODY_NOT != mdoc->last->end) {
assert(mdoc->last->pending);
np = mdoc->last->pending->parent->head;
} else if (MDOC_BLOCK != mdoc->last->type) {
np = mdoc->last->parent->head;
} else
np = mdoc->last->head;
assert(np);
assert(MDOC_HEAD == np->type);
assert(MDOC_Bf == np->tok);
return(1);
}
np = mdoc->last;
assert(MDOC_BLOCK == np->parent->type);
assert(MDOC_Bf == np->parent->tok);
/*
* Cannot have both argument and parameter.
* If neither is specified, let it through with a warning.
*/
if (np->parent->args && np->child) {
mdoc_nmsg(mdoc, np, MANDOCERR_SYNTARGVCOUNT);
return(0);
} else if (NULL == np->parent->args && NULL == np->child) {
mdoc_nmsg(mdoc, np, MANDOCERR_FONTTYPE);
return(1);
}
/* Extract argument into data. */
if (np->parent->args) {
arg = np->parent->args->argv[0].arg;
if (MDOC_Emphasis == arg)
np->norm->Bf.font = FONT_Em;
else if (MDOC_Literal == arg)
np->norm->Bf.font = FONT_Li;
else if (MDOC_Symbolic == arg)
np->norm->Bf.font = FONT_Sy;
else
abort();
return(1);
}
/* Extract parameter into data. */
if (0 == strcmp(np->child->string, "Em"))
np->norm->Bf.font = FONT_Em;
else if (0 == strcmp(np->child->string, "Li"))
np->norm->Bf.font = FONT_Li;
else if (0 == strcmp(np->child->string, "Sy"))
np->norm->Bf.font = FONT_Sy;
else
mdoc_nmsg(mdoc, np, MANDOCERR_FONTTYPE);
return(1);
}
static int
pre_bd(PRE_ARGS)
{
int i, dup, comp;
enum mdoc_disp dt;
const char *offs;
struct mdoc_node *np;
if (MDOC_BLOCK != n->type) {
if (ENDBODY_NOT != n->end) {
assert(n->pending);
np = n->pending->parent;
} else
np = n->parent;
assert(np);
assert(MDOC_BLOCK == np->type);
assert(MDOC_Bd == np->tok);
return(1);
}
/* LINTED */
for (i = 0; n->args && i < (int)n->args->argc; i++) {
dt = DISP__NONE;
dup = comp = 0;
offs = NULL;
switch (n->args->argv[i].arg) {
case (MDOC_Centred):
dt = DISP_centred;
break;
case (MDOC_Ragged):
dt = DISP_ragged;
break;
case (MDOC_Unfilled):
dt = DISP_unfilled;
break;
case (MDOC_Filled):
dt = DISP_filled;
break;
case (MDOC_Literal):
dt = DISP_literal;
break;
case (MDOC_File):
mdoc_nmsg(mdoc, n, MANDOCERR_BADDISP);
return(0);
case (MDOC_Offset):
/* NB: this can be empty! */
if (n->args->argv[i].sz) {
offs = n->args->argv[i].value[0];
dup = (NULL != n->norm->Bd.offs);
break;
}
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV);
break;
case (MDOC_Compact):
comp = 1;
dup = n->norm->Bd.comp;
break;
default:
abort();
/* NOTREACHED */
}
/* Check whether we have duplicates. */
if (dup)
mdoc_nmsg(mdoc, n, MANDOCERR_ARGVREP);
/* Make our auxiliary assignments. */
if (offs && ! dup)
n->norm->Bd.offs = offs;
if (comp && ! dup)
n->norm->Bd.comp = comp;
/* Check whether a type has already been assigned. */
if (DISP__NONE != dt && n->norm->Bd.type != DISP__NONE)
mdoc_nmsg(mdoc, n, MANDOCERR_DISPREP);
/* Make our type assignment. */
if (DISP__NONE != dt && n->norm->Bd.type == DISP__NONE)
n->norm->Bd.type = dt;
}
if (DISP__NONE == n->norm->Bd.type) {
mdoc_nmsg(mdoc, n, MANDOCERR_DISPTYPE);
n->norm->Bd.type = DISP_ragged;
}
return(1);
}
static int
pre_bl(PRE_ARGS)
{
int i, comp, dup;
const char *offs, *width;
enum mdoc_list lt;
struct mdoc_node *np;
if (MDOC_BLOCK != n->type) {
if (ENDBODY_NOT != n->end) {
assert(n->pending);
np = n->pending->parent;
} else
np = n->parent;
assert(np);
assert(MDOC_BLOCK == np->type);
assert(MDOC_Bl == np->tok);
return(1);
}
/*
* First figure out which kind of list to use: bind ourselves to
* the first mentioned list type and warn about any remaining
* ones. If we find no list type, we default to LIST_item.
*/
/* LINTED */
for (i = 0; n->args && i < (int)n->args->argc; i++) {
lt = LIST__NONE;
dup = comp = 0;
width = offs = NULL;
switch (n->args->argv[i].arg) {
/* Set list types. */
case (MDOC_Bullet):
lt = LIST_bullet;
break;
case (MDOC_Dash):
lt = LIST_dash;
break;
case (MDOC_Enum):
lt = LIST_enum;
break;
case (MDOC_Hyphen):
lt = LIST_hyphen;
break;
case (MDOC_Item):
lt = LIST_item;
break;
case (MDOC_Tag):
lt = LIST_tag;
break;
case (MDOC_Diag):
lt = LIST_diag;
break;
case (MDOC_Hang):
lt = LIST_hang;
break;
case (MDOC_Ohang):
lt = LIST_ohang;
break;
case (MDOC_Inset):
lt = LIST_inset;
break;
case (MDOC_Column):
lt = LIST_column;
break;
/* Set list arguments. */
case (MDOC_Compact):
dup = n->norm->Bl.comp;
comp = 1;
break;
case (MDOC_Width):
dup = (NULL != n->norm->Bl.width);
width = n->args->argv[i].value[0];
break;
case (MDOC_Offset):
/* NB: this can be empty! */
if (n->args->argv[i].sz) {
offs = n->args->argv[i].value[0];
dup = (NULL != n->norm->Bl.offs);
break;
}
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV);
break;
default:
continue;
}
/* Check: duplicate auxiliary arguments. */
if (dup)
mdoc_nmsg(mdoc, n, MANDOCERR_ARGVREP);
if (comp && ! dup)
n->norm->Bl.comp = comp;
if (offs && ! dup)
n->norm->Bl.offs = offs;
if (width && ! dup)
n->norm->Bl.width = width;
/* Check: multiple list types. */
if (LIST__NONE != lt && n->norm->Bl.type != LIST__NONE)
mdoc_nmsg(mdoc, n, MANDOCERR_LISTREP);
/* Assign list type. */
if (LIST__NONE != lt && n->norm->Bl.type == LIST__NONE) {
n->norm->Bl.type = lt;
/* Set column information, too. */
if (LIST_column == lt) {
n->norm->Bl.ncols =
n->args->argv[i].sz;
n->norm->Bl.cols = (const char **)
n->args->argv[i].value;
}
}
/* The list type should come first. */
if (n->norm->Bl.type == LIST__NONE)
if (n->norm->Bl.width ||
n->norm->Bl.offs ||
n->norm->Bl.comp)
mdoc_nmsg(mdoc, n, MANDOCERR_LISTFIRST);
continue;
}
/* Allow lists to default to LIST_item. */
if (LIST__NONE == n->norm->Bl.type) {
mdoc_nmsg(mdoc, n, MANDOCERR_LISTTYPE);
n->norm->Bl.type = LIST_item;
}
/*
* Validate the width field. Some list types don't need width
* types and should be warned about them. Others should have it
* and must also be warned.
*/
switch (n->norm->Bl.type) {
case (LIST_tag):
if (n->norm->Bl.width)
break;
mdoc_nmsg(mdoc, n, MANDOCERR_NOWIDTHARG);
break;
case (LIST_column):
/* FALLTHROUGH */
case (LIST_diag):
/* FALLTHROUGH */
case (LIST_ohang):
/* FALLTHROUGH */
case (LIST_inset):
/* FALLTHROUGH */
case (LIST_item):
if (n->norm->Bl.width)
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV);
break;
default:
break;
}
return(1);
}
static int
post_it(POST_ARGS)
{
int i, cols, rc;
enum mdoc_list lt;
struct mdoc_node *n, *c;
enum mandocerr er;
if (MDOC_BLOCK != mdoc->last->type)
return(1);
n = mdoc->last->parent->parent;
lt = n->norm->Bl.type;
if (LIST__NONE == lt) {
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_LISTTYPE);
return(1);
}
switch (lt) {
case (LIST_tag):
if (mdoc->last->head->child)
break;
/* FIXME: give this a dummy value. */
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOARGS);
break;
case (LIST_hang):
/* FALLTHROUGH */
case (LIST_ohang):
/* FALLTHROUGH */
case (LIST_inset):
/* FALLTHROUGH */
case (LIST_diag):
if (NULL == mdoc->last->head->child)
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOARGS);
break;
case (LIST_bullet):
/* FALLTHROUGH */
case (LIST_dash):
/* FALLTHROUGH */
case (LIST_enum):
/* FALLTHROUGH */
case (LIST_hyphen):
if (NULL == mdoc->last->body->child)
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOBODY);
/* FALLTHROUGH */
case (LIST_item):
if (mdoc->last->head->child)
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_ARGSLOST);
break;
case (LIST_column):
cols = (int)n->norm->Bl.ncols;
assert(NULL == mdoc->last->head->child);
if (NULL == mdoc->last->body->child)
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOBODY);
for (i = 0, c = mdoc->last->child; c; c = c->next)
if (MDOC_BODY == c->type)
i++;
if (i < cols)
er = MANDOCERR_ARGCOUNT;
else if (i == cols || i == cols + 1)
break;
else
er = MANDOCERR_SYNTARGCOUNT;
rc = mdoc_vmsg(mdoc, er,
mdoc->last->line, mdoc->last->pos,
"columns == %d (have %d)", cols, i);
return(rc);
default:
break;
}
return(1);
}
static int
post_bl_head(POST_ARGS)
{
struct mdoc_node *np, *nn, *nnp;
int i, j;
if (LIST_column != mdoc->last->norm->Bl.type)
/* FIXME: this should be ERROR class... */
return(hwarn_eq0(mdoc));
/*
* Convert old-style lists, where the column width specifiers
* trail as macro parameters, to the new-style ("normal-form")
* lists where they're argument values following -column.
*/
/* First, disallow both types and allow normal-form. */
/*
* TODO: technically, we can accept both and just merge the two
* lists, but I'll leave that for another day.
*/
if (mdoc->last->norm->Bl.ncols && mdoc->last->nchild) {
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_COLUMNS);
return(0);
} else if (NULL == mdoc->last->child)
return(1);
np = mdoc->last->parent;
assert(np->args);
for (j = 0; j < (int)np->args->argc; j++)
if (MDOC_Column == np->args->argv[j].arg)
break;
assert(j < (int)np->args->argc);
assert(0 == np->args->argv[j].sz);
/*
* Accomodate for new-style groff column syntax. Shuffle the
* child nodes, all of which must be TEXT, as arguments for the
* column field. Then, delete the head children.
*/
np->args->argv[j].sz = (size_t)mdoc->last->nchild;
np->args->argv[j].value = mandoc_malloc
((size_t)mdoc->last->nchild * sizeof(char *));
mdoc->last->norm->Bl.ncols = np->args->argv[j].sz;
mdoc->last->norm->Bl.cols = (const char **)np->args->argv[j].value;
for (i = 0, nn = mdoc->last->child; nn; i++) {
np->args->argv[j].value[i] = nn->string;
nn->string = NULL;
nnp = nn;
nn = nn->next;
mdoc_node_delete(NULL, nnp);
}
mdoc->last->nchild = 0;
mdoc->last->child = NULL;
return(1);
}
static int
post_rs(POST_ARGS)
{
struct mdoc_node *nn, *next, *prev;
int i, j;
switch (mdoc->last->type) {
case (MDOC_HEAD):
check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0);
return(1);
case (MDOC_BODY):
if (mdoc->last->child)
break;
check_count(mdoc, MDOC_BODY, CHECK_WARN, CHECK_GT, 0);
return(1);
default:
return(1);
}
/*
* Make sure only certain types of nodes are allowed within the
* the `Rs' body. Delete offending nodes and raise a warning.
* Do this before re-ordering for the sake of clarity.
*/
next = NULL;
for (nn = mdoc->last->child; nn; nn = next) {
for (i = 0; i < RSORD_MAX; i++)
if (nn->tok == rsord[i])
break;
if (i < RSORD_MAX) {
if (MDOC__J == rsord[i])
mdoc->last->norm->Rs.child_J = nn;
next = nn->next;
continue;
}
next = nn->next;
mdoc_nmsg(mdoc, nn, MANDOCERR_CHILD);
mdoc_node_delete(mdoc, nn);
}
/*
* The full `Rs' block needs special handling to order the
* sub-elements according to `rsord'. Pick through each element
* and correctly order it. This is a insertion sort.
*/
next = NULL;
for (nn = mdoc->last->child->next; nn; nn = next) {
/* Determine order of `nn'. */
for (i = 0; i < RSORD_MAX; i++)
if (rsord[i] == nn->tok)
break;
/*
* Remove `nn' from the chain. This somewhat
* repeats mdoc_node_unlink(), but since we're
* just re-ordering, there's no need for the
* full unlink process.
*/
if (NULL != (next = nn->next))
next->prev = nn->prev;
if (NULL != (prev = nn->prev))
prev->next = nn->next;
nn->prev = nn->next = NULL;
/*
* Scan back until we reach a node that's
* ordered before `nn'.
*/
for ( ; prev ; prev = prev->prev) {
/* Determine order of `prev'. */
for (j = 0; j < RSORD_MAX; j++)
if (rsord[j] == prev->tok)
break;
if (j <= i)
break;
}
/*
* Set `nn' back into its correct place in front
* of the `prev' node.
*/
nn->prev = prev;
if (prev) {
if (prev->next)
prev->next->prev = nn;
nn->next = prev->next;
prev->next = nn;
} else {
mdoc->last->child->prev = nn;
nn->next = mdoc->last->child;
mdoc->last->child = nn;
}
}
return(1);
}
static int
post_dt(POST_ARGS)
{
struct mdoc_node *nn, *n;
const char *cp;
char *p;
n = mdoc->last;
if (mdoc->meta.title)
free(mdoc->meta.title);
if (mdoc->meta.vol)
free(mdoc->meta.vol);
if (mdoc->meta.arch)
free(mdoc->meta.arch);
mdoc->meta.title = mdoc->meta.vol = mdoc->meta.arch = NULL;
/* First make all characters uppercase. */
if (NULL != (nn = n->child))
for (p = nn->string; *p; p++) {
if (toupper((u_char)*p) == *p)
continue;
/*
* FIXME: don't be lazy: have this make all
* characters be uppercase and just warn once.
*/
mdoc_nmsg(mdoc, nn, MANDOCERR_UPPERCASE);
break;
}
/* Handles: `.Dt'
* --> title = unknown, volume = local, msec = 0, arch = NULL
*/
if (NULL == (nn = n->child)) {
/* XXX: make these macro values. */
/* FIXME: warn about missing values. */
mdoc->meta.title = mandoc_strdup("UNKNOWN");
mdoc->meta.vol = mandoc_strdup("LOCAL");
mdoc->meta.msec = mandoc_strdup("1");
return(1);
}
/* Handles: `.Dt TITLE'
* --> title = TITLE, volume = local, msec = 0, arch = NULL
*/
mdoc->meta.title = mandoc_strdup
('\0' == nn->string[0] ? "UNKNOWN" : nn->string);
if (NULL == (nn = nn->next)) {
/* FIXME: warn about missing msec. */
/* XXX: make this a macro value. */
mdoc->meta.vol = mandoc_strdup("LOCAL");
mdoc->meta.msec = mandoc_strdup("1");
return(1);
}
/* Handles: `.Dt TITLE SEC'
* --> title = TITLE, volume = SEC is msec ?
* format(msec) : SEC,
* msec = SEC is msec ? atoi(msec) : 0,
* arch = NULL
*/
cp = mdoc_a2msec(nn->string);
if (cp) {
mdoc->meta.vol = mandoc_strdup(cp);
mdoc->meta.msec = mandoc_strdup(nn->string);
} else {
mdoc_nmsg(mdoc, n, MANDOCERR_BADMSEC);
mdoc->meta.vol = mandoc_strdup(nn->string);
mdoc->meta.msec = mandoc_strdup(nn->string);
}
if (NULL == (nn = nn->next))
return(1);
/* Handles: `.Dt TITLE SEC VOL'
* --> title = TITLE, volume = VOL is vol ?
* format(VOL) :
* VOL is arch ? format(arch) :
* VOL
*/
cp = mdoc_a2vol(nn->string);
if (cp) {
free(mdoc->meta.vol);
mdoc->meta.vol = mandoc_strdup(cp);
} else {
/* FIXME: warn about bad arch. */
cp = mdoc_a2arch(nn->string);
if (NULL == cp) {
free(mdoc->meta.vol);
mdoc->meta.vol = mandoc_strdup(nn->string);
} else
mdoc->meta.arch = mandoc_strdup(cp);
}
/* Ignore any subsequent parameters... */
/* FIXME: warn about subsequent parameters. */
return(1);
}
