=================================================================== RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/mandoc/man_macro.c,v retrieving revision 1.44 retrieving revision 1.45 diff -c -r1.44 -r1.45 *** src/usr.bin/mandoc/man_macro.c 2014/03/30 19:47:32 1.44 --- src/usr.bin/mandoc/man_macro.c 2014/04/20 16:44:44 1.45 *************** *** 1,4 **** ! /* $Id: man_macro.c,v 1.44 2014/03/30 19:47:32 schwarze Exp $ */ /* * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons * Copyright (c) 2012, 2013 Ingo Schwarze --- 1,4 ---- ! /* $Id: man_macro.c,v 1.45 2014/04/20 16:44:44 schwarze Exp $ */ /* * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons * Copyright (c) 2012, 2013 Ingo Schwarze *************** *** 36,51 **** static int blk_exp(MACRO_PROT_ARGS); static int blk_imp(MACRO_PROT_ARGS); static int in_line_eoln(MACRO_PROT_ARGS); ! static int man_args(struct man *, int, int *, char *, char **); ! static int rew_scope(enum man_type, struct man *, enum mant); ! static enum rew rew_dohalt(enum mant, enum man_type, const struct man_node *); ! static enum rew rew_block(enum mant, enum man_type, const struct man_node *); ! static void rew_warn(struct man *, struct man_node *, enum mandocerr); const struct man_macro __man_macros[MAN_MAX] = { --- 36,51 ---- static int blk_exp(MACRO_PROT_ARGS); static int blk_imp(MACRO_PROT_ARGS); static int in_line_eoln(MACRO_PROT_ARGS); ! static int man_args(struct man *, int, int *, char *, char **); ! static int rew_scope(enum man_type, struct man *, enum mant); ! static enum rew rew_dohalt(enum mant, enum man_type, const struct man_node *); ! static enum rew rew_block(enum mant, enum man_type, const struct man_node *); ! static void rew_warn(struct man *, struct man_node *, enum mandocerr); const struct man_macro __man_macros[MAN_MAX] = { *************** *** 111,123 **** man_nmsg(man, n, er); } - /* * Rewind scope. If a code "er" != MANDOCERR_MAX has been provided, it * will be used if an explicit block scope is being closed out. */ int ! man_unscope(struct man *man, const struct man_node *to, enum mandocerr er) { struct man_node *n; --- 111,122 ---- man_nmsg(man, n, er); } /* * Rewind scope. If a code "er" != MANDOCERR_MAX has been provided, it * will be used if an explicit block scope is being closed out. */ int ! man_unscope(struct man *man, const struct man_node *to, enum mandocerr er) { struct man_node *n; *************** *** 126,132 **** man->next = MAN_NEXT_SIBLING; - /* LINTED */ while (man->last != to) { /* * Save the parent here, because we may delete the --- 125,130 ---- *************** *** 149,172 **** return(1); } - static enum rew rew_block(enum mant ntok, enum man_type type, const struct man_node *n) { ! if (MAN_BLOCK == type && ntok == n->parent->tok && ! MAN_BODY == n->parent->type) return(REW_REWIND); return(ntok == n->tok ? REW_HALT : REW_NOHALT); } - /* * There are three scope levels: scoped to the root (all), scoped to the * section (all less sections), and scoped to subsections (all less * sections and subsections). */ ! static enum rew rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n) { enum rew c; --- 147,168 ---- return(1); } static enum rew rew_block(enum mant ntok, enum man_type type, const struct man_node *n) { ! if (MAN_BLOCK == type && ntok == n->parent->tok && ! MAN_BODY == n->parent->type) return(REW_REWIND); return(ntok == n->tok ? REW_HALT : REW_NOHALT); } /* * There are three scope levels: scoped to the root (all), scoped to the * section (all less sections), and scoped to subsections (all less * sections and subsections). */ ! static enum rew rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n) { enum rew c; *************** *** 193,212 **** return(REW_REWIND); } ! /* * Next follow the implicit scope-smashings as defined by man.7: * section, sub-section, etc. */ switch (tok) { ! case (MAN_SH): break; ! case (MAN_SS): /* Rewind to a section, if a block. */ if (REW_NOHALT != (c = rew_block(MAN_SH, type, n))) return(c); break; ! case (MAN_RS): /* Preserve empty paragraphs before RS. */ if (0 == n->nchild && (MAN_P == n->tok || MAN_PP == n->tok || MAN_LP == n->tok)) --- 189,208 ---- return(REW_REWIND); } ! /* * Next follow the implicit scope-smashings as defined by man.7: * section, sub-section, etc. */ switch (tok) { ! case MAN_SH: break; ! case MAN_SS: /* Rewind to a section, if a block. */ if (REW_NOHALT != (c = rew_block(MAN_SH, type, n))) return(c); break; ! case MAN_RS: /* Preserve empty paragraphs before RS. */ if (0 == n->nchild && (MAN_P == n->tok || MAN_PP == n->tok || MAN_LP == n->tok)) *************** *** 234,240 **** return(REW_NOHALT); } - /* * Rewinding entails ascending the parse tree until a coherent point, * for example, the `SH' macro will close out any intervening `SS' --- 230,235 ---- *************** *** 246,254 **** struct man_node *n; enum rew c; - /* LINTED */ for (n = man->last; n; n = n->parent) { ! /* * Whether we should stop immediately (REW_HALT), stop * and rewind until this point (REW_REWIND), or keep * rewinding (REW_NOHALT). --- 241,248 ---- struct man_node *n; enum rew c; for (n = man->last; n; n = n->parent) { ! /* * Whether we should stop immediately (REW_HALT), stop * and rewind until this point (REW_REWIND), or keep * rewinding (REW_NOHALT). *************** *** 260,266 **** break; } ! /* * Rewind until the current point. Warn if we're a roff * instruction that's mowing over explicit scopes. */ --- 254,260 ---- break; } ! /* * Rewind until the current point. Warn if we're a roff * instruction that's mowing over explicit scopes. */ *************** *** 273,290 **** /* * Close out a generic explicit macro. */ - /* 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: --- 267,283 ---- /* * Close out a generic explicit macro. */ 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: *************** *** 300,313 **** 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); } - - /* ARGSUSED */ int blk_exp(MACRO_PROT_ARGS) { --- 293,304 ---- 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); } int blk_exp(MACRO_PROT_ARGS) { *************** *** 347,361 **** return(man_body_alloc(man, line, ppos, tok)); } - - /* * Parse an implicit-block macro. These contain a MAN_HEAD and a * MAN_BODY contained within a MAN_BLOCK. Rules for closing out other * scopes, such as `SH' closing out an `SS', are defined in the rew * routines. */ - /* ARGSUSED */ int blk_imp(MACRO_PROT_ARGS) { --- 338,349 ---- *************** *** 407,414 **** return(man_body_alloc(man, line, ppos, tok)); } - - /* ARGSUSED */ int in_line_eoln(MACRO_PROT_ARGS) { --- 395,400 ---- *************** *** 448,454 **** assert( ! (MAN_NSCOPED & man_macros[tok].flags)); man->flags |= MAN_ELINE; return(1); ! } /* Set ignorable context, if applicable. */ --- 434,440 ---- assert( ! (MAN_NSCOPED & man_macros[tok].flags)); man->flags |= MAN_ELINE; return(1); ! } /* Set ignorable context, if applicable. */ *************** *** 459,465 **** assert(MAN_ROOT != man->last->type); man->next = MAN_NEXT_SIBLING; ! /* * Rewind our element scope. Note that when TH is pruned, we'll * be back at the root, so make sure that we don't clobber as --- 445,451 ---- assert(MAN_ROOT != man->last->type); man->next = MAN_NEXT_SIBLING; ! /* * Rewind our element scope. Note that when TH is pruned, we'll * be back at the root, so make sure that we don't clobber as *************** *** 478,484 **** assert(man->last); /* ! * Same here regarding whether we're back at the root. */ if (man->last->type != MAN_ROOT && ! man_valid_post(man)) --- 464,470 ---- assert(man->last); /* ! * Same here regarding whether we're back at the root. */ if (man->last->type != MAN_ROOT && ! man_valid_post(man))