===================================================================
RCS file: /cvs/mandoc/Attic/mdocterm.c,v
retrieving revision 1.34
retrieving revision 1.38
diff -u -p -r1.34 -r1.38
--- mandoc/Attic/mdocterm.c	2009/03/06 14:13:47	1.34
+++ mandoc/Attic/mdocterm.c	2009/03/10 11:16:43	1.38
@@ -1,4 +1,4 @@
-/* $Id: mdocterm.c,v 1.34 2009/03/06 14:13:47 kristaps Exp $ */
+/* $Id: mdocterm.c,v 1.38 2009/03/10 11:16:43 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -16,6 +16,8 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
+#include <sys/types.h>
+
 #include <assert.h>
 #include <ctype.h>
 #include <err.h>
@@ -23,9 +25,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#ifndef __OpenBSD__
-#include <time.h>
-#endif
 
 #include "mmain.h"
 #include "term.h"
@@ -53,6 +52,7 @@ static	void		  chara(struct termp *, char);
 static	void		  stringa(struct termp *, 
 				const char *, size_t);
 static	void		  symbola(struct termp *, enum tsym);
+static	void		  sanity(const struct mdoc_node *);
 static	void		  stylea(struct termp *, enum tstyle);
 
 #ifdef __linux__
@@ -476,6 +476,10 @@ body(struct termp *p, struct termpair *ppair,
 	int		 dochild;
 	struct termpair	 pair;
 
+	/* Some quick sanity-checking. */
+
+	sanity(node);
+
 	/* Pre-processing. */
 
 	dochild = 1;
@@ -490,7 +494,7 @@ body(struct termp *p, struct termpair *ppair,
 			if ( ! (*termacts[node->tok].pre)(p, &pair, meta, node))
 				dochild = 0;
 	} else /* MDOC_TEXT == node->type */
-		word(p, node->data.text.string);
+		word(p, node->string);
 
 	/* Children. */
 
@@ -681,24 +685,34 @@ pescape(struct termp *p, const char *word, size_t *i, 
 {
 	size_t		 j;
 
-	(*i)++;
-	assert(*i < len);
+	if (++(*i) >= len) {
+		warnx("ignoring bad escape sequence");
+		return;
+	}
 
 	if ('(' == word[*i]) {
 		(*i)++;
-		assert(*i + 1 < len);
+		if (*i + 1 >= len) {
+			warnx("ignoring bad escape sequence");
+			return;
+		}
 		nescape(p, &word[*i], 2);
 		(*i)++;
 		return;
 
 	} else if ('*' == word[*i]) { 
-		/* XXX - deprecated! */
 		(*i)++;
-		assert(*i < len);
+		if (*i >= len) {
+			warnx("ignoring bad escape sequence");
+			return;
+		}
 		switch (word[*i]) {
 		case ('('):
 			(*i)++;
-			assert(*i + 1 < len);
+			if (*i + 1 >= len) {
+				warnx("ignoring bad escape sequence");
+				return;
+			}
 			nescape(p, &word[*i], 2);
 			(*i)++;
 			return;
@@ -718,7 +732,10 @@ pescape(struct termp *p, const char *word, size_t *i, 
 	for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)
 		/* Loop... */ ;
 
-	assert(word[*i]);
+	if (0 == word[*i]) {
+		warnx("ignoring bad escape sequence");
+		return;
+	}
 	nescape(p, &word[*i - j], j);
 }
 
@@ -833,3 +850,114 @@ chara(struct termp *p, char c)
 	}
 	p->buf[(p->col)++] = c;
 }
+
+
+static void
+sanity(const struct mdoc_node *n)
+{
+
+	switch (n->type) {
+	case (MDOC_TEXT):
+		if (n->child) 
+			errx(1, "regular form violated (1)");
+		if (NULL == n->parent) 
+			errx(1, "regular form violated (2)");
+		if (NULL == n->string)
+			errx(1, "regular form violated (3)");
+		switch (n->parent->type) {
+		case (MDOC_TEXT):
+			/* FALLTHROUGH */
+		case (MDOC_ROOT):
+			errx(1, "regular form violated (4)");
+			/* NOTREACHED */
+		default:
+			break;
+		}
+		break;
+	case (MDOC_ELEM):
+		if (NULL == n->parent)
+			errx(1, "regular form violated (5)");
+		switch (n->parent->type) {
+		case (MDOC_TAIL):
+			/* FALLTHROUGH */
+		case (MDOC_BODY):
+			/* FALLTHROUGH */
+		case (MDOC_HEAD):
+			break;
+		default:
+			errx(1, "regular form violated (6)");
+			/* NOTREACHED */
+		}
+		if (n->child) switch (n->child->type) {
+		case (MDOC_TEXT):
+			break;
+		default:
+			errx(1, "regular form violated (7(");
+			/* NOTREACHED */
+		}
+		break;
+	case (MDOC_HEAD):
+		/* FALLTHROUGH */
+	case (MDOC_BODY):
+		/* FALLTHROUGH */
+	case (MDOC_TAIL):
+		if (NULL == n->parent)
+			errx(1, "regular form violated (8)");
+		if (MDOC_BLOCK != n->parent->type)
+			errx(1, "regular form violated (9)");
+		if (n->child) switch (n->child->type) {
+		case (MDOC_BLOCK):
+			/* FALLTHROUGH */
+		case (MDOC_ELEM):
+			/* FALLTHROUGH */
+		case (MDOC_TEXT):
+			break;
+		default:
+			errx(1, "regular form violated (a)");
+			/* NOTREACHED */
+		}
+		break;
+	case (MDOC_BLOCK):
+		if (NULL == n->parent)
+			errx(1, "regular form violated (b)");
+		if (NULL == n->child)
+			errx(1, "regular form violated (c)");
+		switch (n->parent->type) {
+		case (MDOC_ROOT):
+			/* FALLTHROUGH */
+		case (MDOC_HEAD):
+			/* FALLTHROUGH */
+		case (MDOC_BODY):
+			/* FALLTHROUGH */
+		case (MDOC_TAIL):
+			break;
+		default:
+			errx(1, "regular form violated (d)");
+			/* NOTREACHED */
+		}
+		switch (n->child->type) {
+		case (MDOC_ROOT):
+			/* FALLTHROUGH */
+		case (MDOC_ELEM):
+			errx(1, "regular form violated (e)");
+			/* NOTREACHED */
+		default:
+			break;
+		}
+		break;
+	case (MDOC_ROOT):
+		if (n->parent)
+			errx(1, "regular form violated (f)");
+		if (NULL == n->child)
+			errx(1, "regular form violated (10)");
+		switch (n->child->type) {
+		case (MDOC_BLOCK):
+			break;
+		default:
+			errx(1, "regular form violated (11)");
+			/* NOTREACHED */
+		}
+		break;
+	}
+}
+