===================================================================
RCS file: /cvs/mandoc/mdoc.c,v
retrieving revision 1.71
retrieving revision 1.88
diff -u -p -r1.71 -r1.88
--- mandoc/mdoc.c	2009/03/23 15:20:51	1.71
+++ mandoc/mdoc.c	2009/07/06 13:04:52	1.88
@@ -1,39 +1,30 @@
-/* $Id: mdoc.c,v 1.71 2009/03/23 15:20:51 kristaps Exp $ */
+/*	$Id: mdoc.c,v 1.88 2009/07/06 13:04:52 kristaps Exp $ */
 /*
- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
+ * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
  * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
  *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #include <assert.h>
 #include <ctype.h>
-#include <err.h>
 #include <stdarg.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 #include "libmdoc.h"
 
-/*
- * 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, validate.c and action.c.
- */
-
 const	char *const __mdoc_macronames[MDOC_MAX] = {		 
-	"\\\"",		"Dd",		"Dt",		"Os",
+	"Ap",		"Dd",		"Dt",		"Os",
 	"Sh",		"Ss",		"Pp",		"D1",
 	"Dl",		"Bd",		"Ed",		"Bl",
 	"El",		"It",		"Ad",		"An",
@@ -62,12 +53,12 @@ const	char *const __mdoc_macronames[MDOC_MAX] = {		 
 	"Tn",		"Ux",		"Xc",		"Xo",
 	"Fo",		"Fc",		"Oo",		"Oc",
 	"Bk",		"Ek",		"Bt",		"Hf",
-	"Fr",		"Ud",		"Lb",		"Ap",
-	"Lp",		"Lk",		"Mt",		"Brq",
+	"Fr",		"Ud",		"Lb",		"Lp",
+	"Lk",		"Mt",		"Brq",		"Bro",
 	/* LINTED */
-	"Bro",		"Brc",		"\%C",		"Es",
+	"Brc",		"\%C",		"Es",		"En",
 	/* LINTED */
-	"En",		"Dx",		"\%Q"
+	"Dx",		"\%Q"
 	};
 
 const	char *const __mdoc_argnames[MDOC_ARG_MAX] = {		 
@@ -85,20 +76,17 @@ const	char *const __mdoc_argnames[MDOC_ARG_MAX] = {		 
 const	char * const *mdoc_macronames = __mdoc_macronames;
 const	char * const *mdoc_argnames = __mdoc_argnames;
 
-/* FIXME: have this accept line/pos/tok. */
-/* FIXME: mdoc_alloc1 and mdoc_free1 like in man.c. */
-static	struct mdoc_node *mdoc_node_alloc(const struct mdoc *);
-static	int		  mdoc_node_append(struct mdoc *, 
+static	void		  mdoc_free1(struct mdoc *);
+static	int		  mdoc_alloc1(struct mdoc *);
+static	struct mdoc_node *node_alloc(struct mdoc *, int, int, 
+				int, enum mdoc_type);
+static	int		  node_append(struct mdoc *, 
 				struct mdoc_node *);
-
 static	int		  parsetext(struct mdoc *, int, char *);
 static	int		  parsemacro(struct mdoc *, int, char *);
 static	int		  macrowarn(struct mdoc *, int, const char *);
 
 
-/*
- * Get the first (root) node of the parse tree.
- */
 const struct mdoc_node *
 mdoc_node(const struct mdoc *m)
 {
@@ -116,12 +104,10 @@ mdoc_meta(const struct mdoc *m)
 
 
 /*
- * Free up all resources contributed by a parse:  the node tree,
- * meta-data and so on.  Then reallocate the root node for another
- * parse.
+ * Frees volatile resources (parse tree, meta-data, fields).
  */
-void
-mdoc_reset(struct mdoc *mdoc)
+static void
+mdoc_free1(struct mdoc *mdoc)
 {
 
 	if (mdoc->first)
@@ -136,101 +122,112 @@ mdoc_reset(struct mdoc *mdoc)
 		free(mdoc->meta.arch);
 	if (mdoc->meta.vol)
 		free(mdoc->meta.vol);
+}
 
+
+/*
+ * Allocate all volatile resources (parse tree, meta-data, fields).
+ */
+static int
+mdoc_alloc1(struct mdoc *mdoc)
+{
+
 	bzero(&mdoc->meta, sizeof(struct mdoc_meta));
 	mdoc->flags = 0;
-	mdoc->lastnamed = mdoc->lastsec = 0;
+	mdoc->lastnamed = mdoc->lastsec = SEC_NONE;
 	mdoc->last = calloc(1, sizeof(struct mdoc_node));
 	if (NULL == mdoc->last)
-		err(1, "calloc");
+		return(0);
+
 	mdoc->first = mdoc->last;
 	mdoc->last->type = MDOC_ROOT;
 	mdoc->next = MDOC_NEXT_CHILD;
+	return(1);
 }
 
 
 /*
- * Completely free up all resources.
+ * Free up volatile resources (see mdoc_free1()) then re-initialises the
+ * data with mdoc_alloc1().  After invocation, parse data has been reset
+ * and the parser is ready for re-invocation on a new tree; however,
+ * cross-parse non-volatile data is kept intact.
  */
+int
+mdoc_reset(struct mdoc *mdoc)
+{
+
+	mdoc_free1(mdoc);
+	return(mdoc_alloc1(mdoc));
+}
+
+
+/*
+ * Completely free up all volatile and non-volatile parse resources.
+ * After invocation, the pointer is no longer usable.
+ */
 void
 mdoc_free(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);
-
+	mdoc_free1(mdoc);
 	if (mdoc->htab)
-		mdoc_tokhash_free(mdoc->htab);
-
+		mdoc_hash_free(mdoc->htab);
 	free(mdoc);
 }
 
 
+/*
+ * Allocate volatile and non-volatile parse resources.  
+ */
 struct mdoc *
 mdoc_alloc(void *data, int pflags, const struct mdoc_cb *cb)
 {
 	struct mdoc	*p;
 
 	if (NULL == (p = calloc(1, sizeof(struct mdoc))))
-		err(1, "calloc");
-
-	p->data = data;
+		return(NULL);
 	if (cb)
 		(void)memcpy(&p->cb, cb, sizeof(struct mdoc_cb));
 
-	if (NULL == (p->first = calloc(1, sizeof(struct mdoc_node))))
-		err(1, "calloc");
-	p->last = p->first;
-	p->last->type = MDOC_ROOT;
+	p->data = data;
 	p->pflags = pflags;
-	p->next = MDOC_NEXT_CHILD;
-	p->htab = mdoc_tokhash_alloc();
-	return(p);
+
+	if (NULL == (p->htab = mdoc_hash_alloc())) {
+		free(p);
+		return(NULL);
+	} else if (mdoc_alloc1(p))
+		return(p);
+
+	free(p);
+	return(NULL);
 }
 
 
 /*
  * Climb back up the parse tree, validating open scopes.  Mostly calls
- * through to macro_end in macro.c.
+ * through to macro_end() in macro.c.
  */
 int
-mdoc_endparse(struct mdoc *mdoc)
+mdoc_endparse(struct mdoc *m)
 {
 
-	if (MDOC_HALT & mdoc->flags)
+	if (MDOC_HALT & m->flags)
 		return(0);
-	if (NULL == mdoc->first)
+	else if (mdoc_macroend(m))
 		return(1);
-
-	assert(mdoc->last);
-	if ( ! macro_end(mdoc)) {
-		mdoc->flags |= MDOC_HALT;
-		return(0);
-	}
-	return(1);
+	m->flags |= MDOC_HALT;
+	return(0);
 }
 
 
 /*
  * Main parse routine.  Parses a single line -- really just hands off to
- * the macro or text parser.
+ * the macro (parsemacro()) or text parser (parsetext()).
  */
 int
 mdoc_parseln(struct mdoc *m, int ln, char *buf)
 {
 
-	/* If in error-mode, then we parse no more. */
-
 	if (MDOC_HALT & m->flags)
 		return(0);
 
@@ -239,22 +236,6 @@ mdoc_parseln(struct mdoc *m, int ln, char *buf)
 }
 
 
-void
-mdoc_vmsg(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...)
-{
-	char		  buf[256];
-	va_list		  ap;
-
-	if (NULL == mdoc->cb.mdoc_msg)
-		return;
-
-	va_start(ap, fmt);
-	(void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
-	va_end(ap);
-	(*mdoc->cb.mdoc_msg)(mdoc->data, ln, pos, buf);
-}
-
-
 int
 mdoc_verr(struct mdoc *mdoc, int ln, int pos, 
 		const char *fmt, ...)
@@ -268,13 +249,13 @@ mdoc_verr(struct mdoc *mdoc, int ln, int pos, 
 	va_start(ap, fmt);
 	(void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
 	va_end(ap);
+
 	return((*mdoc->cb.mdoc_err)(mdoc->data, ln, pos, buf));
 }
 
 
 int
-mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, 
-		enum mdoc_warn type, const char *fmt, ...)
+mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...)
 {
 	char		 buf[256];
 	va_list		 ap;
@@ -285,37 +266,219 @@ mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, 
 	va_start(ap, fmt);
 	(void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
 	va_end(ap);
-	return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, type, buf));
+
+	return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, buf));
 }
 
 
 int
+mdoc_err(struct mdoc *m, int line, int pos, int iserr, enum merr type)
+{
+	char		 *p;
+	
+	p = NULL;
+
+	switch (type) {
+	case (ENOCALL):
+		p = "not callable";
+		break;
+	case (EPROLBODY):
+		p = "macro disallowed in document body";
+		break;
+	case (EBODYPROL):
+		p = "macro disallowed in document prologue";
+		break;
+	case (EMALLOC):
+		p = "memory exhausted";
+		break;
+	case (ETEXTPROL):
+		p = "text disallowed in document prologue";
+		break;
+	case (ENOBLANK):
+		p = "blank lines disallowed in non-literal contexts";
+		break;
+	case (ESPACE):
+		p = "whitespace disallowed after delimiter";
+		break;
+	case (ETOOLONG):
+		p = "text argument too long";
+		break;
+	case (EESCAPE):
+		p = "invalid escape sequence";
+		break;
+	case (EPRINT):
+		p = "invalid character";
+		break;
+	case (ENESTDISP):
+		p = "displays may not be nested";
+		break;
+	case (EBOOL):
+		p = "expected boolean value";
+		break;
+	case (EARGREP):
+		p = "argument repeated";
+		break;
+	case (EMULTIDISP):
+		p = "multiple display types specified";
+		break;
+	case (EMULTILIST):
+		p = "multiple list types specified";
+		break;
+	case (ELISTTYPE):
+		p = "missing list type";
+		break;
+	case (EDISPTYPE):
+		p = "missing display type";
+		break;
+	case (ESECNAME):
+		p = "the NAME section must come first";
+		break;
+	case (ELINE):
+		p = "expected line arguments";
+		break;
+	case (ENOPROLOGUE):
+		p = "document has no prologue";
+		break;
+	case (ENODAT):
+		p = "document has no data";
+		break;
+	case (ECOLMIS):
+		p = "column syntax style mismatch";
+		break;
+	case (EATT):
+		p = "expected valid AT&T symbol";
+		break;
+	case (ENAME):
+		p = "default name not yet set";
+		break;
+	case (ENOWIDTH):
+		p = "superfluous width argument";
+		break;
+	case (EMISSWIDTH):
+		p = "missing width argument";
+		break;
+	case (EWRONGMSEC):
+		p = "document section in wrong manual section";
+		break;
+	case (ESECOOO):
+		p = "document section out of conventional order";
+		break;
+	case (ESECREP):
+		p = "document section repeated";
+		break;
+	case (EBADSTAND):
+		p = "unknown standard";
+		break;
+	case (ENAMESECINC):
+		p = "NAME section contents incomplete/badly-ordered";
+		break;
+	case (ENOMULTILINE):
+		p = "suggested no multi-line arguments";
+		break;
+	case (EMULTILINE):
+		p = "suggested multi-line arguments";
+		break;
+	case (ENOLINE):
+		p = "suggested no line arguments";
+		break;
+	case (EPROLOOO):
+		p = "prologue macros out-of-order";
+		break;
+	case (EPROLREP):
+		p = "prologue macros repeated";
+		break;
+	case (EARGVAL):
+		p = "argument value suggested";
+		break;
+	case (EFONT):
+		p = "invalid font mode";
+		break;
+	case (EBADMSEC):
+		p = "inappropriate manual section";
+		break;
+	case (EBADSEC):
+		p = "inappropriate document section";
+		break;
+	case (EQUOTTERM):
+		p = "unterminated quoted parameter";
+		break;
+	case (EQUOTPARM):
+		p = "unexpected quoted parameter";
+		break;
+	case (EARGVPARM):
+		p = "argument-like parameter";
+		break;
+	case (ECOLEMPTY):
+		p = "last list column is empty";
+		break;
+	case (ETAILWS):
+		p = "trailing whitespace";
+		break;
+	case (ENUMFMT):
+		p = "bad number format";
+		break;
+	case (EUTSNAME):
+		p = "utsname";
+		break;
+	case (EBADDATE):
+		p = "malformed date syntax";
+		break;
+	case (EOPEN):
+		p = "explicit scope still open on exit";
+		break;
+	case (EQUOT):
+		p = "unterminated quotation";
+		break;
+	case (ENOCTX):
+		p = "closure has no prior context";
+		break;
+	case (ENOPARMS):
+		p = "unexpect line arguments";
+		break;
+	case (EIGNE):
+		p = "ignoring empty element";
+		break;
+	case (EIMPBRK):
+		p = "crufty end-of-line scope violation";
+		break;
+	case (EMACPARM):
+		p = "macro-like parameter";
+		break;
+	case (EOBS):
+		p = "macro marked obsolete";
+		break;
+	}
+
+	assert(p);
+
+	if (iserr)
+		return(mdoc_verr(m, line, pos, p));
+
+	return(mdoc_vwarn(m, line, pos, p));
+}
+
+
+int
 mdoc_macro(struct mdoc *m, int tok, 
 		int ln, int pp, int *pos, char *buf)
 {
 
-	/* FIXME - these should happen during validation. */
-
 	if (MDOC_PROLOGUE & mdoc_macros[tok].flags && 
-			SEC_PROLOGUE != m->lastnamed)
-		return(mdoc_perr(m, ln, pp, 
-				"disallowed in document body"));
-
+			MDOC_PBODY & m->flags)
+		return(mdoc_perr(m, ln, pp, EPROLBODY));
 	if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) && 
