===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/mandoc/mdoc_validate.c,v
retrieving revision 1.174
retrieving revision 1.175
diff -c -r1.174 -r1.175
*** src/usr.bin/mandoc/mdoc_validate.c	2014/11/27 23:35:03	1.174
--- src/usr.bin/mandoc/mdoc_validate.c	2014/11/28 01:05:40	1.175
***************
*** 1,4 ****
! /*	$OpenBSD: mdoc_validate.c,v 1.174 2014/11/27 23:35:03 schwarze Exp $ */
  /*
   * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
   * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.org>
--- 1,4 ----
! /*	$OpenBSD: mdoc_validate.c,v 1.175 2014/11/28 01:05:40 schwarze Exp $ */
  /*
   * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
   * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.org>
***************
*** 51,65 ****
  	CHECK_ERROR,
  };
  
! typedef	int	(*v_pre)(PRE_ARGS);
! typedef	int	(*v_post)(POST_ARGS);
  
  struct	valids {
  	v_pre	 pre;
  	v_post	 post;
  };
  
! static	int	 check_count(struct mdoc *, enum mdoc_type,
  			enum check_lvl, enum check_ineq, int);
  static	void	 check_text(struct mdoc *, int, int, char *);
  static	void	 check_argv(struct mdoc *,
--- 51,65 ----
  	CHECK_ERROR,
  };
  
! typedef	void	(*v_pre)(PRE_ARGS);
! typedef	void	(*v_post)(POST_ARGS);
  
  struct	valids {
  	v_pre	 pre;
  	v_post	 post;
  };
  
! static	void	 check_count(struct mdoc *, enum mdoc_type,
  			enum check_lvl, enum check_ineq, int);
  static	void	 check_text(struct mdoc *, int, int, char *);
  static	void	 check_argv(struct mdoc *,
***************
*** 70,139 ****
  static	size_t		macro2len(enum mdoct);
  static	void	 rewrite_macro2len(char **);
  
! static	int	 berr_ge1(POST_ARGS);
! static	int	 bwarn_ge1(POST_ARGS);
! static	int	 ewarn_eq0(POST_ARGS);
! static	int	 ewarn_eq1(POST_ARGS);
! static	int	 ewarn_ge1(POST_ARGS);
! static	int	 ewarn_le1(POST_ARGS);
! static	int	 hwarn_eq0(POST_ARGS);
! static	int	 hwarn_eq1(POST_ARGS);
! static	int	 hwarn_ge1(POST_ARGS);
  
! static	int	 post_an(POST_ARGS);
! static	int	 post_at(POST_ARGS);
! static	int	 post_bf(POST_ARGS);
! static	int	 post_bk(POST_ARGS);
! static	int	 post_bl(POST_ARGS);
! static	int	 post_bl_block(POST_ARGS);
! static	int	 post_bl_block_tag(POST_ARGS);
! static	int	 post_bl_head(POST_ARGS);
! static	int	 post_bx(POST_ARGS);
! static	int	 post_d1(POST_ARGS);
! static	int	 post_defaults(POST_ARGS);
! static	int	 post_dd(POST_ARGS);
! static	int	 post_dt(POST_ARGS);
! static	int	 post_en(POST_ARGS);
! static	int	 post_es(POST_ARGS);
! static	int	 post_eoln(POST_ARGS);
! static	int	 post_ex(POST_ARGS);
! static	int	 post_fa(POST_ARGS);
! static	int	 post_fn(POST_ARGS);
! static	int	 post_fname(POST_ARGS);
! static	int	 post_fo(POST_ARGS);
! static	int	 post_hyph(POST_ARGS);
! static	int	 post_hyphtext(POST_ARGS);
! static	int	 post_ignpar(POST_ARGS);
! static	int	 post_it(POST_ARGS);
! static	int	 post_lb(POST_ARGS);
! static	int	 post_literal(POST_ARGS);
! static	int	 post_nd(POST_ARGS);
! static	int	 post_nm(POST_ARGS);
! static	int	 post_ns(POST_ARGS);
! static	int	 post_os(POST_ARGS);
! static	int	 post_par(POST_ARGS);
! static	int	 post_root(POST_ARGS);
! static	int	 post_rs(POST_ARGS);
! static	int	 post_sh(POST_ARGS);
! static	int	 post_sh_head(POST_ARGS);
! static	int	 post_sh_name(POST_ARGS);
! static	int	 post_sh_see_also(POST_ARGS);
! static	int	 post_sh_authors(POST_ARGS);
! static	int	 post_sm(POST_ARGS);
! static	int	 post_st(POST_ARGS);
! static	int	 post_vt(POST_ARGS);
! static	int	 pre_an(PRE_ARGS);
! static	int	 pre_bd(PRE_ARGS);
! static	int	 pre_bl(PRE_ARGS);
! static	int	 pre_dd(PRE_ARGS);
! static	int	 pre_display(PRE_ARGS);
! static	int	 pre_dt(PRE_ARGS);
! static	int	 pre_literal(PRE_ARGS);
! static	int	 pre_obsolete(PRE_ARGS);
! static	int	 pre_os(PRE_ARGS);
! static	int	 pre_par(PRE_ARGS);
! static	int	 pre_std(PRE_ARGS);
  
  static	const struct valids mdoc_valids[MDOC_MAX] = {
  	{ NULL, NULL },				/* Ap */
  	{ pre_dd, post_dd },			/* Dd */
--- 70,135 ----
  static	size_t		macro2len(enum mdoct);
  static	void	 rewrite_macro2len(char **);
  
! static	void	 bwarn_ge1(POST_ARGS);
! static	void	 ewarn_eq1(POST_ARGS);
! static	void	 ewarn_ge1(POST_ARGS);
! static	void	 hwarn_eq0(POST_ARGS);
  
! static	void	 post_an(POST_ARGS);
! static	void	 post_at(POST_ARGS);
! static	void	 post_bf(POST_ARGS);
! static	void	 post_bk(POST_ARGS);
! static	void	 post_bl(POST_ARGS);
! static	void	 post_bl_block(POST_ARGS);
! static	void	 post_bl_block_tag(POST_ARGS);
! static	void	 post_bl_head(POST_ARGS);
! static	void	 post_bx(POST_ARGS);
! static	void	 post_d1(POST_ARGS);
! static	void	 post_defaults(POST_ARGS);
! static	void	 post_dd(POST_ARGS);
! static	void	 post_dt(POST_ARGS);
! static	void	 post_en(POST_ARGS);
! static	void	 post_es(POST_ARGS);
! static	void	 post_eoln(POST_ARGS);
! static	void	 post_ex(POST_ARGS);
! static	void	 post_fa(POST_ARGS);
! static	void	 post_fn(POST_ARGS);
! static	void	 post_fname(POST_ARGS);
! static	void	 post_fo(POST_ARGS);
! static	void	 post_hyph(POST_ARGS);
! static	void	 post_hyphtext(POST_ARGS);
! static	void	 post_ignpar(POST_ARGS);
! static	void	 post_it(POST_ARGS);
! static	void	 post_lb(POST_ARGS);
! static	void	 post_literal(POST_ARGS);
! static	void	 post_nd(POST_ARGS);
! static	void	 post_nm(POST_ARGS);
! static	void	 post_ns(POST_ARGS);
! static	void	 post_os(POST_ARGS);
! static	void	 post_par(POST_ARGS);
! static	void	 post_root(POST_ARGS);
! static	void	 post_rs(POST_ARGS);
! static	void	 post_sh(POST_ARGS);
! static	void	 post_sh_head(POST_ARGS);
! static	void	 post_sh_name(POST_ARGS);
! static	void	 post_sh_see_also(POST_ARGS);
! static	void	 post_sh_authors(POST_ARGS);
! static	void	 post_sm(POST_ARGS);
! static	void	 post_st(POST_ARGS);
! static	void	 post_vt(POST_ARGS);
  
