===================================================================
RCS file: /cvs/mandoc/man.c,v
retrieving revision 1.53
retrieving revision 1.54
diff -u -p -r1.53 -r1.54
--- mandoc/man.c	2010/03/23 21:50:43	1.53
+++ mandoc/man.c	2010/03/24 20:10:53	1.54
@@ -1,4 +1,4 @@
-/*	$Id: man.c,v 1.53 2010/03/23 21:50:43 kristaps Exp $ */
+/*	$Id: man.c,v 1.54 2010/03/24 20:10:53 kristaps Exp $ */
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -49,7 +49,8 @@ const	char *const __man_merrnames[WERRMAX] = {		 
 	"scope open on exit", /* WEXITSCOPE */
 	"no scope context", /* WNOSCOPE */
 	"literal context already open", /* WOLITERAL */
-	"no literal context open" /* WNLITERAL */
+	"no literal context open", /* WNLITERAL */
+	"invalid nesting of roff declarations", /* WROFFNEST */
 };
 
 const	char *const __man_macronames[MAN_MAX] = {		 
@@ -61,7 +62,9 @@ const	char *const __man_macronames[MAN_MAX] = {		 
 	"RI",		"na",		"i",		"sp",
 	"nf",		"fi",		"r",		"RE",
 	"RS",		"DT",		"UC",		"PD",
-	"Sp",		"Vb",		"Ve",
+	"Sp",		"Vb",		"Ve",		"de",
+	"dei",		"am",		"ami",		"ig",
+	".",
 	};
 
 const	char * const *man_macronames = __man_macronames;
@@ -70,6 +73,9 @@ static	struct man_node	*man_node_alloc(int, int, 
 				enum man_type, enum mant);
 static	int		 man_node_append(struct man *, 
 				struct man_node *);
+static	void		 man_node_free(struct man_node *);
+static	void		 man_node_unlink(struct man *, 
+				struct man_node *);
 static	int		 man_ptext(struct man *, int, char *);
 static	int		 man_pmacro(struct man *, int, char *);
 static	void		 man_free1(struct man *);
@@ -160,7 +166,7 @@ man_free1(struct man *man)
 {
 
 	if (man->first)
-		man_node_freelist(man->first);
+		man_node_delete(man, man->first);
 	if (man->meta.title)
 		free(man->meta.title);
 	if (man->meta.source)
@@ -179,6 +185,7 @@ man_alloc1(struct man *m)
 	m->last = mandoc_calloc(1, sizeof(struct man_node));
 	m->first = m->last;
 	m->last->type = MAN_ROOT;
+	m->last->tok = MAN_MAX;
 	m->next = MAN_NEXT_CHILD;
 }
 
@@ -206,6 +213,7 @@ man_node_append(struct man *man, struct man_node *p)
 		/* NOTREACHED */
 	}
 	
+	assert(p->parent);
 	p->parent->nchild++;
 
 	if ( ! man_valid_pre(man, p))
@@ -336,30 +344,29 @@ man_word_alloc(struct man *m, int line, int pos, const
 }
 
 
-void
+/*
+ * Free all of the resources held by a node.  This does NOT unlink a
+ * node from its context; for that, see man_node_unlink().
+ */
+static void
 man_node_free(struct man_node *p)
 {
 
 	if (p->string)
 		free(p->string);
-	if (p->parent)
-		p->parent->nchild--;
 	free(p);
 }
 
 
 void
-man_node_freelist(struct man_node *p)
+man_node_delete(struct man *m, struct man_node *p)
 {
-	struct man_node	*n;
 
-	if (p->child)
-		man_node_freelist(p->child);
-	assert(0 == p->nchild);
-	n = p->next;
+	while (p->child)
+		man_node_delete(m, p->child);
+
+	man_node_unlink(m, p);
 	man_node_free(p);
-	if (n)
-		man_node_freelist(n);
 }
 
 
@@ -568,8 +575,7 @@ man_pmacro(struct man *m, int ln, char *buf)
 		if ( ! man_nwarn(m, n, WLNSCOPE))
 			return(0);
 
-		man_node_unlink(m, n);
-		man_node_free(n);
+		man_node_delete(m, n);
 		m->flags &= ~MAN_ELINE;
 	}
 
@@ -584,6 +590,9 @@ out:
 	/* 
 	 * We weren't in a block-line scope when entering the
 	 * above-parsed macro, so return.
+	 *
+	 * FIXME: this prohibits the nesting of blocks (e.g., `de' and
+	 * family) within BLINE or ELINE systems.  This is annoying.
 	 */
 
 	if ( ! (MAN_BLINE & fl)) {
@@ -672,26 +681,43 @@ man_err(struct man *m, int line, int pos, int iserr, e
 }
 
 
-void
+/*
+ * Unlink a node from its context.  If "m" is provided, the last parse
+ * point will also be adjusted accordingly.
+ */
+static void
 man_node_unlink(struct man *m, struct man_node *n)
 {
 
-	if (n->prev) {
+	/* Adjust siblings. */
+
+	if (n->prev)
 		n->prev->next = n->next;
-		if (m->last == n) {
-			assert(NULL == n->next);
+	if (n->next)
+		n->next->prev = n->prev;
+
+	/* Adjust parent. */
+
+	if (n->parent) {
+		n->parent->nchild--;
+		if (n->parent->child == n)
+			n->parent->child = n->prev ? n->prev : n->next;
+	}
+
+	/* Adjust parse point, if applicable. */
+
+	if (m && m->last == n) {
+		/*XXX: this can occur when bailing from validation. */
+		/*assert(NULL == n->next);*/
+		if (n->prev) {
 			m->last = n->prev;
 			m->next = MAN_NEXT_SIBLING;
-		}
-	} else {
-		n->parent->child = n->next;
-		if (m->last == n) {
-			assert(NULL == n->next);
+		} else {
 			m->last = n->parent;
 			m->next = MAN_NEXT_CHILD;
 		}
 	}
 
-	if (n->next)
-		n->next->prev = n->prev;
+	if (m && m->first == n)
+		m->first = NULL;
 }