/* ARGSUSED */
int
blk_close(MACRO_PROT_ARGS)
{
enum mant ntok;
const struct man_node *nn;
switch (tok) {
case (MAN_RE):
ntok = MAN_RS;
break;
default:
abort();
/* NOTREACHED */
}
for (nn = m->last->parent; nn; nn = nn->parent)
if (ntok == nn->tok)
break;
if (NULL == nn)
man_pmsg(m, line, ppos, MANDOCERR_NOSCOPE);
if ( ! rew_scope(MAN_BODY, m, ntok))
return(0);
if ( ! rew_scope(MAN_BLOCK, m, ntok))
return(0);
return(1);
}
/* ARGSUSED */
int
blk_imp(MACRO_PROT_ARGS)
{
int la;
char *p;
struct man_node *n;
/* Close out prior scopes. */
if ( ! rew_scope(MAN_BODY, man, tok))
return(0);
if ( ! rew_scope(MAN_BLOCK, man, tok))
return(0);
/* Allocate new block & head scope. */
if ( ! man_block_alloc(man, line, ppos, tok))
return(0);
if ( ! man_head_alloc(man, line, ppos, tok))
return(0);
n = man->last;
/* Add line arguments. */
for (;;) {
la = *pos;
if ( ! man_args(man, line, pos, buf, &p))
break;
if ( ! man_word_alloc(man, line, la, p))
return(0);
}
/* Close out head and open body (unless MAN_SCOPE). */
if (MAN_SCOPED & man_macros[tok].flags) {
/* If we're forcing scope (`TP'), keep it open. */
if (MAN_FSCOPED & man_macros[tok].flags) {
man->flags |= MAN_BLINE;
return(1);
} else if (n == man->last) {
man->flags |= MAN_BLINE;
return(1);
}
}
if ( ! rew_scope(MAN_HEAD, man, tok))
return(0);
return(man_body_alloc(man, line, ppos, tok));
}
/* ARGSUSED */
int
blk_close(MACRO_PROT_ARGS)
{
enum mant ntok;
const struct man_node *nn;
switch (tok) {
case (MAN_RE):
ntok = MAN_RS;
break;
case (MAN_UE):
ntok = MAN_UR;
break;
default:
abort();
/* NOTREACHED */
}
for (nn = man->last->parent; nn; nn = nn->parent)
if (ntok == nn->tok && MAN_BLOCK == nn->type)
break;
if (NULL == nn) {
man_pmsg(man, line, ppos, MANDOCERR_NOSCOPE);
if ( ! rew_scope(MAN_BLOCK, man, MAN_PP))
return(0);
} else
man_unscope(man, nn, MANDOCERR_MAX);
return(1);
}
/*
* Close out a generic explicit macro.
*/
void
blk_close(MACRO_PROT_ARGS)
{
int ntok;
const struct roff_node *nn;
char *p;
int nrew, target;
nrew = 1;
switch (tok) {
case MAN_RE:
ntok = MAN_RS;
if ( ! man_args(man, line, pos, buf, &p))
break;
for (nn = man->last->parent; nn; nn = nn->parent)
if (nn->tok == ntok && nn->type == ROFFT_BLOCK)
nrew++;
target = strtol(p, &p, 10);
if (*p != '\0')
mandoc_vmsg(MANDOCERR_ARG_EXCESS, man->parse,
line, p - buf, "RE ... %s", p);
if (target == 0)
target = 1;
nrew -= target;
if (nrew < 1) {
mandoc_vmsg(MANDOCERR_RE_NOTOPEN, man->parse,
line, ppos, "RE %d", target);
return;
}
break;
case MAN_UE:
ntok = MAN_UR;
break;
default:
abort();
}
for (nn = man->last->parent; nn; nn = nn->parent)
if (nn->tok == ntok && nn->type == ROFFT_BLOCK && ! --nrew)
break;
if (nn == NULL) {
mandoc_msg(MANDOCERR_BLK_NOTOPEN, man->parse,
line, ppos, man_macronames[tok]);
rew_scope(man, MAN_PP);
} else {
line = man->last->line;
ppos = man->last->pos;
ntok = man->last->tok;
man_unscope(man, nn);
/* Move a trailing paragraph behind the block. */
if (ntok == MAN_LP || ntok == MAN_PP || ntok == MAN_P) {
*pos = strlen(buf);
blk_imp(man, ntok, line, ppos, pos, buf);
}
}
}
/* ARGSUSED */
int
blk_exp(MACRO_PROT_ARGS)
{
int la;
char *p;
/*
* Close out prior scopes. "Regular" explicit macros cannot be
* nested, but we allow roff macros to be placed just about
* anywhere.
*/
if ( ! rew_scope(MAN_BODY, m, tok))
return(0);
if ( ! rew_scope(MAN_BLOCK, m, tok))
return(0);
if ( ! man_block_alloc(m, line, ppos, tok))
return(0);
if ( ! man_head_alloc(m, line, ppos, tok))
return(0);
for (;;) {
la = *pos;
if ( ! man_args(m, line, pos, buf, &p))
break;
if ( ! man_word_alloc(m, line, la, p))
return(0);
}
assert(m);
assert(tok != MAN_MAX);
if ( ! rew_scope(MAN_HEAD, m, tok))
return(0);
return(man_body_alloc(m, line, ppos, tok));
}
/*
* Parse an implicit-block macro. These contain a ROFFT_HEAD and a
* ROFFT_BODY contained within a ROFFT_BLOCK. Rules for closing out other
* scopes, such as `SH' closing out an `SS', are defined in the rew
* routines.
*/
void
blk_imp(MACRO_PROT_ARGS)
{
int la;
char *p;
struct roff_node *n;
rew_scope(man, tok);
n = roff_block_alloc(man, line, ppos, tok);
if (n->tok == MAN_SH || n->tok == MAN_SS)
man->flags &= ~MAN_LITERAL;
n = roff_head_alloc(man, line, ppos, tok);
/* Add line arguments. */
for (;;) {
la = *pos;
if ( ! man_args(man, line, pos, buf, &p))
break;
roff_word_alloc(man, line, la, p);
}
/*
* For macros having optional next-line scope,
* keep the head open if there were no arguments.
* For `TP', always keep the head open.
*/
if (man_macros[tok].flags & MAN_SCOPED &&
(tok == MAN_TP || n == man->last)) {
man->flags |= MAN_BLINE;
return;
}
/* Close out the head and open the body. */
man_unscope(man, n);
roff_body_alloc(man, line, ppos, tok);
}
void
blk_exp(MACRO_PROT_ARGS)
{
struct roff_node *head;
char *p;
int la;
rew_scope(man, tok);
roff_block_alloc(man, line, ppos, tok);
head = roff_head_alloc(man, line, ppos, tok);
la = *pos;
if (man_args(man, line, pos, buf, &p))
roff_word_alloc(man, line, la, p);
if (buf[*pos] != '\0')
mandoc_vmsg(MANDOCERR_ARG_EXCESS, man->parse, line,
*pos, "%s ... %s", roff_name[tok], buf + *pos);
man_unscope(man, head);
roff_body_alloc(man, line, ppos, tok);
}
/* ARGSUSED */
int
blk_exp(MACRO_PROT_ARGS)
{
struct man_node *n;
int la;
char *p;
/* Close out prior implicit scopes. */
if ( ! rew_scope(MAN_BLOCK, man, tok))
return(0);
if ( ! man_block_alloc(man, line, ppos, tok))
return(0);
if ( ! man_head_alloc(man, line, ppos, tok))
return(0);
for (;;) {
la = *pos;
if ( ! man_args(man, line, pos, buf, &p))
break;
if ( ! man_word_alloc(man, line, la, p))
return(0);
}
assert(man);
assert(tok != MAN_MAX);
for (n = man->last; n; n = n->parent) {
if (n->tok != tok)
continue;
assert(MAN_HEAD == n->type);
man_unscope(man, n, MANDOCERR_MAX);
break;
}
return(man_body_alloc(man, line, ppos, tok));
}