+ static	void	 pre_an(PRE_ARGS);
+ static	void	 pre_bd(PRE_ARGS);
+ static	void	 pre_bl(PRE_ARGS);
+ static	void	 pre_dd(PRE_ARGS);
+ static	void	 pre_display(PRE_ARGS);
+ static	void	 pre_dt(PRE_ARGS);
+ static	void	 pre_literal(PRE_ARGS);
+ static	void	 pre_obsolete(PRE_ARGS);
+ static	void	 pre_os(PRE_ARGS);
+ static	void	 pre_par(PRE_ARGS);
+ static	void	 pre_std(PRE_ARGS);
+ 
  static	const struct valids mdoc_valids[MDOC_MAX] = {
  	{ NULL, NULL },				/* Ap */
  	{ pre_dd, post_dd },			/* Dd */
***************
*** 306,312 ****
  };
  
  
! int
  mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)
  {
  	v_pre	 p;
--- 302,308 ----
  };
  
  
! void
  mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)
  {
  	v_pre	 p;
***************
*** 320,336 ****
  	case MDOC_EQN:
  		/* FALLTHROUGH */
  	case MDOC_ROOT:
! 		return(1);
  	default:
  		break;
  	}
  
  	check_args(mdoc, n);
  	p = mdoc_valids[n->tok].pre;
! 	return(*p ? (*p)(mdoc, n) : 1);
  }
  
! int
  mdoc_valid_post(struct mdoc *mdoc)
  {
  	struct mdoc_node *n;
--- 316,333 ----
  	case MDOC_EQN:
  		/* FALLTHROUGH */
  	case MDOC_ROOT:
! 		return;
  	default:
  		break;
  	}
  
  	check_args(mdoc, n);
  	p = mdoc_valids[n->tok].pre;
! 	if (*p)
! 		(*p)(mdoc, n);
  }
  
! void
  mdoc_valid_post(struct mdoc *mdoc)
  {
  	struct mdoc_node *n;
***************
*** 338,344 ****
  
  	n = mdoc->last;
  	if (n->flags & MDOC_VALID)
! 		return(1);
  	n->flags |= MDOC_VALID;
  
  	switch (n->type) {
--- 335,341 ----
  
  	n = mdoc->last;
  	if (n->flags & MDOC_VALID)
! 		return;
  	n->flags |= MDOC_VALID;
  
  	switch (n->type) {
***************
*** 347,355 ****
  	case MDOC_EQN:
  		/* FALLTHROUGH */
  	case MDOC_TBL:
! 		return(1);
  	case MDOC_ROOT:
! 		return(post_root(mdoc));
  	default:
  
  		/*
--- 344,353 ----
  	case MDOC_EQN:
  		/* FALLTHROUGH */
  	case MDOC_TBL:
! 		break;
  	case MDOC_ROOT:
! 		post_root(mdoc);
! 		break;
  	default:
  
  		/*
***************
*** 366,376 ****
  		/* Call the macro's postprocessor. */
  
  		p = mdoc_valids[n->tok].post;
! 		return(*p ? (*p)(mdoc) : 1);
  	}
  }
  
! static int
  check_count(struct mdoc *mdoc, enum mdoc_type type,
  		enum check_lvl lvl, enum check_ineq ineq, int val)
  {
--- 364,376 ----
  		/* Call the macro's postprocessor. */
  
  		p = mdoc_valids[n->tok].post;
! 		if (*p)
! 			(*p)(mdoc);
! 		break;
  	}
  }
  
! static void
  check_count(struct mdoc *mdoc, enum mdoc_type type,
  		enum check_lvl lvl, enum check_ineq ineq, int val)
  {
***************
*** 378,400 ****
  	enum mandocerr	 t;
  
  	if (mdoc->last->type != type)
! 		return(1);
  
  	switch (ineq) {
  	case CHECK_LT:
  		p = "less than ";
  		if (mdoc->last->nchild < val)
! 			return(1);
  		break;
  	case CHECK_GT:
  		p = "more than ";
  		if (mdoc->last->nchild > val)
! 			return(1);
  		break;
  	case CHECK_EQ:
  		p = "";
  		if (val == mdoc->last->nchild)
! 			return(1);
  		break;
  	default:
  		abort();
--- 378,400 ----
  	enum mandocerr	 t;
  
  	if (mdoc->last->type != type)
! 		return;
  
  	switch (ineq) {
  	case CHECK_LT:
  		p = "less than ";
  		if (mdoc->last->nchild < val)
! 			return;
  		break;
  	case CHECK_GT:
  		p = "more than ";
  		if (mdoc->last->nchild > val)
! 			return;
  		break;
  	case CHECK_EQ:
  		p = "";
  		if (val == mdoc->last->nchild)
! 			return;
  		break;
  	default:
  		abort();
***************
*** 405,468 ****
  	mandoc_vmsg(t, mdoc->parse, mdoc->last->line,
  	    mdoc->last->pos, "want %s%d children (have %d)",
  	    p, val, mdoc->last->nchild);
- 	return(1);
  }
  
! static int
! berr_ge1(POST_ARGS)
! {
! 
! 	return(check_count(mdoc, MDOC_BODY, CHECK_ERROR, CHECK_GT, 0));
! }
! 
! static int
  bwarn_ge1(POST_ARGS)
  {
! 	return(check_count(mdoc, MDOC_BODY, CHECK_WARN, CHECK_GT, 0));
  }
  
! static int
! ewarn_eq0(POST_ARGS)
! {
! 	return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0));
! }
! 
! static int
  ewarn_eq1(POST_ARGS)
  {
! 	return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 1));
  }
  
! static int
  ewarn_ge1(POST_ARGS)
  {
! 	return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0));
  }
  
! static int
! ewarn_le1(POST_ARGS)
! {
! 	return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_LT, 2));
! }
! 
! static int
  hwarn_eq0(POST_ARGS)
  {
! 	return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0));
  }
  
- static int
- hwarn_eq1(POST_ARGS)
- {
- 	return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 1));
- }
- 
- static int
- hwarn_ge1(POST_ARGS)
- {
- 	return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_GT, 0));
- }
- 
  static void
  check_args(struct mdoc *mdoc, struct mdoc_node *n)
  {
--- 405,436 ----
  	mandoc_vmsg(t, mdoc->parse, mdoc->last->line,
  	    mdoc->last->pos, "want %s%d children (have %d)",
  	    p, val, mdoc->last->nchild);
  }
  
! static void
  bwarn_ge1(POST_ARGS)
  {
! 	check_count(mdoc, MDOC_BODY, CHECK_WARN, CHECK_GT, 0);
  }
  
! static void
  ewarn_eq1(POST_ARGS)
  {
! 	check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 1);
  }
  
! static void
  ewarn_ge1(POST_ARGS)
  {
! 	check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0);
  }
  
! static void
  hwarn_eq0(POST_ARGS)
  {
! 	check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0);
  }
  
  static void
  check_args(struct mdoc *mdoc, struct mdoc_node *n)
  {
***************
*** 498,510 ****
  		    ln, pos + (int)(p - cp), NULL);
  }
  
! 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)
--- 466,478 ----
  		    ln, pos + (int)(p - cp), NULL);
  }
  
! static void
  pre_display(PRE_ARGS)
  {
  	struct mdoc_node *node;
  
  	if (MDOC_BLOCK != n->type)
! 		return;
  
  	for (node = mdoc->last->parent; node; node = node->parent)
  		if (MDOC_BLOCK == node->type)
***************
*** 515,525 ****
  		mandoc_vmsg(MANDOCERR_BD_NEST,
  		    mdoc->parse, n->line, n->pos,
  		    "%s in Bd", mdoc_macronames[n->tok]);
- 
- 	return(1);
  }
  
