/* 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)); }