===================================================================
RCS file: /cvs/mandoc/mdoc_validate.c,v
retrieving revision 1.107
retrieving revision 1.120
diff -u -p -r1.107 -r1.120
--- mandoc/mdoc_validate.c	2010/07/02 15:03:14	1.107
+++ mandoc/mdoc_validate.c	2010/10/11 13:24:33	1.120
@@ -1,6 +1,6 @@
-/*	$Id: mdoc_validate.c,v 1.107 2010/07/02 15:03:14 kristaps Exp $ */
+/*	$Id: mdoc_validate.c,v 1.120 2010/10/11 13:24:33 kristaps Exp $ */
 /*
- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -32,11 +32,22 @@
 #include "libmandoc.h"
 
 /* FIXME: .Bl -diag can't have non-text children in HEAD. */
-/* TODO: ignoring Pp (it's superfluous in some invocations). */
 
 #define	PRE_ARGS  struct mdoc *mdoc, struct mdoc_node *n
 #define	POST_ARGS struct mdoc *mdoc
 
+enum	check_ineq {
+	CHECK_LT,
+	CHECK_GT,
+	CHECK_EQ
+};
+
+enum	check_lvl {
+	CHECK_WARN,
+	CHECK_ERROR,
+	CHECK_FATAL
+};
+
 typedef	int	(*v_pre)(PRE_ARGS);
 typedef	int	(*v_post)(POST_ARGS);
 
@@ -45,35 +56,28 @@ struct	valids {
 	v_post	*post;
 };
 
+static	int	 check_count(struct mdoc *, enum mdoc_type, 
+			enum check_lvl, enum check_ineq, int);
 static	int	 check_parent(PRE_ARGS, enum mdoct, enum mdoc_type);
 static	int	 check_stdarg(PRE_ARGS);
 static	int	 check_text(struct mdoc *, int, int, char *);
 static	int	 check_argv(struct mdoc *, 
 			struct mdoc_node *, struct mdoc_argv *);
 static	int	 check_args(struct mdoc *, struct mdoc_node *);
-static	int	 err_child_lt(struct mdoc *, const char *, int);
-static	int	 warn_child_lt(struct mdoc *, const char *, int);
-static	int	 err_child_gt(struct mdoc *, const char *, int);
-static	int	 warn_child_gt(struct mdoc *, const char *, int);
-static	int	 err_child_eq(struct mdoc *, const char *, int);
-static	int	 warn_child_eq(struct mdoc *, const char *, int);
-static	int	 warn_count(struct mdoc *, const char *, 
-			int, const char *, int);
-static	int	 err_count(struct mdoc *, const char *, 
-			int, const char *, int);
 
+static	int	 ebool(POST_ARGS);
 static	int	 berr_ge1(POST_ARGS);
 static	int	 bwarn_ge1(POST_ARGS);
-static	int	 ebool(POST_ARGS);
 static	int	 eerr_eq0(POST_ARGS);
 static	int	 eerr_eq1(POST_ARGS);
 static	int	 eerr_ge1(POST_ARGS);
 static	int	 eerr_le1(POST_ARGS);
+static	int	 ewarn_eq0(POST_ARGS);
 static	int	 ewarn_ge1(POST_ARGS);
 static	int	 herr_eq0(POST_ARGS);
 static	int	 herr_ge1(POST_ARGS);
-static	int	 hwarn_eq1(POST_ARGS);
 static	int	 hwarn_eq0(POST_ARGS);
+static	int	 hwarn_eq1(POST_ARGS);
 static	int	 hwarn_le1(POST_ARGS);
 
 static	int	 post_an(POST_ARGS);
@@ -101,6 +105,7 @@ static	int	 pre_display(PRE_ARGS);
 static	int	 pre_dt(PRE_ARGS);
 static	int	 pre_it(PRE_ARGS);
 static	int	 pre_os(PRE_ARGS);
+static	int	 pre_pp(PRE_ARGS);
 static	int	 pre_rv(PRE_ARGS);
 static	int	 pre_sh(PRE_ARGS);
 static	int	 pre_ss(PRE_ARGS);
@@ -118,7 +123,7 @@ static	v_post	 posts_it[] = { post_it, NULL };
 static	v_post	 posts_lb[] = { eerr_eq1, post_lb, NULL };
 static	v_post	 posts_nd[] = { berr_ge1, NULL };
 static	v_post	 posts_nm[] = { post_nm, NULL };