! static int
  pre_bl(PRE_ARGS)
  {
  	struct mdoc_node *np;
--- 483,491 ----
  		mandoc_vmsg(MANDOCERR_BD_NEST,
  		    mdoc->parse, n->line, n->pos,
  		    "%s in Bd", mdoc_macronames[n->tok]);
  }
  
! static void
  pre_bl(PRE_ARGS)
  {
  	struct mdoc_node *np;
***************
*** 538,544 ****
  		assert(np);
  		assert(MDOC_BLOCK == np->type);
  		assert(MDOC_Bl == np->tok);
! 		return(1);
  	}
  
  	/*
--- 504,510 ----
  		assert(np);
  		assert(MDOC_BLOCK == np->type);
  		assert(MDOC_Bl == np->tok);
! 		return;
  	}
  
  	/*
***************
*** 709,719 ****
  	default:
  		break;
  	}
! 
! 	return(pre_par(mdoc, n));
  }
  
! static int
  pre_bd(PRE_ARGS)
  {
  	struct mdoc_node *np;
--- 675,684 ----
  	default:
  		break;
  	}
! 	pre_par(mdoc, n);
  }
  
! static void
  pre_bd(PRE_ARGS)
  {
  	struct mdoc_node *np;
***************
*** 733,739 ****
  		assert(np);
  		assert(MDOC_BLOCK == np->type);
  		assert(MDOC_Bd == np->tok);
! 		return(1);
  	}
  
  	for (i = 0; n->args && i < (int)n->args->argc; i++) {
--- 698,704 ----
  		assert(np);
  		assert(MDOC_BLOCK == np->type);
  		assert(MDOC_Bd == np->tok);
! 		return;
  	}
  
  	for (i = 0; n->args && i < (int)n->args->argc; i++) {
***************
*** 802,819 ****
  		    n->line, n->pos, "Bd");
  		n->norm->Bd.type = DISP_ragged;
  	}
! 
! 	return(pre_par(mdoc, n));
  }
  
! static int
  pre_an(PRE_ARGS)
  {
  	struct mdoc_argv *argv;
  	size_t	 i;
  
  	if (n->args == NULL)
! 		return(1);
  
  	for (i = 1; i < n->args->argc; i++) {
  		argv = n->args->argv + i;
--- 767,783 ----
  		    n->line, n->pos, "Bd");
  		n->norm->Bd.type = DISP_ragged;
  	}
! 	pre_par(mdoc, n);
  }
  
! static void
  pre_an(PRE_ARGS)
  {
  	struct mdoc_argv *argv;
  	size_t	 i;
  
  	if (n->args == NULL)
! 		return;
  
  	for (i = 1; i < n->args->argc; i++) {
  		argv = n->args->argv + i;
***************
*** 829,862 ****
  		n->norm->An.auth = AUTH_nosplit;
  	else
  		abort();
- 
- 	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);
  
  	mandoc_msg(MANDOCERR_ARG_STD, mdoc->parse,
  	    n->line, n->pos, mdoc_macronames[n->tok]);
- 	return(1);
  }
  
! static int
  pre_obsolete(PRE_ARGS)
  {
  
  	if (MDOC_ELEM == n->type || MDOC_BLOCK == n->type)
  		mandoc_msg(MANDOCERR_MACRO_OBS, mdoc->parse,
  		    n->line, n->pos, mdoc_macronames[n->tok]);
- 	return(1);
  }
  
! static int
  pre_dt(PRE_ARGS)
  {
  
--- 793,822 ----
  		n->norm->An.auth = AUTH_nosplit;
  	else
  		abort();
  }
  
! static void
  pre_std(PRE_ARGS)
  {
  
  	if (n->args && 1 == n->args->argc)
  		if (MDOC_Std == n->args->argv[0].arg)
! 			return;
  
  	mandoc_msg(MANDOCERR_ARG_STD, mdoc->parse,
  	    n->line, n->pos, mdoc_macronames[n->tok]);
  }
  
! static void
  pre_obsolete(PRE_ARGS)
  {
  
  	if (MDOC_ELEM == n->type || MDOC_BLOCK == n->type)
  		mandoc_msg(MANDOCERR_MACRO_OBS, mdoc->parse,
  		    n->line, n->pos, mdoc_macronames[n->tok]);
  }
  
! static void
  pre_dt(PRE_ARGS)
  {
  
***************
*** 866,875 ****
  	else if (mdoc->meta.os != NULL)
  		mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
  		    n->line, n->pos, "Dt after Os");
- 	return(1);
  }
  
! static int
  pre_os(PRE_ARGS)
  {
  
--- 826,834 ----
  	else if (mdoc->meta.os != NULL)
  		mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
  		    n->line, n->pos, "Dt after Os");
  }
  
! static void
  pre_os(PRE_ARGS)
  {
  
***************
*** 879,888 ****
  	else if (mdoc->flags & MDOC_PBODY)
  		mandoc_msg(MANDOCERR_PROLOG_LATE, mdoc->parse,
  		    n->line, n->pos, "Os");
- 	return(1);
  }
  
! static int
  pre_dd(PRE_ARGS)
  {
  
--- 838,846 ----
  	else if (mdoc->flags & MDOC_PBODY)
  		mandoc_msg(MANDOCERR_PROLOG_LATE, mdoc->parse,
  		    n->line, n->pos, "Os");
  }
  
! static void
  pre_dd(PRE_ARGS)
  {
  
***************
*** 898,907 ****
  	else if (mdoc->meta.os != NULL)
  		mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
  		    n->line, n->pos, "Dd after Os");
- 	return(1);
  }
  
! static int
  post_bf(POST_ARGS)
  {
  	struct mdoc_node *np, *nch;
--- 856,864 ----
  	else if (mdoc->meta.os != NULL)
  		mandoc_msg(MANDOCERR_PROLOG_ORDER, mdoc->parse,
  		    n->line, n->pos, "Dd after Os");
  }
  
! static void
  post_bf(POST_ARGS)
  {
  	struct mdoc_node *np, *nch;
***************
*** 924,930 ****
  		assert(np);
  		assert(MDOC_HEAD == np->type);
  		assert(MDOC_Bf == np->tok);
! 		return(1);
  	}
  
  	np = mdoc->last;
--- 881,887 ----
  		assert(np);
  		assert(MDOC_HEAD == np->type);
  		assert(MDOC_Bf == np->tok);
! 		return;
  	}
  
  	np = mdoc->last;
***************
*** 938,944 ****
  		if (NULL == nch) {
  			mandoc_msg(MANDOCERR_BF_NOFONT, mdoc->parse,
  			    np->line, np->pos, "Bf");
! 			return(1);
  		}
  		nch = nch->next;
  	}
--- 895,901 ----
  		if (NULL == nch) {
  			mandoc_msg(MANDOCERR_BF_NOFONT, mdoc->parse,
  			    np->line, np->pos, "Bf");
! 			return;
  		}
  		nch = nch->next;
  	}
***************
*** 958,964 ****
  			np->norm->Bf.font = FONT_Sy;
  		else
  			abort();
! 		return(1);
  	}
  
  	/* Extract parameter into data. */
--- 915,921 ----
  			np->norm->Bf.font = FONT_Sy;
  		else
  			abort();
! 		return;
  	}
  
  	/* Extract parameter into data. */
***************
*** 973,983 ****
  		mandoc_vmsg(MANDOCERR_BF_BADFONT, mdoc->parse,
  		    np->child->line, np->child->pos,
  		    "Bf %s", np->child->string);