-			SEC_PROLOGUE == m->lastnamed)
-		return(mdoc_perr(m, ln, pp, 
-				"disallowed in prologue"));
+			! (MDOC_PBODY & m->flags))
+		return(mdoc_perr(m, ln, pp, EBODYPROL));
 
 	if (1 != pp && ! (MDOC_CALLABLE & mdoc_macros[tok].flags))
-		return(mdoc_perr(m, ln, pp, "%s not callable",
-					mdoc_macronames[tok]));
+		return(mdoc_perr(m, ln, pp, ENOCALL));
 
 	return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf));
 }
 
 
 static int
-mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *p)
+node_append(struct mdoc *mdoc, struct mdoc_node *p)
 {
 
 	assert(mdoc->last);
@@ -337,6 +500,8 @@ mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *
 		/* NOTREACHED */
 	}
 
+	p->parent->nchild++;
+
 	if ( ! mdoc_valid_pre(mdoc, p))
 		return(0);
 	if ( ! mdoc_action_pre(mdoc, p))
@@ -377,13 +542,22 @@ mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *
 
 
 static struct mdoc_node *
-mdoc_node_alloc(const struct mdoc *mdoc)
+node_alloc(struct mdoc *mdoc, int line, 
+		int pos, int tok, enum mdoc_type type)
 {
 	struct mdoc_node *p;
 
-	if (NULL == (p = calloc(1, sizeof(struct mdoc_node))))
-		err(1, "calloc");
+	if (NULL == (p = calloc(1, sizeof(struct mdoc_node)))) {
+		(void)mdoc_nerr(mdoc, mdoc->last, EMALLOC);
+		return(NULL);
+	}
+
 	p->sec = mdoc->lastsec;
+	p->line = line;
+	p->pos = pos;
+	p->tok = tok;
+	if (MDOC_TEXT != (p->type = type))
+		assert(p->tok >= 0);
 
 	return(p);
 }