-static	v_post	 posts_notext[] = { eerr_eq0, NULL };
+static	v_post	 posts_notext[] = { ewarn_eq0, NULL };
 static	v_post	 posts_rs[] = { berr_ge1, herr_eq0, post_rs, NULL };
 static	v_post	 posts_sh[] = { herr_ge1, bwarn_ge1, post_sh, NULL };
 static	v_post	 posts_sp[] = { eerr_le1, NULL };
@@ -130,8 +135,8 @@ static	v_post	 posts_vt[] = { post_vt, NULL };
 static	v_post	 posts_wline[] = { bwarn_ge1, herr_eq0, NULL };
 static	v_post	 posts_wtext[] = { ewarn_ge1, NULL };
 static	v_pre	 pres_an[] = { pre_an, NULL };
-static	v_pre	 pres_bd[] = { pre_display, pre_bd, NULL };
-static	v_pre	 pres_bl[] = { pre_bl, NULL };
+static	v_pre	 pres_bd[] = { pre_display, pre_bd, pre_pp, NULL };
+static	v_pre	 pres_bl[] = { pre_bl, pre_pp, NULL };
 static	v_pre	 pres_d1[] = { pre_display, NULL };
 static	v_pre	 pres_dd[] = { pre_dd, NULL };
 static	v_pre	 pres_dt[] = { pre_dt, NULL };
@@ -140,18 +145,19 @@ static	v_pre	 pres_ex[] = { NULL, NULL };
 static	v_pre	 pres_fd[] = { NULL, NULL };
 static	v_pre	 pres_it[] = { pre_it, NULL };
 static	v_pre	 pres_os[] = { pre_os, NULL };
+static	v_pre	 pres_pp[] = { pre_pp, NULL };
 static	v_pre	 pres_rv[] = { pre_rv, NULL };
 static	v_pre	 pres_sh[] = { pre_sh, NULL };
 static	v_pre	 pres_ss[] = { pre_ss, NULL };
 
 const	struct valids mdoc_valids[MDOC_MAX] = {
 	{ NULL, NULL },				/* Ap */
-	{ pres_dd, posts_text },		/* Dd */
+	{ pres_dd, posts_wtext },		/* Dd */
 	{ pres_dt, posts_dt },			/* Dt */
 	{ pres_os, NULL },			/* Os */
 	{ pres_sh, posts_sh },			/* Sh */ 
 	{ pres_ss, posts_ss },			/* Ss */ 
-	{ NULL, posts_notext },			/* Pp */ 
+	{ pres_pp, posts_notext },		/* Pp */ 
 	{ pres_d1, posts_wline },		/* D1 */
 	{ pres_d1, posts_wline },		/* Dl */
 	{ pres_bd, posts_bd_bk },		/* Bd */
@@ -264,7 +270,7 @@ const	struct valids mdoc_valids[MDOC_MAX] = {
 	{ NULL, NULL },				/* Dx */
 	{ NULL, posts_text },			/* %Q */
 	{ NULL, posts_notext },			/* br */
-	{ NULL, posts_sp },			/* sp */
+	{ pres_pp, posts_sp },			/* sp */
 	{ NULL, posts_text1 },			/* %U */
 	{ NULL, NULL },				/* Ta */
 };
@@ -318,93 +324,126 @@ mdoc_valid_post(struct mdoc *mdoc)
 	return(1);
 }
 
+static int
+check_count(struct mdoc *m, enum mdoc_type type, 
+		enum check_lvl lvl, enum check_ineq ineq, int val)
+{
+	const char	*p;
 
-static inline int
-warn_count(struct mdoc *m, const char *k, 
-		int want, const char *v, int has)
+	if (m->last->type != type)
+		return(1);
+	
+	switch (ineq) {
+	case (CHECK_LT):
+		p = "less than ";
+		if (m->last->nchild < val)
+			return(1);
+		break;
+	case (CHECK_GT):
+		p = "greater than ";
+		if (m->last->nchild > val)
+			return(1);
+		break;
+	case (CHECK_EQ):
+		p = "";
+		if (val == m->last->nchild)
+			return(1);
+		break;
+	}
+
+	if (CHECK_WARN == lvl) {
+		return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT,
+				m->last->line, m->last->pos,
+				"want %s%d children (have %d)",
+				p, val, m->last->nchild));
+	}
+
+	return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT,
+			m->last->line, m->last->pos,
+			"require %s%d children (have %d)",
+			p, val, m->last->nchild));
+}
+
+static int
+berr_ge1(POST_ARGS)
 {
 
-	return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT, 
-				m->last->line, m->last->pos, 
-				"%s %s %d (have %d)", v, k, want, has));
+	return(check_count(mdoc, MDOC_BODY, CHECK_FATAL, CHECK_GT, 0));
 }
 