- 
- 	return(1);
  }
  
! static int
  post_lb(POST_ARGS)
  {
  	struct mdoc_node	*n;
--- 930,938 ----
  		mandoc_vmsg(MANDOCERR_BF_BADFONT, mdoc->parse,
  		    np->child->line, np->child->pos,
  		    "Bf %s", np->child->string);
  }
  
! static void
  post_lb(POST_ARGS)
  {
  	struct mdoc_node	*n;
***************
*** 999,1008 ****
  
  	free(n->string);
  	n->string = libname;
- 	return(1);
  }
  
! static int
  post_eoln(POST_ARGS)
  {
  	const struct mdoc_node *n;
--- 954,962 ----
  
  	free(n->string);
  	n->string = libname;
  }
  
! static void
  post_eoln(POST_ARGS)
  {
  	const struct mdoc_node *n;
***************
*** 1013,1022 ****
  		    mdoc->parse, n->line, n->pos,
  		    "%s %s", mdoc_macronames[n->tok],
  		    n->child->string);
- 	return(1);
  }
  
! static int
  post_fname(POST_ARGS)
  {
  	const struct mdoc_node	*n;
--- 967,975 ----
  		    mdoc->parse, n->line, n->pos,
  		    "%s %s", mdoc_macronames[n->tok],
  		    n->child->string);
  }
  
! static void
  post_fname(POST_ARGS)
  {
  	const struct mdoc_node	*n;
***************
*** 1029,1058 ****
  	if ( ! (cp[0] == '\0' || (cp[0] == '(' && cp[1] == '*')))
  		mandoc_msg(MANDOCERR_FN_PAREN, mdoc->parse,
  		    n->line, n->pos + pos, n->string);
- 	return(1);
  }
  
! static int
  post_fn(POST_ARGS)
  {
  
  	post_fname(mdoc);
  	post_fa(mdoc);
- 	return(1);
  }
  
! static int
  post_fo(POST_ARGS)
  {
  
! 	hwarn_eq1(mdoc);
  	bwarn_ge1(mdoc);
  	if (mdoc->last->type == MDOC_HEAD && mdoc->last->nchild)
  		post_fname(mdoc);
- 	return(1);
  }
  
! static int
  post_fa(POST_ARGS)
  {
  	const struct mdoc_node *n;
--- 982,1008 ----
  	if ( ! (cp[0] == '\0' || (cp[0] == '(' && cp[1] == '*')))
  		mandoc_msg(MANDOCERR_FN_PAREN, mdoc->parse,
  		    n->line, n->pos + pos, n->string);
  }
  
! static void
  post_fn(POST_ARGS)
  {
  
  	post_fname(mdoc);
  	post_fa(mdoc);
  }
  
! static void
  post_fo(POST_ARGS)
  {
  
! 	check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 1);
  	bwarn_ge1(mdoc);
  	if (mdoc->last->type == MDOC_HEAD && mdoc->last->nchild)
  		post_fname(mdoc);
  }
  
! static void
  post_fa(POST_ARGS)
  {
  	const struct mdoc_node *n;
***************
*** 1071,1080 ****
  			break;
  		}
  	}
- 	return(1);
  }
  
! static int
  post_vt(POST_ARGS)
  {
  	const struct mdoc_node *n;
--- 1021,1029 ----
  			break;
  		}
  	}
  }
  
! static void
  post_vt(POST_ARGS)
  {
  	const struct mdoc_node *n;
***************
*** 1088,1135 ****
  	 */
  
  	if (MDOC_BODY != mdoc->last->type)
! 		return(1);
  
  	for (n = mdoc->last->child; n; n = n->next)
  		if (MDOC_TEXT != n->type)
  			mandoc_msg(MANDOCERR_VT_CHILD, mdoc->parse,
  			    n->line, n->pos, mdoc_macronames[n->tok]);
- 
- 	return(1);
  }
  
! static int
  post_nm(POST_ARGS)
  {
  
  	if (NULL != mdoc->meta.name)
! 		return(1);
  
  	mdoc_deroff(&mdoc->meta.name, mdoc->last);
  
  	if (NULL == mdoc->meta.name)
  		mandoc_msg(MANDOCERR_NM_NONAME, mdoc->parse,
  		    mdoc->last->line, mdoc->last->pos, "Nm");
- 	return(1);
  }
  
! static int
  post_nd(POST_ARGS)
  {
  
! 	berr_ge1(mdoc);
! 	return(post_hyph(mdoc));
  }
  
! static int
  post_d1(POST_ARGS)
  {
  
  	bwarn_ge1(mdoc);
! 	return(post_hyph(mdoc));
  }
  
! static int
  post_literal(POST_ARGS)
  {
  
--- 1037,1081 ----
  	 */
  
  	if (MDOC_BODY != mdoc->last->type)
! 		return;
  
  	for (n = mdoc->last->child; n; n = n->next)
  		if (MDOC_TEXT != n->type)
  			mandoc_msg(MANDOCERR_VT_CHILD, mdoc->parse,
  			    n->line, n->pos, mdoc_macronames[n->tok]);
  }
  
! static void
  post_nm(POST_ARGS)
  {
  
  	if (NULL != mdoc->meta.name)
! 		return;
  
  	mdoc_deroff(&mdoc->meta.name, mdoc->last);
  
  	if (NULL == mdoc->meta.name)
  		mandoc_msg(MANDOCERR_NM_NONAME, mdoc->parse,
  		    mdoc->last->line, mdoc->last->pos, "Nm");
  }
  
! static void
  post_nd(POST_ARGS)
  {
  
! 	check_count(mdoc, MDOC_BODY, CHECK_ERROR, CHECK_GT, 0);
! 	post_hyph(mdoc);
  }
  
! static void
  post_d1(POST_ARGS)
  {
  
  	bwarn_ge1(mdoc);
! 	post_hyph(mdoc);
  }
  
! static void
  post_literal(POST_ARGS)
  {
  
***************
*** 1146,1156 ****
  
  	if (MDOC_BODY == mdoc->last->type)
  		mdoc->flags &= ~MDOC_LITERAL;
- 
- 	return(1);
  }
  
! static int
  post_defaults(POST_ARGS)
  {
  	struct mdoc_node *nn;
--- 1092,1100 ----
  
  	if (MDOC_BODY == mdoc->last->type)
  		mdoc->flags &= ~MDOC_LITERAL;
  }
  
! static void
  post_defaults(POST_ARGS)
  {
  	struct mdoc_node *nn;
***************
*** 1162,1195 ****
  	 */
  
  	if (mdoc->last->child)
! 		return(1);
  
  	nn = mdoc->last;
  	mdoc->next = MDOC_NEXT_CHILD;
  
  	switch (nn->tok) {
  	case MDOC_Ar:
! 		if ( ! mdoc_word_alloc(mdoc, nn->line, nn->pos, "file"))
! 			return(0);
! 		if ( ! mdoc_word_alloc(mdoc, nn->line, nn->pos, "..."))
! 			return(0);
  		break;
  	case MDOC_Pa:
  		/* FALLTHROUGH */
  	case MDOC_Mt:
! 		if ( ! mdoc_word_alloc(mdoc, nn->line, nn->pos, "~"))
! 			return(0);
  		break;
  	default:
  		abort();
  		/* NOTREACHED */
  	}
- 
  	mdoc->last = nn;
- 	return(1);
  }
  