@@ -394,17 +568,10 @@ mdoc_tail_alloc(struct mdoc *mdoc, int line, int pos, 
 {
 	struct mdoc_node *p;
 
-	assert(mdoc->first);
-	assert(mdoc->last);
-
-	p = mdoc_node_alloc(mdoc);
-
-	p->line = line;
-	p->pos = pos;
-	p->type = MDOC_TAIL;
-	p->tok = tok;
-
-	return(mdoc_node_append(mdoc, p));
+	p = node_alloc(mdoc, line, pos, tok, MDOC_TAIL);
+	if (NULL == p)
+		return(0);
+	return(node_append(mdoc, p));
 }
 
 
@@ -416,14 +583,10 @@ mdoc_head_alloc(struct mdoc *mdoc, int line, int pos, 
 	assert(mdoc->first);
 	assert(mdoc->last);
 
-	p = mdoc_node_alloc(mdoc);
-
-	p->line = line;
-	p->pos = pos;
-	p->type = MDOC_HEAD;
-	p->tok = tok;
-
-	return(mdoc_node_append(mdoc, p));
+	p = node_alloc(mdoc, line, pos, tok, MDOC_HEAD);
+	if (NULL == p)
+		return(0);
+	return(node_append(mdoc, p));
 }
 
 
@@ -432,17 +595,10 @@ mdoc_body_alloc(struct mdoc *mdoc, int line, int pos, 
 {
 	struct mdoc_node *p;
 
-	assert(mdoc->first);
-	assert(mdoc->last);
-
-	p = mdoc_node_alloc(mdoc);
-
-	p->line = line;
-	p->pos = pos;
-	p->type = MDOC_BODY;
-	p->tok = tok;
-
-	return(mdoc_node_append(mdoc, p));
+	p = node_alloc(mdoc, line, pos, tok, MDOC_BODY);
+	if (NULL == p)
+		return(0);
+	return(node_append(mdoc, p));
 }
 
 
@@ -452,18 +608,13 @@ mdoc_block_alloc(struct mdoc *mdoc, int line, int pos,
 {
 	struct mdoc_node *p;
 
-	p = mdoc_node_alloc(mdoc);
-
-	p->pos = pos;
-	p->line = line;
-	p->type = MDOC_BLOCK;
-	p->tok = tok;
+	p = node_alloc(mdoc, line, pos, tok, MDOC_BLOCK);
+	if (NULL == p)
+		return(0);
 	p->args = args;
-
-	if (args)
+	if (p->args)
 		(args->refcnt)++;
-
-	return(mdoc_node_append(mdoc, p));
+	return(node_append(mdoc, p));
 }
 
 
@@ -473,18 +624,13 @@ mdoc_elem_alloc(struct mdoc *mdoc, int line, int pos, 
 {
 	struct mdoc_node *p;
 
-	p = mdoc_node_alloc(mdoc);
-
-	p->line = line;
-	p->pos = pos;
-	p->type = MDOC_ELEM;
-	p->tok = tok;
+	p = node_alloc(mdoc, line, pos, tok, MDOC_ELEM);
+	if (NULL == p)
+		return(0);
 	p->args = args;
-
-	if (args)
+	if (p->args)
 		(args->refcnt)++;
-
-	return(mdoc_node_append(mdoc, p));
+	return(node_append(mdoc, p));
 }
 
 
@@ -494,15 +640,15 @@ mdoc_word_alloc(struct mdoc *mdoc, 
 {
 	struct mdoc_node *p;
 
-	p = mdoc_node_alloc(mdoc);
+	p = node_alloc(mdoc, line, pos, -1, MDOC_TEXT);
+	if (NULL == p)
+		return(0);
+	if (NULL == (p->string = strdup(word))) {
+		(void)mdoc_nerr(mdoc, mdoc->last, EMALLOC);
+		return(0);
+	}
 
-	p->line = line;
-	p->pos = pos;
-	p->type = MDOC_TEXT;
-	if (NULL == (p->string = strdup(word)))
-		err(1, "strdup");
-
-	return(mdoc_node_append(mdoc, p));
+	return(node_append(mdoc, p));
 }
 
 
@@ -510,6 +656,8 @@ void
 mdoc_node_free(struct mdoc_node *p)
 {
 
+	if (p->parent)
+		p->parent->nchild--;
 	if (p->string)
 		free(p->string);
 	if (p->args)
@@ -527,6 +675,7 @@ mdoc_node_freelist(struct mdoc_node *p)
 	if (p->next)
 		mdoc_node_freelist(p->next);
 
+	assert(0 == p->nchild);
 	mdoc_node_free(p);
 }
 
@@ -539,13 +688,11 @@ static int
 parsetext(struct mdoc *m, int line, char *buf)
 {
 
-	if (SEC_PROLOGUE == m->lastnamed)
-		return(mdoc_perr(m, line, 0,
-			"text disallowed in prologue"));
+	if (SEC_NONE == m->lastnamed)
+		return(mdoc_perr(m, line, 0, ETEXTPROL));
 
 	if (0 == buf[0] && ! (MDOC_LITERAL & m->flags))
-		return(mdoc_perr(m, line, 0,
-			"blank lines only in literal context"));
+		return(mdoc_perr(m, line, 0, ENOBLANK));
 
 	if ( ! mdoc_word_alloc(m, line, 0, buf))
 		return(0);
@@ -559,15 +706,14 @@ static int
 macrowarn(struct mdoc *m, int ln, const char *buf)
 {
 	if ( ! (MDOC_IGN_MACRO & m->pflags))
-		return(mdoc_perr(m, ln, 1, "unknown macro: %s%s", 
+		return(mdoc_verr(m, ln, 1, 
+				"unknown macro: %s%s", 
 				buf, strlen(buf) > 3 ? "..." : ""));
-	return(mdoc_pwarn(m, ln, 1, WARN_SYNTAX,
-				"unknown macro: %s%s",
+	return(mdoc_vwarn(m, ln, 1, "unknown macro: %s%s",
 				buf, strlen(buf) > 3 ? "..." : ""));
 }
 
 
-
 /*
  * Parse a macro line, that is, a line beginning with the control
  * character.
@@ -578,7 +724,7 @@ parsemacro(struct mdoc *m, int ln, char *buf)
 	int		  i, c;
 	char		  mac[5];
 
-	/* Comments and empties are quickly ignored. */
+	/* Empty lines are ignored. */
 
 	if (0 == buf[1])
 		return(1);
@@ -589,13 +735,9 @@ parsemacro(struct mdoc *m, int ln, char *buf)
 			i++;
 		if (0 == buf[i])
 			return(1);
-		return(mdoc_perr(m, ln, 1, "invalid syntax"));
+		return(mdoc_perr(m, ln, 1, ESPACE));
 	}
 
-	if (buf[1] && '\\' == buf[1])
-		if (buf[2] && '\"' == buf[2])
-			return(1);
-
 	/* Copy the first word into a nil-terminated buffer. */
 
 	for (i = 1; i < 5; i++) {
@@ -613,7 +755,7 @@ parsemacro(struct mdoc *m, int ln, char *buf)
 		return(1);
 	} 
 	
-	if (MDOC_MAX == (c = mdoc_tokhash_find(m->htab, mac))) {
+	if (MDOC_MAX == (c = mdoc_hash_find(m->htab, mac))) {
 		if ( ! macrowarn(m, ln, mac))
 			goto err;
 		return(1);