===================================================================
RCS file: /cvs/mandoc/mdoc.c,v
retrieving revision 1.64
retrieving revision 1.68
diff -u -p -r1.64 -r1.68
--- mandoc/mdoc.c	2009/03/12 16:30:50	1.64
+++ mandoc/mdoc.c	2009/03/20 15:14:01	1.68
@@ -1,6 +1,6 @@
-/* $Id: mdoc.c,v 1.64 2009/03/12 16:30:50 kristaps Exp $ */
+/* $Id: mdoc.c,v 1.68 2009/03/20 15:14:01 kristaps Exp $ */
 /*
- * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
+ * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the
@@ -29,7 +29,7 @@
 /*
  * Main caller in the libmdoc library.  This begins the parsing routine,
  * handles allocation of data, and so forth.  Most of the "work" is done
- * in macro.c and validate.c.
+ * in macro.c, validate.c and action.c.
  */
 
 static	struct mdoc_node *mdoc_node_alloc(const struct mdoc *);
@@ -74,7 +74,8 @@ const	char *const __mdoc_macronames[MDOC_MAX] = {		 
 	"Fr",		"Ud",		"Lb",		"Ap",
 	"Lp",		"Lk",		"Mt",		"Brq",
 	/* LINTED */
-	"Bro",		"Brc",		"\%C"
+	"Bro",		"Brc",		"\%C",		"Es",
+	"En",		"Dx"
 	};
 
 const	char *const __mdoc_argnames[MDOC_ARG_MAX] = {		 
@@ -93,10 +94,17 @@ const	char * const *mdoc_macronames = __mdoc_macroname
 const	char * const *mdoc_argnames = __mdoc_argnames;
 
 
+/*
+ * Get the first (root) node of the parse tree.
+ */
 const struct mdoc_node *
 mdoc_node(const struct mdoc *mdoc)
 {
 
+	if (MDOC_HALT & mdoc->flags)
+		return(NULL);
+	if (mdoc->first)
+		assert(MDOC_ROOT == mdoc->first->type);
 	return(mdoc->first);
 }
 
@@ -105,18 +113,53 @@ const struct mdoc_meta *
 mdoc_meta(const struct mdoc *mdoc)
 {
 
+	if (MDOC_HALT & mdoc->flags)
+		return(NULL);
 	return(&mdoc->meta);
 }
 
 
+/*
+ * Free up all resources contributed by a parse:  the node tree, meta-data and
+ * so on.  Then reallocate the root node for another parse.
+ */
 void
+mdoc_reset(struct mdoc *mdoc)
+{
+
+	if (mdoc->first)
+		mdoc_node_freelist(mdoc->first);
+	if (mdoc->meta.title)
+		free(mdoc->meta.title);
+	if (mdoc->meta.os)
+		free(mdoc->meta.os);
+	if (mdoc->meta.name)
+		free(mdoc->meta.name);
+	if (mdoc->meta.arch)
+		free(mdoc->meta.arch);
+	if (mdoc->meta.vol)
+		free(mdoc->meta.vol);
+
+	bzero(&mdoc->meta, sizeof(struct mdoc_meta));
+	mdoc->flags = 0;
+	mdoc->lastnamed = mdoc->lastsec = 0;
+
+	mdoc->first = mdoc->last = 
+		xcalloc(1, sizeof(struct mdoc_node));
+	mdoc->last->type = MDOC_ROOT;
+	mdoc->next = MDOC_NEXT_CHILD;
+}
+
+
+/*
+ * Completely free up all resources.
+ */
+void
 mdoc_free(struct mdoc *mdoc)
 {
 
 	if (mdoc->first)
 		mdoc_node_freelist(mdoc->first);
-	if (mdoc->htab)
-		mdoc_tokhash_free(mdoc->htab);
 	if (mdoc->meta.title)
 		free(mdoc->meta.title);
 	if (mdoc->meta.os)
@@ -128,6 +171,9 @@ mdoc_free(struct mdoc *mdoc)
 	if (mdoc->meta.vol)
 		free(mdoc->meta.vol);
 
+	if (mdoc->htab)
+		mdoc_tokhash_free(mdoc->htab);
+
 	free(mdoc);
 }
 
@@ -143,17 +189,20 @@ mdoc_alloc(void *data, int pflags, const struct mdoc_c
 	if (cb)
 		(void)memcpy(&p->cb, cb, sizeof(struct mdoc_cb));
 
-	p->last = xcalloc(1, sizeof(struct mdoc_node));
+	p->last = p->first = 
+		xcalloc(1, sizeof(struct mdoc_node));
 	p->last->type = MDOC_ROOT;
-	p->first = p->last;
 	p->pflags = pflags;
 	p->next = MDOC_NEXT_CHILD;
 	p->htab = mdoc_tokhash_alloc();
-
 	return(p);
 }
 
 
+/*
+ * Climb back up the parse tree, validating open scopes.  Mostly calls
+ * through to macro_end in macro.c.
+ */
 int
 mdoc_endparse(struct mdoc *mdoc)
 {
@@ -290,6 +339,8 @@ mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *
 
 	if ( ! mdoc_valid_pre(mdoc, p))
 		return(0);
+	if ( ! mdoc_action_pre(mdoc, p))
+		return(0);
 
 	switch (p->type) {
 	case (MDOC_HEAD):
@@ -484,17 +535,21 @@ mdoc_node_freelist(struct mdoc_node *p)
  * control character.
  */
 static int
-parsetext(struct mdoc *mdoc, int line, char *buf)
+parsetext(struct mdoc *m, int line, char *buf)
 {
 
-	if (SEC_PROLOGUE == mdoc->lastnamed)
-		return(mdoc_perr(mdoc, line, 0,
+	if (SEC_PROLOGUE == m->lastnamed)
+		return(mdoc_perr(m, line, 0,
 			"text disallowed in prologue"));
 
-	if ( ! mdoc_word_alloc(mdoc, line, 0, buf))
+	if (0 == buf[0] && ! (MDOC_LITERAL & m->flags))
+		return(mdoc_perr(m, line, 0,
+			"blank lines only in literal context"));
+
+	if ( ! mdoc_word_alloc(m, line, 0, buf))
 		return(0);
 
-	mdoc->next = MDOC_NEXT_SIBLING;
+	m->next = MDOC_NEXT_SIBLING;
 	return(1);
 }
 
@@ -527,9 +582,9 @@ parsemacro(struct mdoc *m, int ln, char *buf)
 	if (0 == buf[1])
 		return(1);
 
-	if (isspace((unsigned char)buf[1])) {
+	if (' ' == buf[1]) {
 		i = 2;
-		while (buf[i] && isspace((unsigned char)buf[i]))
+		while (buf[i] && ' ' == buf[i])
 			i++;
 		if (0 == buf[i])
 			return(1);
@@ -545,7 +600,7 @@ parsemacro(struct mdoc *m, int ln, char *buf)
 	for (i = 1; i < 5; i++) {
 		if (0 == (mac[i - 1] = buf[i]))
 			break;
-		else if (isspace((unsigned char)buf[i]))
+		else if (' ' == buf[i])
 			break;
 	}
 
@@ -565,13 +620,19 @@ parsemacro(struct mdoc *m, int ln, char *buf)
 
 	/* The macro is sane.  Jump to the next word. */
 
-	while (buf[i] && isspace((unsigned char)buf[i]))
+	while (buf[i] && ' ' == buf[i])
 		i++;
 
 	/* Begin recursive parse sequence. */
 
 	if ( ! mdoc_macro(m, c, ln, 1, &i, buf)) 
 		goto err;
+
+	/*
+	 * If we're in literal mode, then add a newline to the end of
+	 * macro lines.  Our frontends will interpret this correctly
+	 * (it's documented in mdoc.3).
+	 */
 
 	return(1);