! static int
  post_at(POST_ARGS)
  {
  	struct mdoc_node	*n;
--- 1106,1134 ----
  	 */
  
  	if (mdoc->last->child)
! 		return;
  
  	nn = mdoc->last;
  	mdoc->next = MDOC_NEXT_CHILD;
  
  	switch (nn->tok) {
  	case MDOC_Ar:
! 		mdoc_word_alloc(mdoc, nn->line, nn->pos, "file");
! 		mdoc_word_alloc(mdoc, nn->line, nn->pos, "...");
  		break;
  	case MDOC_Pa:
  		/* FALLTHROUGH */
  	case MDOC_Mt:
! 		mdoc_word_alloc(mdoc, nn->line, nn->pos, "~");
  		break;
  	default:
  		abort();
  		/* NOTREACHED */
  	}
  	mdoc->last = nn;
  }
  
! static void
  post_at(POST_ARGS)
  {
  	struct mdoc_node	*n;
***************
*** 1199,1208 ****
  	n = mdoc->last;
  	if (n->child == NULL) {
  		mdoc->next = MDOC_NEXT_CHILD;
! 		if ( ! mdoc_word_alloc(mdoc, n->line, n->pos, "AT&T UNIX"))
! 			return(0);
  		mdoc->last = n;
! 		return(1);
  	}
  
  	/*
--- 1138,1146 ----
  	n = mdoc->last;
  	if (n->child == NULL) {
  		mdoc->next = MDOC_NEXT_CHILD;
! 		mdoc_word_alloc(mdoc, n->line, n->pos, "AT&T UNIX");
  		mdoc->last = n;
! 		return;
  	}
  
  	/*
***************
*** 1222,1231 ****
  
  	free(n->string);
  	n->string = att;
- 	return(1);
  }
  
! static int
  post_an(POST_ARGS)
  {
  	struct mdoc_node *np;
--- 1160,1168 ----
  
  	free(n->string);
  	n->string = att;
  }
  
! static void
  post_an(POST_ARGS)
  {
  	struct mdoc_node *np;
***************
*** 1236,1263 ****
  			check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0);
  	} else if (np->child)
  		check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0);
- 
- 	return(1);
  }
  
! static int
  post_en(POST_ARGS)
  {
  
  	if (MDOC_BLOCK == mdoc->last->type)
  		mdoc->last->norm->Es = mdoc->last_es;
- 	return(1);
  }
  
! static int
  post_es(POST_ARGS)
  {
  
  	mdoc->last_es = mdoc->last;
- 	return(1);
  }
  
! static int
  post_it(POST_ARGS)
  {
  	int		  i, cols;
--- 1173,1196 ----
  			check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0);
  	} else if (np->child)
  		check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0);
  }
  
! static void
  post_en(POST_ARGS)
  {
  
  	if (MDOC_BLOCK == mdoc->last->type)
  		mdoc->last->norm->Es = mdoc->last_es;
  }
  
! static void
  post_es(POST_ARGS)
  {
  
  	mdoc->last_es = mdoc->last;
  }
  
! static void
  post_it(POST_ARGS)
  {
  	int		  i, cols;
***************
*** 1266,1272 ****
  
  	nit = mdoc->last;
  	if (MDOC_BLOCK != nit->type)
! 		return(1);
  
  	nbl = nit->parent->parent;
  	lt = nbl->norm->Bl.type;
--- 1199,1205 ----
  
  	nit = mdoc->last;
  	if (MDOC_BLOCK != nit->type)
! 		return;
  
  	nbl = nit->parent->parent;
  	lt = nbl->norm->Bl.type;
***************
*** 1323,1333 ****
  	default:
  		abort();
  	}
- 
- 	return(1);
  }
  
! static int
  post_bl_block(POST_ARGS)
  {
  	struct mdoc_node *n, *ni, *nc;
--- 1256,1264 ----
  	default:
  		abort();
  	}
  }
  
! static void
  post_bl_block(POST_ARGS)
  {
  	struct mdoc_node *n, *ni, *nc;
***************
*** 1344,1351 ****
  
  	if (LIST_tag == n->norm->Bl.type &&
  	    NULL == n->norm->Bl.width) {
! 		if ( ! post_bl_block_tag(mdoc))
! 			return(0);
  		assert(n->norm->Bl.width);
  	}
  
--- 1275,1281 ----
  
  	if (LIST_tag == n->norm->Bl.type &&
  	    NULL == n->norm->Bl.width) {
! 		post_bl_block_tag(mdoc);
  		assert(n->norm->Bl.width);
  	}
  
***************
*** 1369,1376 ****
  				mandoc_msg(MANDOCERR_PAR_MOVE,
  				    mdoc->parse, nc->line, nc->pos,
  				    mdoc_macronames[nc->tok]);
! 				if ( ! mdoc_node_relink(mdoc, nc))
! 					return(0);
  			} else if (0 == n->norm->Bl.comp &&
  			    LIST_column != n->norm->Bl.type) {
  				mandoc_vmsg(MANDOCERR_PAR_SKIP,
--- 1299,1305 ----
  				mandoc_msg(MANDOCERR_PAR_MOVE,
  				    mdoc->parse, nc->line, nc->pos,
  				    mdoc_macronames[nc->tok]);
! 				mdoc_node_relink(mdoc, nc);
  			} else if (0 == n->norm->Bl.comp &&
  			    LIST_column != n->norm->Bl.type) {
  				mandoc_vmsg(MANDOCERR_PAR_SKIP,
***************
*** 1383,1389 ****
  			nc = ni->body->last;
  		}
  	}
- 	return(1);
  }
  
  /*
--- 1312,1317 ----
***************
*** 1409,1415 ****
  	mandoc_asprintf(arg, "%zun", width);
  }
  
! static int
  post_bl_block_tag(POST_ARGS)
  {
  	struct mdoc_node *n, *nn;
--- 1337,1343 ----
  	mandoc_asprintf(arg, "%zun", width);
  }
  
! static void
  post_bl_block_tag(POST_ARGS)
  {
  	struct mdoc_node *n, *nn;
***************
*** 1472,1490 ****
  
  	/* Set our width! */
  	n->norm->Bl.width = n->args->argv[i].value[0];
- 	return(1);
  }
  
! static int
  post_bl_head(POST_ARGS)
  {
  	struct mdoc_node *np, *nn, *nnp;
  	struct mdoc_argv *argv;
  	int		  i, j;
  
! 	if (LIST_column != mdoc->last->norm->Bl.type)
  		/* FIXME: this should be ERROR class... */
! 		return(hwarn_eq0(mdoc));
  
  	/*
  	 * Append old-style lists, where the column width specifiers
--- 1400,1419 ----
  
  	/* Set our width! */
  	n->norm->Bl.width = n->args->argv[i].value[0];
  }
  
! static void
  post_bl_head(POST_ARGS)
  {
  	struct mdoc_node *np, *nn, *nnp;
  	struct mdoc_argv *argv;
  	int		  i, j;
  
! 	if (LIST_column != mdoc->last->norm->Bl.type) {
  		/* FIXME: this should be ERROR class... */
! 		hwarn_eq0(mdoc);
! 		return;
! 	}
  
  	/*
  	 * Append old-style lists, where the column width specifiers
***************
*** 1493,1499 ****
  	 */
  
  	if (mdoc->last->child == NULL)
! 		return(1);
  
  	np = mdoc->last->parent;
  	assert(np->args);
--- 1422,1428 ----
  	 */
  
  	if (mdoc->last->child == NULL)
! 		return;
  
  	np = mdoc->last->parent;
  	assert(np->args);
***************
*** 1529,1539 ****
  
  	mdoc->last->nchild = 0;
  	mdoc->last->child = NULL;
- 
- 	return(1);
  }
  
! static int
  post_bl(POST_ARGS)
  {
  	struct mdoc_node	*nparent, *nprev; /* of the Bl block */
--- 1458,1466 ----
  
  	mdoc->last->nchild = 0;
  	mdoc->last->child = NULL;
  }
  