+static int
+bwarn_ge1(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_BODY, CHECK_WARN, CHECK_GT, 0));
+}
 
-static inline int
-err_count(struct mdoc *m, const char *k,
-		int want, const char *v, int has)
+static int
+eerr_eq0(POST_ARGS)
 {
+	return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_EQ, 0));
+}
 
-	mdoc_vmsg(m, MANDOCERR_SYNTARGCOUNT, 
-			m->last->line, m->last->pos, 
-			"%s %s %d (have %d)", 
-			v, k, want, has);
-	return(0);
+static int
+eerr_eq1(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_EQ, 1));
 }
 
+static int
+eerr_ge1(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_GT, 0));
+}
 
-/*
- * Build these up with macros because they're basically the same check
- * for different inequalities.  Yes, this could be done with functions,
- * but this is reasonable for now.
- */
+static int
+eerr_le1(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_LT, 2));
+}
 
-#define CHECK_CHILD_DEFN(lvl, name, ineq) 			\
-static int 							\
-lvl##_child_##name(struct mdoc *mdoc, const char *p, int sz) 	\
-{ 								\
-	if (mdoc->last->nchild ineq sz)				\
-		return(1); 					\
-	return(lvl##_count(mdoc, #ineq, sz, p, mdoc->last->nchild)); \
+static int
+ewarn_eq0(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0));
 }
 
-#define CHECK_BODY_DEFN(name, lvl, func, num) 			\
-static int 							\
-b##lvl##_##name(POST_ARGS) 					\
-{ 								\
-	if (MDOC_BODY != mdoc->last->type) 			\
-		return(1); 					\
-	return(func(mdoc, "multi-line arguments", (num))); 	\
+static int
+ewarn_ge1(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0));
 }
 
-#define CHECK_ELEM_DEFN(name, lvl, func, num) 			\
-static int							\
-e##lvl##_##name(POST_ARGS) 					\
-{ 								\
-	assert(MDOC_ELEM == mdoc->last->type); 			\
-	return(func(mdoc, "line arguments", (num))); 		\
+static int
+herr_eq0(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_HEAD, CHECK_FATAL, CHECK_EQ, 0));
 }
 
-#define CHECK_HEAD_DEFN(name, lvl, func, num)			\
-static int 							\
-h##lvl##_##name(POST_ARGS) 					\
-{ 								\
-	if (MDOC_HEAD != mdoc->last->type) 			\
-		return(1); 					\
-	return(func(mdoc, "line arguments", (num)));	 	\
+static int
+herr_ge1(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_HEAD, CHECK_FATAL, CHECK_GT, 0));
 }
 
+static int
+hwarn_eq0(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0));
+}
 
-CHECK_CHILD_DEFN(warn, gt, >)			/* warn_child_gt() */
-CHECK_CHILD_DEFN(err, gt, >)			/* err_child_gt() */
-CHECK_CHILD_DEFN(warn, eq, ==)			/* warn_child_eq() */
-CHECK_CHILD_DEFN(err, eq, ==)			/* err_child_eq() */
-CHECK_CHILD_DEFN(err, lt, <)			/* err_child_lt() */
-CHECK_CHILD_DEFN(warn, lt, <)			/* warn_child_lt() */
-CHECK_BODY_DEFN(ge1, warn, warn_child_gt, 0)	/* bwarn_ge1() */
-CHECK_BODY_DEFN(ge1, err, err_child_gt, 0)	/* berr_ge1() */
-CHECK_ELEM_DEFN(ge1, warn, warn_child_gt, 0)	/* ewarn_ge1() */
-CHECK_ELEM_DEFN(eq1, err, err_child_eq, 1)	/* eerr_eq1() */
-CHECK_ELEM_DEFN(le1, err, err_child_lt, 2)	/* eerr_le1() */
-CHECK_ELEM_DEFN(eq0, err, err_child_eq, 0)	/* eerr_eq0() */
-CHECK_ELEM_DEFN(ge1, err, err_child_gt, 0)	/* eerr_ge1() */
-CHECK_HEAD_DEFN(eq0, err, err_child_eq, 0)	/* herr_eq0() */
-CHECK_HEAD_DEFN(le1, warn, warn_child_lt, 2)	/* hwarn_le1() */
-CHECK_HEAD_DEFN(ge1, err, err_child_gt, 0)	/* herr_ge1() */
-CHECK_HEAD_DEFN(eq1, warn, warn_child_eq, 1)	/* hwarn_eq1() */
-CHECK_HEAD_DEFN(eq0, warn, warn_child_eq, 0)	/* hwarn_eq0() */
+static int
+hwarn_eq1(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 1));
+}
 