! static void
  post_bl(POST_ARGS)
  {
  	struct mdoc_node	*nparent, *nprev; /* of the Bl block */
***************
*** 1543,1555 ****
  	nbody = mdoc->last;
  	switch (nbody->type) {
  	case MDOC_BLOCK:
! 		return(post_bl_block(mdoc));
  	case MDOC_HEAD:
! 		return(post_bl_head(mdoc));
  	case MDOC_BODY:
  		break;
  	default:
! 		return(1);
  	}
  
  	bwarn_ge1(mdoc);
--- 1470,1484 ----
  	nbody = mdoc->last;
  	switch (nbody->type) {
  	case MDOC_BLOCK:
! 		post_bl_block(mdoc);
! 		return;
  	case MDOC_HEAD:
! 		post_bl_head(mdoc);
! 		return;
  	case MDOC_BODY:
  		break;
  	default:
! 		return;
  	}
  
  	bwarn_ge1(mdoc);
***************
*** 1606,1625 ****
  
  		nchild = nnext;
  	}
- 
- 	return(1);
  }
  
! static int
  post_bk(POST_ARGS)
  {
  
  	hwarn_eq0(mdoc);
  	bwarn_ge1(mdoc);
- 	return(1);
  }
  
! static int
  post_sm(struct mdoc *mdoc)
  {
  	struct mdoc_node	*nch;
--- 1535,1551 ----
  
  		nchild = nnext;
  	}
  }
  
! static void
  post_bk(POST_ARGS)
  {
  
  	hwarn_eq0(mdoc);
  	bwarn_ge1(mdoc);
  }
  
! static void
  post_sm(struct mdoc *mdoc)
  {
  	struct mdoc_node	*nch;
***************
*** 1628,1654 ****
  
  	if (nch == NULL) {
  		mdoc->flags ^= MDOC_SMOFF;
! 		return(1);
  	}
  
  	assert(nch->type == MDOC_TEXT);
  
  	if ( ! strcmp(nch->string, "on")) {
  		mdoc->flags &= ~MDOC_SMOFF;
! 		return(1);
  	}
  	if ( ! strcmp(nch->string, "off")) {
  		mdoc->flags |= MDOC_SMOFF;
! 		return(1);
  	}
  
  	mandoc_vmsg(MANDOCERR_SM_BAD,
  	    mdoc->parse, nch->line, nch->pos,
  	    "%s %s", mdoc_macronames[mdoc->last->tok], nch->string);
! 	return(mdoc_node_relink(mdoc, nch));
  }
  
! static int
  post_root(POST_ARGS)
  {
  	struct mdoc_node *n;
--- 1554,1581 ----
  
  	if (nch == NULL) {
  		mdoc->flags ^= MDOC_SMOFF;
! 		return;
  	}
  
  	assert(nch->type == MDOC_TEXT);
  
  	if ( ! strcmp(nch->string, "on")) {
  		mdoc->flags &= ~MDOC_SMOFF;
! 		return;
  	}
  	if ( ! strcmp(nch->string, "off")) {
  		mdoc->flags |= MDOC_SMOFF;
! 		return;
  	}
  
  	mandoc_vmsg(MANDOCERR_SM_BAD,
  	    mdoc->parse, nch->line, nch->pos,
  	    "%s %s", mdoc_macronames[mdoc->last->tok], nch->string);
! 	mdoc_node_relink(mdoc, nch);
! 	return;
  }
  
! static void
  post_root(POST_ARGS)
  {
  	struct mdoc_node *n;
***************
*** 1686,1696 ****
  	else if (n->tok != MDOC_Sh)
  		mandoc_msg(MANDOCERR_SEC_BEFORE, mdoc->parse,
  		    n->line, n->pos, mdoc_macronames[n->tok]);
- 
- 	return(1);
  }
  
! static int
  post_st(POST_ARGS)
  {
  	struct mdoc_node	 *n, *nch;
--- 1613,1621 ----
  	else if (n->tok != MDOC_Sh)
  		mandoc_msg(MANDOCERR_SEC_BEFORE, mdoc->parse,
  		    n->line, n->pos, mdoc_macronames[n->tok]);
  }
  
! static void
  post_st(POST_ARGS)
  {
  	struct mdoc_node	 *n, *nch;
***************
*** 1703,1709 ****
  		mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
  		    n->line, n->pos, mdoc_macronames[n->tok]);
  		mdoc_node_delete(mdoc, n);
! 		return(1);
  	}
  
  	assert(MDOC_TEXT == nch->type);
--- 1628,1634 ----
  		mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
  		    n->line, n->pos, mdoc_macronames[n->tok]);
  		mdoc_node_delete(mdoc, n);
! 		return;
  	}
  
  	assert(MDOC_TEXT == nch->type);
***************
*** 1716,1726 ****
  		free(nch->string);
  		nch->string = mandoc_strdup(p);
  	}
- 
- 	return(1);
  }
  
! static int
  post_rs(POST_ARGS)
  {
  	struct mdoc_node *nn, *next, *prev;
--- 1641,1649 ----
  		free(nch->string);
  		nch->string = mandoc_strdup(p);
  	}
  }
  
! static void
  post_rs(POST_ARGS)
  {
  	struct mdoc_node *nn, *next, *prev;
***************
*** 1729,1742 ****
  	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);
  	}
  
  	/*
--- 1652,1665 ----
  	switch (mdoc->last->type) {
  	case MDOC_HEAD:
  		check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0);
! 		return;
  	case MDOC_BODY:
  		if (mdoc->last->child)
  			break;
  		check_count(mdoc, MDOC_BODY, CHECK_WARN, CHECK_GT, 0);
! 		return;
  	default:
! 		return;
  	}
  
  	/*
***************
*** 1810,1824 ****
  			mdoc->last->child = nn;
  		}
  	}
- 
- 	return(1);
  }
  
  /*
   * For some arguments of some macros,
   * convert all breakable hyphens into ASCII_HYPH.
   */
! static int
  post_hyph(POST_ARGS)
  {
  	struct mdoc_node	*n, *nch;
--- 1733,1745 ----
  			mdoc->last->child = nn;
  		}
  	}
  }
  
  /*
   * For some arguments of some macros,
   * convert all breakable hyphens into ASCII_HYPH.
   */
! static void
  post_hyph(POST_ARGS)
  {
  	struct mdoc_node	*n, *nch;
***************
*** 1829,1843 ****
  	case MDOC_HEAD:
  		if (MDOC_Sh == n->tok || MDOC_Ss == n->tok)
  			break;
! 		return(1);
  	case MDOC_BODY:
  		if (MDOC_D1 == n->tok || MDOC_Nd == n->tok)
  			break;
! 		return(1);
  	case MDOC_ELEM:
  		break;
  	default:
! 		return(1);
  	}
  
  	for (nch = n->child; nch; nch = nch->next) {
--- 1750,1764 ----
  	case MDOC_HEAD:
  		if (MDOC_Sh == n->tok || MDOC_Ss == n->tok)
  			break;
! 		return;
  	case MDOC_BODY:
  		if (MDOC_D1 == n->tok || MDOC_Nd == n->tok)
  			break;
! 		return;
  	case MDOC_ELEM:
  		break;
  	default:
! 		return;
  	}
  
  	for (nch = n->child; nch; nch = nch->next) {
***************
*** 1852,1879 ****
  			    isalpha((unsigned char)cp[1]))
  				*cp = ASCII_HYPH;
  	}
- 	return(1);
  }
  
! static int
  post_hyphtext(POST_ARGS)
  {
  
  	ewarn_ge1(mdoc);
! 	return(post_hyph(mdoc));
  }
  
! static int
  post_ns(POST_ARGS)
  {
  
  	if (MDOC_LINE & mdoc->last->flags)
  		mandoc_msg(MANDOCERR_NS_SKIP, mdoc->parse,
  		    mdoc->last->line, mdoc->last->pos, NULL);
- 	return(1);
  }
  
! static int
  post_sh(POST_ARGS)
  {
  
--- 1773,1798 ----
  			    isalpha((unsigned char)cp[1]))
  				*cp = ASCII_HYPH;
  	}
  }
  
! static void
  post_hyphtext(POST_ARGS)
  {
  
  	ewarn_ge1(mdoc);
! 	post_hyph(mdoc);
  }
  
! static void
  post_ns(POST_ARGS)
  {
  
  	if (MDOC_LINE & mdoc->last->flags)
  		mandoc_msg(MANDOCERR_NS_SKIP, mdoc->parse,
  		    mdoc->last->line, mdoc->last->pos, NULL);
  }
  
! static void
  post_sh(POST_ARGS)
  {
  
***************
*** 1881,1895 ****
  
  	switch (mdoc->last->type) {
  	case MDOC_HEAD:
! 		return(post_sh_head(mdoc));
  	case MDOC_BODY:
  		switch (mdoc->lastsec)  {
  		case SEC_NAME:
! 			return(post_sh_name(mdoc));
  		case SEC_SEE_ALSO:
! 			return(post_sh_see_also(mdoc));
  		case SEC_AUTHORS:
! 			return(post_sh_authors(mdoc));
  		default:
  			break;
  		}
--- 1800,1818 ----
  
  	switch (mdoc->last->type) {
  	case MDOC_HEAD:
! 		post_sh_head(mdoc);
! 		break;
  	case MDOC_BODY:
  		switch (mdoc->lastsec)  {
  		case SEC_NAME:
! 			post_sh_name(mdoc);
! 			break;
  		case SEC_SEE_ALSO:
! 			post_sh_see_also(mdoc);
! 			break;
  		case SEC_AUTHORS:
! 			post_sh_authors(mdoc);
! 			break;
  		default:
  			break;
  		}
***************
*** 1897,1907 ****
  	default:
  		break;
  	}
- 
- 	return(1);
  }
  
! static int
  post_sh_name(POST_ARGS)
  {
  	struct mdoc_node *n;
--- 1820,1828 ----
  	default:
  		break;
  	}
  }
  
! static void
  post_sh_name(POST_ARGS)
  {
  	struct mdoc_node *n;
***************
*** 1915,1921 ****
  	if (NULL == (n = mdoc->last->child)) {
  		mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
  		    mdoc->last->line, mdoc->last->pos, "empty");
! 		return(1);
  	}
  
  	for ( ; n && n->next; n = n->next) {
--- 1836,1842 ----
  	if (NULL == (n = mdoc->last->child)) {
  		mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
  		    mdoc->last->line, mdoc->last->pos, "empty");
! 		return;
  	}
  
  	for ( ; n && n->next; n = n->next) {
***************
*** 1929,1942 ****
  
  	assert(n);
  	if (MDOC_BLOCK == n->type && MDOC_Nd == n->tok)
! 		return(1);
  
  	mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
  	    n->line, n->pos, mdoc_macronames[n->tok]);
- 	return(1);
  }
  
! static int
  post_sh_see_also(POST_ARGS)
  {
  	const struct mdoc_node	*n;
--- 1850,1862 ----
  
  	assert(n);
  	if (MDOC_BLOCK == n->type && MDOC_Nd == n->tok)
! 		return;
  
  	mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
  	    n->line, n->pos, mdoc_macronames[n->tok]);
  }
  
! static void
  post_sh_see_also(POST_ARGS)
  {
  	const struct mdoc_node	*n;
***************
*** 1988,1994 ****
  			break;
  		for (name = n->string; *name != '\0'; name++)
  			if (isalpha((const unsigned char)*name))
! 				return(1);
  		lastpunct = n->string;
  		if (n->next == NULL)
  			mandoc_vmsg(MANDOCERR_XR_PUNCT, mdoc->parse,
--- 1908,1914 ----
  			break;
  		for (name = n->string; *name != '\0'; name++)
  			if (isalpha((const unsigned char)*name))
! 				return;
  		lastpunct = n->string;
  		if (n->next == NULL)
  			mandoc_vmsg(MANDOCERR_XR_PUNCT, mdoc->parse,
***************
*** 1996,2002 ****
  			    lastpunct, lastname, lastsec);
  		n = n->next;
  	}
- 	return(1);
  }
  
  static int
--- 1916,1921 ----
***************
*** 2009,2025 ****
  	return(0);
  }
  
! static int
  post_sh_authors(POST_ARGS)
  {
  
  	if ( ! child_an(mdoc->last))
  		mandoc_msg(MANDOCERR_AN_MISSING, mdoc->parse,
  		    mdoc->last->line, mdoc->last->pos, NULL);
- 	return(1);
  }
  
! static int
  post_sh_head(POST_ARGS)
  {
  	struct mdoc_node *n;
--- 1928,1943 ----
  	return(0);
  }
  
! static void
  post_sh_authors(POST_ARGS)
  {
  
  	if ( ! child_an(mdoc->last))
  		mandoc_msg(MANDOCERR_AN_MISSING, mdoc->parse,
  		    mdoc->last->line, mdoc->last->pos, NULL);
  }
  