+static int
+hwarn_le1(POST_ARGS)
+{
+	return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_LT, 2));
+}
 
+
 static int
 check_stdarg(PRE_ARGS)
 {
@@ -454,45 +493,42 @@ check_argv(struct mdoc *m, struct mdoc_node *n, struct
 
 
 static int
-check_text(struct mdoc *mdoc, int line, int pos, char *p)
+check_text(struct mdoc *m, int ln, int pos, char *p)
 {
 	int		 c;
+	size_t		 sz;
 
-	/* 
-	 * FIXME: we absolutely cannot let \b get through or it will
-	 * destroy some assumptions in terms of format.
-	 */
-
 	for ( ; *p; p++, pos++) {
+		sz = strcspn(p, "\t\\");
+		p += (int)sz;
+
+		if ('\0' == *p)
+			break;
+
+		pos += (int)sz;
+
 		if ('\t' == *p) {
-			if ( ! (MDOC_LITERAL & mdoc->flags))
-				if ( ! mdoc_pmsg(mdoc, line, pos, MANDOCERR_BADCHAR))
-					return(0);
-		} else if ( ! isprint((u_char)*p) && ASCII_HYPH != *p)
-			if ( ! mdoc_pmsg(mdoc, line, pos, MANDOCERR_BADCHAR))
-				return(0);
+			if (MDOC_LITERAL & m->flags)
+				continue;
+			if (mdoc_pmsg(m, ln, pos, MANDOCERR_BADTAB))
+				continue;
+			return(0);
+		}
 
-		if ('\\' != *p)
-			continue;
+		/* Check the special character. */
 
 		c = mandoc_special(p);
 		if (c) {
 			p += c - 1;
 			pos += c - 1;
-			continue;
-		}
-
-		c = mdoc_pmsg(mdoc, line, pos, MANDOCERR_BADESCAPE);
-		if ( ! (MDOC_IGN_ESCAPE & mdoc->pflags) && ! c)
-			return(c);
+		} else
+			mdoc_pmsg(m, ln, pos, MANDOCERR_BADESCAPE);
 	}
 
 	return(1);
 }
 
 
-
-
 static int
 check_parent(PRE_ARGS, enum mdoct tok, enum mdoc_type t)
 {
@@ -510,7 +546,6 @@ check_parent(PRE_ARGS, enum mdoct tok, enum mdoc_type 
 }
 
 
-
 static int
 pre_display(PRE_ARGS)
 {
@@ -625,6 +660,8 @@ pre_bl(PRE_ARGS)
 			if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV))
 				return(0);
 			break;
+		default:
+			continue;
 		}
 
 		/* Check: duplicate auxiliary arguments. */
@@ -647,8 +684,16 @@ pre_bl(PRE_ARGS)
 
 		/* Assign list type. */
 
-		if (LIST__NONE != lt && n->data.Bl->type == LIST__NONE)
+		if (LIST__NONE != lt && n->data.Bl->type == LIST__NONE) {
 			n->data.Bl->type = lt;
+			/* Set column information, too. */
+			if (LIST_column == lt) {
+				n->data.Bl->ncols = 
+					n->args->argv[i].sz;
+				n->data.Bl->cols = (const char **)
+					n->args->argv[i].value;
+			}
+		}
 
 		/* The list type should come first. */
 
@@ -855,6 +900,8 @@ pre_an(PRE_ARGS)
 		if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_ARGCOUNT))
 			return(0);
 