! static void
  post_sh_head(POST_ARGS)
  {
  	struct mdoc_node *n;
***************
*** 2078,2084 ****
  
  	if (SEC_CUSTOM == sec) {
  		free(secname);
! 		return(1);
  	}
  
  	/*
--- 1996,2002 ----
  
  	if (SEC_CUSTOM == sec) {
  		free(secname);
! 		return;
  	}
  
  	/*
***************
*** 2104,2110 ****
  
  	if (mdoc->meta.msec == NULL) {
  		free(secname);
! 		return(1);
  	}
  
  	goodsec = NULL;
--- 2022,2028 ----
  
  	if (mdoc->meta.msec == NULL) {
  		free(secname);
! 		return;
  	}
  
  	goodsec = NULL;
***************
*** 2136,2156 ****
  	default:
  		break;
  	}
- 
  	free(secname);
- 	return(1);
  }
  
! static int
  post_ignpar(POST_ARGS)
  {
  	struct mdoc_node *np;
  
! 	hwarn_ge1(mdoc);
  	post_hyph(mdoc);
  
  	if (MDOC_BODY != mdoc->last->type)
! 		return(1);
  
  	if (NULL != (np = mdoc->last->child))
  		if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {
--- 2054,2072 ----
  	default:
  		break;
  	}
  	free(secname);
  }
  
! static void
  post_ignpar(POST_ARGS)
  {
  	struct mdoc_node *np;
  
! 	check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_GT, 0);
  	post_hyph(mdoc);
  
  	if (MDOC_BODY != mdoc->last->type)
! 		return;
  
  	if (NULL != (np = mdoc->last->child))
  		if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {
***************
*** 2169,2186 ****
  			    mdoc_macronames[mdoc->last->tok]);
  			mdoc_node_delete(mdoc, np);
  		}
- 
- 	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
--- 2085,2100 ----
  			    mdoc_macronames[mdoc->last->tok]);
  			mdoc_node_delete(mdoc, np);
  		}
  }
  
! static void
  pre_par(PRE_ARGS)
  {
  
  	if (NULL == mdoc->last)
! 		return;
  	if (MDOC_ELEM != n->type && MDOC_BLOCK != n->type)
! 		return;
  
  	/*
  	 * Don't allow prior `Lp' or `Pp' prior to a paragraph-type
***************
*** 2190,2252 ****
  	if (MDOC_Pp != mdoc->last->tok &&
  	    MDOC_Lp != mdoc->last->tok &&
  	    MDOC_br != 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);
  
  	mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
  	    mdoc->last->line, mdoc->last->pos,
  	    "%s before %s", mdoc_macronames[mdoc->last->tok],
  	    mdoc_macronames[n->tok]);
  	mdoc_node_delete(mdoc, mdoc->last);
- 	return(1);
  }
  
! static int
  post_par(POST_ARGS)
  {
  	struct mdoc_node *np;
  
  	if (mdoc->last->tok == MDOC_sp)
! 		ewarn_le1(mdoc);
  	else
! 		ewarn_eq0(mdoc);
  
  	if (MDOC_ELEM != mdoc->last->type &&
  	    MDOC_BLOCK != mdoc->last->type)
! 		return(1);
  
  	if (NULL == (np = mdoc->last->prev)) {
  		np = mdoc->last->parent;
  		if (MDOC_Sh != np->tok && MDOC_Ss != np->tok)
! 			return(1);
! 	} else {
! 		if (MDOC_Pp != np->tok && MDOC_Lp != np->tok &&
! 		    (MDOC_br != mdoc->last->tok ||
! 		     (MDOC_sp != np->tok && MDOC_br != np->tok)))
! 			return(1);
! 	}
  
  	mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
  	    mdoc->last->line, mdoc->last->pos,
  	    "%s after %s", mdoc_macronames[mdoc->last->tok],
  	    mdoc_macronames[np->tok]);
  	mdoc_node_delete(mdoc, mdoc->last);
- 	return(1);
  }
  
! static int
  pre_literal(PRE_ARGS)
  {
  
  	pre_display(mdoc, n);
  
  	if (MDOC_BODY != n->type)
! 		return(1);
  
  	/*
  	 * The `Dl' (note "el" not "one") and `Bd -literal' and `Bd
--- 2104,2162 ----
  	if (MDOC_Pp != mdoc->last->tok &&
  	    MDOC_Lp != mdoc->last->tok &&
  	    MDOC_br != mdoc->last->tok)
! 		return;
  	if (MDOC_Bl == n->tok && n->norm->Bl.comp)
! 		return;
  	if (MDOC_Bd == n->tok && n->norm->Bd.comp)
! 		return;
  	if (MDOC_It == n->tok && n->parent->norm->Bl.comp)
! 		return;
  
  	mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
  	    mdoc->last->line, mdoc->last->pos,
  	    "%s before %s", mdoc_macronames[mdoc->last->tok],
  	    mdoc_macronames[n->tok]);
  	mdoc_node_delete(mdoc, mdoc->last);
  }
  
! static void
  post_par(POST_ARGS)
  {
  	struct mdoc_node *np;
  
  	if (mdoc->last->tok == MDOC_sp)
! 		check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_LT, 2);
  	else
! 		check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0);
  
  	if (MDOC_ELEM != mdoc->last->type &&
  	    MDOC_BLOCK != mdoc->last->type)
! 		return;
  
  	if (NULL == (np = mdoc->last->prev)) {
  		np = mdoc->last->parent;
  		if (MDOC_Sh != np->tok && MDOC_Ss != np->tok)
! 			return;
! 	} else if (MDOC_Pp != np->tok && MDOC_Lp != np->tok &&
! 	    (MDOC_br != mdoc->last->tok ||
! 	     (MDOC_sp != np->tok && MDOC_br != np->tok)))
! 		return;
  
  	mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
  	    mdoc->last->line, mdoc->last->pos,
  	    "%s after %s", mdoc_macronames[mdoc->last->tok],
  	    mdoc_macronames[np->tok]);
  	mdoc_node_delete(mdoc, mdoc->last);
  }
  
! static void
  pre_literal(PRE_ARGS)
  {
  
  	pre_display(mdoc, n);
  
  	if (MDOC_BODY != n->type)
! 		return;
  
  	/*
  	 * The `Dl' (note "el" not "one") and `Bd -literal' and `Bd
***************
*** 2267,2277 ****
  		abort();
  		/* NOTREACHED */
  	}
- 
- 	return(1);
  }
  
! static int
  post_dd(POST_ARGS)
  {
  	struct mdoc_node *n;
--- 2177,2185 ----
  		abort();
  		/* NOTREACHED */
  	}
  }
  
! static void
  post_dd(POST_ARGS)
  {
  	struct mdoc_node *n;
***************
*** 2298,2307 ****
  	}
  out:
  	mdoc_node_delete(mdoc, n);
- 	return(1);
  }
  
! static int
  post_dt(POST_ARGS)
  {
  	struct mdoc_node *nn, *n;
--- 2206,2214 ----
  	}
  out:
  	mdoc_node_delete(mdoc, n);
  }
  
! static void
  post_dt(POST_ARGS)
  {
  	struct mdoc_node *nn, *n;
***************
*** 2403,2412 ****
  	/* FIXME: warn about subsequent parameters. */
  out:
  	mdoc_node_delete(mdoc, n);
- 	return(1);
  }
  
! static int
  post_bx(POST_ARGS)
  {
  	struct mdoc_node	*n;
--- 2310,2318 ----
  	/* FIXME: warn about subsequent parameters. */
  out:
  	mdoc_node_delete(mdoc, n);
  }
  
! static void
  post_bx(POST_ARGS)
  {
  	struct mdoc_node	*n;
***************
*** 2420,2430 ****
  	n = mdoc->last->child;
  	if (n && NULL != (n = n->next))
  		*n->string = (char)toupper((unsigned char)*n->string);
- 
- 	return(1);
  }
  
! static int
  post_os(POST_ARGS)
  {
  #ifndef OSNAME
--- 2326,2334 ----
  	n = mdoc->last->child;
  	if (n && NULL != (n = n->next))
  		*n->string = (char)toupper((unsigned char)*n->string);
  }
  
! static void
  post_os(POST_ARGS)
  {
  #ifndef OSNAME
***************
*** 2472,2485 ****
  
  out:
  	mdoc_node_delete(mdoc, n);
- 	return(1);
  }
  
  /*
   * If no argument is provided,
   * fill in the name of the current manual page.
   */
! static int
  post_ex(POST_ARGS)
  {
  	struct mdoc_node *n;
--- 2376,2388 ----
  
  out:
  	mdoc_node_delete(mdoc, n);
  }
  
  /*
   * If no argument is provided,
   * fill in the name of the current manual page.
   */
! static void
  post_ex(POST_ARGS)
  {
  	struct mdoc_node *n;
***************
*** 2487,2507 ****
  	n = mdoc->last;
  
  	if (n->child)
! 		return(1);
  
  	if (mdoc->meta.name == NULL) {
  		mandoc_msg(MANDOCERR_EX_NONAME, mdoc->parse,
  		    n->line, n->pos, "Ex");
! 		return(1);
  	}
  
  	mdoc->next = MDOC_NEXT_CHILD;
! 
! 	if ( ! mdoc_word_alloc(mdoc, n->line, n->pos, mdoc->meta.name))
! 		return(0);
! 
  	mdoc->last = n;
- 	return(1);
  }
  
  static enum mdoc_sec
--- 2390,2406 ----
  	n = mdoc->last;
  
  	if (n->child)
! 		return;
  
  	if (mdoc->meta.name == NULL) {
  		mandoc_msg(MANDOCERR_EX_NONAME, mdoc->parse,
  		    n->line, n->pos, "Ex");
! 		return;
  	}
  
  	mdoc->next = MDOC_NEXT_CHILD;
! 	mdoc_word_alloc(mdoc, n->line, n->pos, mdoc->meta.name);
  	mdoc->last = n;
  }
  
  static enum mdoc_sec