+	/* FIXME: this should use a different error message. */
+
 	if (MDOC_Split == n->args->argv[0].arg)
 		n->data.An.auth = AUTH_split;
 	else if (MDOC_Nosplit == n->args->argv[0].arg)
@@ -939,7 +986,7 @@ static int
 post_bf(POST_ARGS)
 {
 	struct mdoc_node *np;
-	int		  arg;
+	enum mdocargt	  arg;
 
 	/*
 	 * Unlike other data pointers, these are "housed" by the HEAD
@@ -1087,7 +1134,11 @@ post_an(POST_ARGS)
 
 	np = mdoc->last;
 	if (AUTH__NONE != np->data.An.auth && np->child)
-		return(mdoc_nmsg(mdoc, np, MANDOCERR_ARGCOUNT));
+		return(eerr_eq0(mdoc));
+	/* 
+	 * FIXME: make this ewarn and make sure that the front-ends
+	 * don't print the arguments.
+	 */
 	if (AUTH__NONE != np->data.An.auth || np->child)
 		return(1);
 	return(mdoc_nmsg(mdoc, np, MANDOCERR_NOARGS));
@@ -1132,9 +1183,6 @@ post_it(POST_ARGS)
 		if (NULL == mdoc->last->head->child)
 			if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOARGS))
 				return(0);
-		if (NULL == mdoc->last->body->child)
-			if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOBODY))
-				return(0);
 		break;
 	case (LIST_bullet):
 		/* FALLTHROUGH */
@@ -1143,24 +1191,18 @@ post_it(POST_ARGS)
 	case (LIST_enum):
 		/* FALLTHROUGH */
 	case (LIST_hyphen):
+		if (NULL == mdoc->last->body->child)
+			if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOBODY))
+				return(0);
 		/* FALLTHROUGH */
 	case (LIST_item):
 		if (mdoc->last->head->child)
 			if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_ARGSLOST))
 				return(0);
-		if (NULL == mdoc->last->body->child)
-			if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOBODY))
-				return(0);
 		break;
 	case (LIST_column):
-		cols = -1;
-		for (i = 0; i < (int)n->args->argc; i++)
-			if (MDOC_Column == n->args->argv[i].arg) {
-				cols = (int)n->args->argv[i].sz;
-				break;
-			}
+		cols = (int)n->data.Bl->ncols;
 
-		assert(-1 != cols);
 		assert(NULL == mdoc->last->head->child);
 
 		if (NULL == mdoc->last->body->child)
@@ -1193,28 +1235,21 @@ post_it(POST_ARGS)
 static int
 post_bl_head(POST_ARGS) 
 {
-	int		  i;
 	struct mdoc_node *n;
 
 	assert(mdoc->last->parent);
 	n = mdoc->last->parent;
 
 	if (LIST_column == n->data.Bl->type) {
-		for (i = 0; i < (int)n->args->argc; i++)
-			if (MDOC_Column == n->args->argv[i].arg)
-				break;
-		assert(i < (int)n->args->argc);
-
-		if (n->args->argv[i].sz && mdoc->last->nchild) {
+		if (n->data.Bl->ncols && mdoc->last->nchild) {
 			mdoc_nmsg(mdoc, n, MANDOCERR_COLUMNS);
 			return(0);
 		}
 		return(1);
 	}
 
-	if (0 == (i = mdoc->last->nchild))
-		return(1);
-	return(warn_count(mdoc, "==", 0, "line arguments", i));
+	/* FIXME: should be ERROR class. */
+	return(hwarn_eq0(mdoc));
 }
 
 
@@ -1472,5 +1507,28 @@ post_sh_head(POST_ARGS)
 		break;
 	}
 
+	return(1);
+}
+
+
+static int
+pre_pp(PRE_ARGS)
+{
+
+	if (NULL == mdoc->last)
+		return(1);
+
+	/* Don't allow prior `Lp' or `Pp'. */
+
+	if (MDOC_Pp != mdoc->last->tok && MDOC_Lp != mdoc->last->tok)
+		return(1);
+
+	if (MDOC_Bl == n->tok && n->data.Bl->comp)
+		return(1);
+	if (MDOC_Bd == n->tok && n->data.Bd->comp)
+		return(1);
+
+	mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_IGNPAR);
+	mdoc_node_delete(mdoc, mdoc->last);
 	return(1);
 }