===================================================================
RCS file: /cvs/mandoc/Attic/mdocterm.c,v
retrieving revision 1.44
retrieving revision 1.49
diff -u -p -r1.44 -r1.49
--- mandoc/Attic/mdocterm.c	2009/03/15 07:18:10	1.44
+++ mandoc/Attic/mdocterm.c	2009/03/19 11:49:00	1.49
@@ -1,6 +1,6 @@
-/* $Id: mdocterm.c,v 1.44 2009/03/15 07:18:10 kristaps Exp $ */
+/* $Id: mdocterm.c,v 1.49 2009/03/19 11:49:00 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
@@ -17,248 +17,325 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 #include <sys/types.h>
+#include <sys/stat.h>
 
 #include <assert.h>
-#include <ctype.h>
 #include <err.h>
+#include <fcntl.h>
 #include <getopt.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
-#include "mmain.h"
 #include "term.h"
 
-struct	nroffopt {
-	int		  fl_h;
-	int		  fl_i;
-	char		 *arg_m;
-	char		 *arg_n;
-	char		 *arg_o;
-	char		 *arg_r;
-	char		 *arg_T;
-	struct termp	 *termp; /* Ephemeral. */
-};
+#define	WARN_WALL	  0x03		/* All-warnings mask. */
+#define	WARN_WCOMPAT	 (1 << 0)	/* Compatibility warnings. */
+#define	WARN_WSYNTAX	 (1 << 1)	/* Syntax warnings. */
+#define	WARN_WERR	 (1 << 2)	/* Warnings->errors. */
 
-struct	termseq {
-	const char	 *enc;
-	int		  sym;
+enum	termt {
+	TERMT_ASCII,
+	TERMT_LINT,
+	TERMT_TREE
 };
 
-dead_pre void		  punt(struct nroffopt *, char *) dead_post;
-static	int		  option(void *, int, char *);
-static	int		  optsopt(struct termp *, char *);
-static	void		  body(struct termp *,
-				struct termpair *,
+extern	char		 *__progname;
+
+__dead	static void	  version(void);
+__dead	static void	  usage(void);
+#if 0
+__dead	static void	  punt(struct cmdargs *, char **);
+#endif
+static	int		  foptions(int *, char *);
+static	int		  toptions(enum termt *, char *);
+static	int		  woptions(int *, char *);
+static	int		  merr(void *, int, int, const char *);
+static	int		  mwarn(void *, int, int, 
+				enum mdoc_warn, const char *);
+static	void		  body(struct termp *, struct termpair *,
 				const struct mdoc_meta *,
 				const struct mdoc_node *);
 static	void		  header(struct termp *,
 				const struct mdoc_meta *);
 static	void		  footer(struct termp *,
 				const struct mdoc_meta *);
-
-static	void		  pword(struct termp *, const char *, size_t);
-static	void		  pescape(struct termp *, const char *, 
-				size_t *, size_t);
+static	int		  file(char **, size_t *, char **, size_t *, 
+				const char *, struct mdoc *);
+static	int		  fdesc(char **, size_t *, char **, size_t *, 
+				const char *, int, struct mdoc *);
+static	void		  pword(struct termp *, const char *, int);
+static	void		  pescape(struct termp *, 
+				const char *, int *, int);
 static	void		  nescape(struct termp *,
 				const char *, size_t);
 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 *);
 
-#ifdef __linux__
-extern	size_t		  strlcat(char *, const char *, size_t);
-extern	size_t		  strlcpy(char *, const char *, size_t);
-#endif
 
-static	struct termseq	  termenc1[] = {
-	{ "\\",		  TERMSYM_SLASH },
-	{ "\'",		  TERMSYM_RSQUOTE },
-	{ "`",		  TERMSYM_LSQUOTE },
-	{ "-",		  TERMSYM_HYPHEN },
-	{ " ",		  TERMSYM_SPACE },
-	{ ".",		  TERMSYM_PERIOD },
-	{ "&",		  TERMSYM_BREAK },
-	{ "e",		  TERMSYM_SLASH },
-	{ "q",		  TERMSYM_DQUOTE },
-	{ "|",		  TERMSYM_BREAK },
-	{ NULL,		  0 }
-};
+int
+main(int argc, char *argv[])
+{
+	struct termp	 termp;
+	int		 c, fflags, wflags;
+	struct mdoc_cb	 cb;
+	struct mdoc	*mdoc;
+	char		*buf, *line;
+	size_t		 bufsz, linesz;
+	enum termt	 termt;
 
-static	struct termseq	  termenc2[] = {
-	{ "rC", 	  TERMSYM_RBRACE },
-	{ "lC", 	  TERMSYM_LBRACE },
-	{ "rB", 	  TERMSYM_RBRACK },
-	{ "lB", 	  TERMSYM_LBRACK },
-	{ "ra", 	  TERMSYM_RANGLE },
-	{ "la", 	  TERMSYM_LANGLE },
-	{ "Lq", 	  TERMSYM_LDQUOTE },
-	{ "lq", 	  TERMSYM_LDQUOTE },
-	{ "Rq", 	  TERMSYM_RDQUOTE },
-	{ "rq", 	  TERMSYM_RDQUOTE },
-	{ "oq", 	  TERMSYM_LSQUOTE },
-	{ "aq", 	  TERMSYM_RSQUOTE },
+	bzero(&termp, sizeof(struct termp));
+	bzero(&cb, sizeof(struct mdoc_cb));
 
-	{ "<-", 	  TERMSYM_LARROW },
-	{ "->", 	  TERMSYM_RARROW },
-	{ "ua", 	  TERMSYM_UARROW },
-	{ "da", 	  TERMSYM_DARROW },
+	termt = TERMT_ASCII;
+	fflags = wflags = 0;
 
-	{ "bu", 	  TERMSYM_BULLET },
-	{ "Ba", 	  TERMSYM_BAR },
-	{ "ba", 	  TERMSYM_BAR },
-	{ "co", 	  TERMSYM_COPY },
-	{ "Am", 	  TERMSYM_AMP },
+	/* LINTED */
+	while (-1 != (c = getopt(argc, argv, "f:VW:T:")))
+		switch (c) {
+		case ('f'):
+			if ( ! foptions(&fflags, optarg))
+				return(0);
+			break;
+		case ('T'):
+			if ( ! toptions(&termt, optarg))
+				return(0);
+			break;
+		case ('W'):
+			if ( ! woptions(&wflags, optarg))
+				return(0);
+			break;
+		case ('V'):
+			version();
+			/* NOTREACHED */
+		default:
+			usage();
+			/* NOTREACHED */
+		}
 
-	{ "Le", 	  TERMSYM_LE },
-	{ "<=", 	  TERMSYM_LE },
-	{ "Ge", 	  TERMSYM_GE },
-	{ ">=", 	  TERMSYM_GE },
-	{ "==", 	  TERMSYM_EQ },
-	{ "Ne", 	  TERMSYM_NEQ },
-	{ "!=", 	  TERMSYM_NEQ },
-	{ "Pm", 	  TERMSYM_PLUSMINUS },
-	{ "+-", 	  TERMSYM_PLUSMINUS },
-	{ "If", 	  TERMSYM_INF2 },
-	{ "if", 	  TERMSYM_INF },
-	{ "Na", 	  TERMSYM_NAN },
-	{ "na", 	  TERMSYM_NAN },
-	{ "**", 	  TERMSYM_ASTERISK },
-	{ "Gt", 	  TERMSYM_GT },
-	{ "Lt", 	  TERMSYM_LT },
+	argc -= optind;
+	argv += optind;
 
-	{ "aa", 	  TERMSYM_ACUTE },
-	{ "ga", 	  TERMSYM_GRAVE },
+	termp.maxrmargin = 78;			/* FIXME */
 
-	{ "en", 	  TERMSYM_EN },
-	{ "em", 	  TERMSYM_EM },
+	cb.mdoc_err = merr;
+	cb.mdoc_warn = mwarn;
 
-	{ "Pi", 	  TERMSYM_PI },
-	{ NULL,		  0 }
-};
+	/* Line and block buffers persist between parses. */
 
-/* FIXME: abstract to dynamically-compiled table. */
-static	struct termsym	  termsym_ascii[TERMSYM_MAX] = {
-	{ "]", 1 },		/* TERMSYM_RBRACK */
-	{ "[", 1 },		/* TERMSYM_LBRACK */
-	{ "<-", 2 },		/* TERMSYM_LARROW */
-	{ "->", 2 },		/* TERMSYM_RARROW */
-	{ "^", 1 },		/* TERMSYM_UARROW */
-	{ "v", 1 },		/* TERMSYM_DARROW */
-	{ "`", 1 },		/* TERMSYM_LSQUOTE */
-	{ "\'", 1 },		/* TERMSYM_RSQUOTE */
-	{ "\'", 1 },		/* TERMSYM_SQUOTE */
-	{ "``", 2 },		/* TERMSYM_LDQUOTE */
-	{ "\'\'", 2 },		/* TERMSYM_RDQUOTE */
-	{ "\"", 1 },		/* TERMSYM_DQUOTE */
-	{ "<", 1 },		/* TERMSYM_LT */
-	{ ">", 1 },		/* TERMSYM_GT */
-	{ "<=", 2 },		/* TERMSYM_LE */
-	{ ">=", 2 },		/* TERMSYM_GE */
-	{ "==", 2 },		/* TERMSYM_EQ */
-	{ "!=", 2 },		/* TERMSYM_NEQ */
-	{ "\'", 1 },		/* TERMSYM_ACUTE */
-	{ "`", 1 },		/* TERMSYM_GRAVE */
-	{ "pi", 2 },		/* TERMSYM_PI */
-	{ "+=", 2 },		/* TERMSYM_PLUSMINUS */
-	{ "oo", 2 },		/* TERMSYM_INF */
-	{ "infinity", 8 },	/* TERMSYM_INF2 */
-	{ "NaN", 3 },		/* TERMSYM_NAN */
-	{ "|", 1 },		/* TERMSYM_BAR */
-	{ "o", 1 },		/* TERMSYM_BULLET */
-	{ "&", 1 },		/* TERMSYM_AMP */
-	{ "--", 2 },		/* TERMSYM_EM */
-	{ "-", 1 },		/* TERMSYM_EN */
-	{ "(C)", 3 },		/* TERMSYM_COPY */
-	{ "*", 1 },		/* TERMSYM_ASTERISK */
-	{ "\\", 1 },		/* TERMSYM_SLASH */
-	{ "-", 1 },		/* TERMSYM_HYPHEN */
-	{ " ", 1 },		/* TERMSYM_SPACE */
-	{ ".", 1 },		/* TERMSYM_PERIOD */
-	{ "", 0 },		/* TERMSYM_BREAK */
-	{ "<", 1 },		/* TERMSYM_LANGLE */
-	{ ">", 1 },		/* TERMSYM_RANGLE */
-	{ "{", 1 },		/* TERMSYM_LBRACE */
-	{ "}", 1 },		/* TERMSYM_RBRACE */
-};
+	buf = line = NULL;
+	bufsz = linesz = 0;
 
-int
-main(int argc, char *argv[])
+	/* Overall mdoc persists between parses. */
+
+	mdoc = mdoc_alloc(&wflags, fflags, &cb);
+
+	while (*argv) {
+		if ( ! file(&line, &linesz, &buf, &bufsz, *argv, mdoc))
+			break;
+
+		switch (termt) {
+		case (TERMT_ASCII):
+			if (NULL == termp.symtab)
+				termp.symtab = ascii2htab();
+			header(&termp, mdoc_meta(mdoc));
+			body(&termp, NULL, mdoc_meta(mdoc), 
+					mdoc_node(mdoc));
+			footer(&termp, mdoc_meta(mdoc));
+			break;
+		default:
+			break;
+		}
+
+		mdoc_reset(mdoc);
+		argv++;
+	}
+
+	if (buf)
+		free(buf);
+	if (line)
+		free(line);
+	if (termp.buf)
+		free(termp.buf);
+	if (termp.symtab)
+		asciifree(termp.symtab);
+
+	mdoc_free(mdoc);
+
+	return(0);
+}
+
+
+__dead static void
+version(void)
 {
-	struct mmain	  *p;
-	const struct mdoc *mdoc;
-	struct nroffopt	   nroff;
-	struct termp	   termp;
-	int		   c;
-	char		  *in;
 
-	(void)memset(&termp, 0, sizeof(struct termp));
-	(void)memset(&nroff, 0, sizeof(struct nroffopt));
+	(void)printf("%s %s\n", __progname, VERSION);
+	exit(0);
+	/* NOTREACHED */
+}
 
-	termp.maxrmargin = termp.rmargin = 78; /* FIXME */
-	termp.maxcols = 1024; /* FIXME */
-	termp.offset = termp.col = 0;
-	termp.flags = TERMP_NOSPACE;
-	termp.symtab = termsym_ascii;
-	termp.enc = TERMENC_NROFF;
 
-	nroff.termp = &termp;
+__dead static void
+usage(void)
+{
 
-	p = mmain_alloc();
+	(void)fprintf(stderr, "usage: %s\n", __progname);
+	exit(1);
+	/* NOTREACHED */
+}
 
-	c = mmain_getopt(p, argc, argv, "[-Ooption...]", 
-			"[infile]", "him:n:o:r:T:O:", &nroff, option);
 
-	/* FIXME: this needs to accept multiple outputs. */
-	argv += c;
-	if ((argc -= c) > 0)
-		in = *argv++;
-	else
-		in = "-";
+static int
+file(char **ln, size_t *lnsz, char **buf, size_t *bufsz, 
+		const char *file, struct mdoc *mdoc)
+{
+	int		 fd, c;
 
-	mmain_prepare(p, in);
+	if (-1 == (fd = open(file, O_RDONLY, 0))) {
+		warn("%s", file);
+		return(0);
+	}
 
-	if (NULL == (mdoc = mmain_process(p))) {
-		if (TERMP_NOPUNT & termp.iflags)
-			mmain_exit(p, 1);
-		mmain_free(p);
-		punt(&nroff, in);
-		/* NOTREACHED */
+	c = fdesc(ln, lnsz, buf, bufsz, file, fd, mdoc);
+
+	if (-1 == close(fd))
+		warn("%s", file);
+
+	return(c);
+}
+
+
+static int
+fdesc(char **lnp, size_t *lnsz, char **bufp, size_t *bufsz, 
+		const char *f, int fd, struct mdoc *mdoc)
+{
+	size_t		 sz;
+	ssize_t		 ssz;
+	struct stat	 st;
+	int		 j, i, pos, lnn;
+	char		*ln, *buf;
+
+	buf = *bufp;
+	ln = *lnp;
+
+	/*
+	 * Two buffers: ln and buf.  buf is the input buffer, optimised
+	 * for each file's block size.  ln is a line buffer.  Both
+	 * growable, hence passed in by ptr-ptr.
+	 */
+
+	if (-1 == fstat(fd, &st)) {
+		warnx("%s", f);
+		sz = BUFSIZ;
+	} else 
+		sz = (unsigned)BUFSIZ > st.st_blksize ?
+			(size_t)BUFSIZ : st.st_blksize;
+
+	if (sz > *bufsz) {
+		if (NULL == (buf = realloc(buf, sz)))
+			err(1, "realloc");
+		*bufp = buf;
+		*bufsz = sz;
 	}
 
-	if (NULL == (termp.buf = malloc(termp.maxcols)))
-		err(1, "malloc");
+	/*
+	 * Fill buf with file blocksize and parse newlines into ln.
+	 */
 
-	header(&termp, mdoc_meta(mdoc));
-	body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc));
-	footer(&termp, mdoc_meta(mdoc));
+	for (lnn = 1, pos = 0; ; ) {
+		if (-1 == (ssz = read(fd, buf, sz))) {
+			warn("%s", f);
+			return(0);
+		} else if (0 == ssz) 
+			break;
 
-	free(termp.buf);
+		for (i = 0; i < (int)ssz; i++) {
+			if (pos >= (int)*lnsz) {
+				*lnsz += 256; /* Step-size. */
+				ln = realloc(ln, *lnsz);
+				if (NULL == ln)
+					err(1, "realloc");
+				*lnp = ln;
+			}
 
-	mmain_exit(p, 0);
-	/* NOTREACHED */
+			if ('\n' != buf[i]) {
+				ln[pos++] = buf[i];
+				continue;
+			}
+
+			/* Check for CPP-escaped newline.  */
+
+			if (pos > 0 && '\\' == ln[pos - 1]) {
+				for (j = pos - 1; j >= 0; j--)
+					if ('\\' != ln[j])
+						break;
+
+				if ( ! ((pos - j) % 2)) {
+					pos--;
+					lnn++;
+					continue;
+				}
+			}
+
+			ln[pos] = 0;
+			if ( ! mdoc_parseln(mdoc, lnn, ln))
+				return(0);
+			lnn++;
+			pos = 0;
+		}
+	}
+
+	return(mdoc_endparse(mdoc));
 }
 
 
 static int
-optsopt(struct termp *p, char *arg)
+toptions(enum termt *tflags, char *arg)
 {
+
+	if (0 == strcmp(arg, "ascii"))
+		*tflags = TERMT_ASCII;
+	else if (0 == strcmp(arg, "lint"))
+		*tflags = TERMT_LINT;
+	else if (0 == strcmp(arg, "tree"))
+		*tflags = TERMT_TREE;
+	else {
+		warnx("bad argument: -T%s", arg);
+		return(0);
+	}
+
+	return(1);
+}
+
+
+/*
+ * Parse out the options for [-fopt...] setting compiler options.  These
+ * can be comma-delimited or called again.
+ */
+static int
+foptions(int *fflags, char *arg)
+{
 	char		*v;
-	char		*toks[] = { "ansi", "nopunt", NULL };
+	char		*toks[] = { "ign-scope", "ign-escape", 
+				    "ign-macro", NULL };
 
 	while (*arg) 
 		switch (getsubopt(&arg, toks, &v)) {
 		case (0):
-			p->enc = TERMENC_ANSI;
+			*fflags |= MDOC_IGN_SCOPE;
 			break;
 		case (1):
-			p->iflags |= TERMP_NOPUNT;
+			*fflags |= MDOC_IGN_ESCAPE;
 			break;
+		case (2):
+			*fflags |= MDOC_IGN_MACRO;
+			break;
 		default:
-			warnx("unknown -O argument");
+			warnx("bad argument: -f%s", arg);
 			return(0);
 		}
 
@@ -266,43 +343,37 @@ optsopt(struct termp *p, char *arg)
 }
 
 
+/* 
+ * Parse out the options for [-Werr...], which sets warning modes.
+ * These can be comma-delimited or called again.  XXX - should this be
+ * using -w like troff?
+ */
 static int
-option(void *ptr, int c, char *arg)
+woptions(int *wflags, char *arg)
 {
-	struct termp	*termp;
-	struct nroffopt *nroff;
+	char		*v;
+	char		*toks[] = { "all", "compat", 
+			"syntax", "error", NULL };
 
-	nroff = (struct nroffopt *)ptr;
-	termp = nroff->termp;
+	while (*arg) 
+		switch (getsubopt(&arg, toks, &v)) {
+		case (0):
+			*wflags |= WARN_WALL;
+			break;
+		case (1):
+			*wflags |= WARN_WCOMPAT;
+			break;
+		case (2):
+			*wflags |= WARN_WSYNTAX;
+			break;
+		case (3):
+			*wflags |= WARN_WERR;
+			break;
+		default:
+			warnx("bad argument: -W%s", arg);
+			return(0);
+		}
 
-	switch (c) {
-	case ('h'):
-		nroff->fl_h = 1;
-		break;
-	case ('i'):
-		nroff->fl_i = 1;
-		break;
-	case ('m'):
-		nroff->arg_m = arg;
-		break;
-	case ('n'):
-		nroff->arg_n = arg;
-		break;
-	case ('o'):
-		nroff->arg_o = arg;
-		break;
-	case ('r'):
-		nroff->arg_r = arg;
-		break;
-	case ('T'):
-		nroff->arg_T = arg;
-		break;
-	case ('O'):
-		return(optsopt(termp, arg));
-	default:
-		break;
-	}
-
 	return(1);
 }
 
@@ -327,6 +398,8 @@ option(void *ptr, int c, char *arg)
  *    columns.  In short: don't print a newline and instead pad to the
  *    right margin.  Used in conjunction with TERMP_NOLPAD.
  *
+ *  - TERMP_NONOBREAK: don't newline when TERMP_NOBREAK is specified.
+ *
  *  In-line line breaking:
  *
  *  If TERMP_NOBREAK is specified and the line overruns the right
@@ -342,7 +415,8 @@ option(void *ptr, int c, char *arg)
 void
 flushln(struct termp *p)
 {
-	size_t		 i, j, vsz, vis, maxvis, mmax, bp;
+	int		 i, j;
+	size_t		 vsz, vis, maxvis, mmax, bp;
 
 	/*
 	 * First, establish the maximum columns of "visible" content.
@@ -365,10 +439,10 @@ flushln(struct termp *p)
 
 	if ( ! (p->flags & TERMP_NOLPAD))
 		/* LINTED */
-		for (j = 0; j < p->offset; j++)
+		for (j = 0; j < (int)p->offset; j++)
 			putchar(' ');
 
-	for (i = 0; i < p->col; i++) {
+	for (i = 0; i < (int)p->col; i++) {
 		/*
 		 * Count up visible word characters.  Control sequences
 		 * (starting with the CSI) aren't counted.  A space
@@ -377,18 +451,12 @@ flushln(struct termp *p)
 		 */
 
 		/* LINTED */
-		for (j = i, vsz = 0; j < p->col; j++) {
-			if (isspace((u_char)p->buf[j])) {
+		for (j = i, vsz = 0; j < (int)p->col; j++) {
+			if (' ' == p->buf[j])
 				break;
-			} else if (27 == p->buf[j]) {
-				assert(TERMENC_ANSI == p->enc);
-				assert(j + 5 <= p->col);
-				j += 4;
-			} else if (8 == p->buf[j]) {
-				assert(TERMENC_NROFF == p->enc);
-				assert(j + 2 <= p->col);
+			else if (8 == p->buf[j])
 				j += 1;
-			} else
+			else
 				vsz++;
 		}
 
@@ -403,7 +471,7 @@ flushln(struct termp *p)
 		if ( ! (TERMP_NOBREAK & p->flags)) {
 			if (vis && vis + vsz > bp) {
 				putchar('\n');
-				for (j = 0; j < p->offset; j++)
+				for (j = 0; j < (int)p->offset; j++)
 					putchar(' ');
 				vis = 0;
 			} else if (vis + vsz > bp)
@@ -414,7 +482,7 @@ flushln(struct termp *p)
 		} else {
 			if (vis && vis + vsz > bp) {
 				putchar('\n');
-				for (j = 0; j < p->rmargin; j++)
+				for (j = 0; j < (int)p->rmargin; j++)
 					putchar(' ');
 				vis = p->rmargin - p->offset;
 			} else if (vis + vsz > bp) 
@@ -429,13 +497,13 @@ flushln(struct termp *p)
 		 * our breakpoint.
 		 */
 
-		for ( ; i < p->col; i++) {
-			if (isspace((u_char)p->buf[i]))
+		for ( ; i < (int)p->col; i++) {
+			if (' ' == p->buf[i])
 				break;
 			putchar(p->buf[i]);
 		}
 		vis += vsz;
-		if (i < p->col && vis <= bp) {
+		if (i < (int)p->col && vis <= bp) {
 			putchar(' ');
 			vis++;
 		}
@@ -449,7 +517,7 @@ flushln(struct termp *p)
 	if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {
 		if ( ! (TERMP_NONOBREAK & p->flags)) {
 			putchar('\n');
-			for (i = 0; i < p->rmargin; i++)
+			for (i = 0; i < (int)p->rmargin; i++)
 				putchar(' ');
 		}
 		p->col = 0;
@@ -515,14 +583,14 @@ vspace(struct termp *p)
 void
 word(struct termp *p, const char *word)
 {
-	size_t 		 i, j, len;
+	int 		 i, j, len;
 
 	if (p->flags & TERMP_LITERAL) {
-		pword(p, word, strlen(word));
+		pword(p, word, (int)strlen(word));
 		return;
 	}
 
-	if (0 == (len = strlen(word)))
+	if (0 == (len = (int)strlen(word)))
 		errx(1, "blank line not in literal context");
 
 	if (mdoc_isdelim(word)) {
@@ -533,14 +601,13 @@ word(struct termp *p, const char *word)
 
 	/* LINTED */
 	for (j = i = 0; i < len; i++) {
-		if ( ! isspace((u_char)word[i])) {
+		if (' ' != word[i]) {
 			j++;
 			continue;
 		} 
 		
 		/* Escaped spaces don't delimit... */
-		if (i > 0 && isspace((u_char)word[i]) && 
-				'\\' == word[i - 1]) {
+		if (i && ' ' == word[i] && '\\' == word[i - 1]) {
 			j++;
 			continue;
 		}
@@ -670,7 +737,7 @@ footer(struct termp *p, const struct mdoc_meta *meta)
 static void
 header(struct termp *p, const struct mdoc_meta *meta)
 {
-	char		*buf, *title, *bufp;
+	char		*buf, *title;
 
 	p->rmargin = p->maxrmargin;
 	p->offset = 0;
@@ -705,9 +772,6 @@ header(struct termp *p, const struct mdoc_meta *meta)
 	(void)snprintf(title, p->rmargin, "%s(%d)", 
 			meta->title, meta->msec);
 
-	for (bufp = title; *bufp; bufp++)
-		*bufp = toupper((u_char)*bufp);
-	
 	p->offset = 0;
 	p->rmargin = (p->maxrmargin - strlen(buf)) / 2;
 	p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
@@ -747,27 +811,12 @@ header(struct termp *p, const struct mdoc_meta *meta)
 static void
 nescape(struct termp *p, const char *word, size_t len)
 {
-	struct termseq	*enc;
+	const char	*rhs;
+	size_t		 sz;
 
-	switch (len) {
-	case (1):
-		enc = termenc1;
-		break;
-	case (2):
-		enc = termenc2;
-		break;
-	default:
-		warnx("unsupported %zu-byte escape sequence", len);
+	if (NULL == (rhs = a2ascii(p->symtab, word, len, &sz))) 
 		return;
-	}
-
-	for ( ; enc->enc; enc++) 
-		if (0 == memcmp(enc->enc, word, len)) {
-			symbola(p, enc->sym);
-			return;
-		}
-
-	warnx("unsupported %zu-byte escape sequence", len);
+	stringa(p, rhs, sz);
 }
 
 
@@ -777,38 +826,33 @@ nescape(struct termp *p, const char *word, size_t len)
  * the escape sequence (we assert upon badly-formed escape sequences).
  */
 static void
-pescape(struct termp *p, const char *word, size_t *i, size_t len)
+pescape(struct termp *p, const char *word, int *i, int len)
 {
-	size_t		 j;
+	int		 j;
 
-	if (++(*i) >= len) {
-		warnx("ignoring bad escape sequence");
+	if (++(*i) >= len)
 		return;
-	}
 
 	if ('(' == word[*i]) {
 		(*i)++;
-		if (*i + 1 >= len) {
-			warnx("ignoring bad escape sequence");
+		if (*i + 1 >= len)
 			return;
-		}
+
 		nescape(p, &word[*i], 2);
 		(*i)++;
 		return;
 
 	} else if ('*' == word[*i]) { 
 		(*i)++;
-		if (*i >= len) {
-			warnx("ignoring bad escape sequence");
+		if (*i >= len)
 			return;
-		}
+
 		switch (word[*i]) {
 		case ('('):
 			(*i)++;
-			if (*i + 1 >= len) {
-				warnx("ignoring bad escape sequence");
+			if (*i + 1 >= len)
 				return;
-			}
+
 			nescape(p, &word[*i], 2);
 			(*i)++;
 			return;
@@ -828,11 +872,10 @@ pescape(struct termp *p, const char *word, size_t *i, 
 	for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)
 		/* Loop... */ ;
 
-	if (0 == word[*i]) {
-		warnx("ignoring bad escape sequence");
+	if (0 == word[*i])
 		return;
-	}
-	nescape(p, &word[*i - j], j);
+
+	nescape(p, &word[*i - j], (size_t)j);
 }
 
 
@@ -842,9 +885,9 @@ pescape(struct termp *p, const char *word, size_t *i, 
  * handles word styling.
  */
 static void
-pword(struct termp *p, const char *word, size_t len)
+pword(struct termp *p, const char *word, int len)
 {
-	size_t		 i;
+	int		 i;
 
 	if ( ! (TERMP_NOSPACE & p->flags) && 
 			! (TERMP_LITERAL & p->flags))
@@ -858,49 +901,13 @@ pword(struct termp *p, const char *word, size_t len)
 	 * before the word.
 	 */
 
-	if (TERMENC_ANSI == p->enc && TERMP_STYLE & p->flags) {
-		if (TERMP_BOLD & p->flags) {
-			chara(p, 27);
-			stringa(p, "[01m", 4);
-		}
-		if (TERMP_UNDER & p->flags) {
-			chara(p, 27);
-			stringa(p, "[04m", 4);
-		}
-		if (TERMP_RED & p->flags) {
-			chara(p, 27);
-			stringa(p, "[31m", 4);
-		}
-		if (TERMP_GREEN & p->flags) {
-			chara(p, 27);
-			stringa(p, "[32m", 4);
-		}
-		if (TERMP_YELLOW & p->flags) {
-			chara(p, 27);
-			stringa(p, "[33m", 4);
-		}
-		if (TERMP_BLUE & p->flags) {
-			chara(p, 27);
-			stringa(p, "[34m", 4);
-		}
-		if (TERMP_MAGENTA & p->flags) {
-			chara(p, 27);
-			stringa(p, "[35m", 4);
-		}
-		if (TERMP_CYAN & p->flags) {
-			chara(p, 27);
-			stringa(p, "[36m", 4);
-		}
-	}
-
 	for (i = 0; i < len; i++) {
 		if ('\\' == word[i]) {
 			pescape(p, word, &i, len);
 			continue;
 		}
 
-		if (TERMENC_NROFF == p->enc && 
-				TERMP_STYLE & p->flags) {
+		if (TERMP_STYLE & p->flags) {
 			if (TERMP_BOLD & p->flags) {
 				chara(p, word[i]);
 				chara(p, 8);
@@ -913,27 +920,10 @@ pword(struct termp *p, const char *word, size_t len)
 
 		chara(p, word[i]);
 	}
-
-	if (TERMENC_ANSI == p->enc && TERMP_STYLE & p->flags) {
-		chara(p, 27);
-		stringa(p, "[00m", 4);
-	}
 }
 
 
 /*
- * Add a symbol to the output line buffer.
- */
-static void
-symbola(struct termp *p, enum tsym sym)
-{
-
-	assert(p->symtab[sym].sym);
-	stringa(p, p->symtab[sym].sym, p->symtab[sym].sz);
-}
-
-
-/*
  * Like chara() but for arbitrary-length buffers.  Resize the buffer by
  * a factor of two (if the buffer is less than that) or the buffer's
  * size.
@@ -946,17 +936,18 @@ stringa(struct termp *p, const char *c, size_t sz)
 	if (0 == sz)
 		return;
 
-	s = sz > p->maxcols * 2 ? sz : p->maxcols * 2;
-	
 	assert(c);
 	if (p->col + sz >= p->maxcols) {
+		if (0 == p->maxcols)
+			p->maxcols = 256;
+		s = sz > p->maxcols * 2 ? sz : p->maxcols * 2;
 		p->buf = realloc(p->buf, s);
 		if (NULL == p->buf)
 			err(1, "realloc");
 		p->maxcols = s;
 	}
 
-	(void)memcpy(&p->buf[p->col], c, sz);
+	(void)memcpy(&p->buf[(int)p->col], c, sz);
 	p->col += sz;
 }
 
@@ -969,14 +960,18 @@ stringa(struct termp *p, const char *c, size_t sz)
 static void
 chara(struct termp *p, char c)
 {
+	size_t		 s;
 
 	if (p->col + 1 >= p->maxcols) {
-		p->buf = realloc(p->buf, p->maxcols * 2);
+		if (0 == p->maxcols)
+			p->maxcols = 256;
+		s = p->maxcols * 2;
+		p->buf = realloc(p->buf, s);
 		if (NULL == p->buf)
-			err(1, "malloc");
-		p->maxcols *= 2;
+			err(1, "realloc");
+		p->maxcols = s;
 	}
-	p->buf[(p->col)++] = c;
+	p->buf[(int)(p->col)++] = c;
 }
 
 
@@ -1090,37 +1085,48 @@ sanity(const struct mdoc_node *n)
 }
 
 
-dead_pre void
-punt(struct nroffopt *nroff, char *in)
+static int
+merr(void *arg, int line, int col, const char *msg)
 {
-	char		*args[32];
-	char		 arg0[32], argm[32];
-	int		 i;
 
-	warnx("punting to nroff!");
+	warnx("error: %s (line %d, column %d)", msg, line, col);
+	return(0);
+}
 
-	i = 0;
 
-	(void)strlcpy(arg0, "nroff", 32);
-	args[i++] = arg0;
+static int
+mwarn(void *arg, int line, int col, 
+		enum mdoc_warn type, const char *msg)
+{
+	int		 flags;
+	char		*wtype;
 
-	if (nroff->fl_h)
-		args[i++] = "-h";
-	if (nroff->fl_i)
-		args[i++] = "-i";
+	flags = *(int *)arg;
+	wtype = NULL;
 
-	if (nroff->arg_m) {
-		(void)strlcpy(argm, "-m", 32);
-		(void)strlcat(argm, nroff->arg_m, 32);
-		args[i++] = argm;
-	} else
-		args[i++] = "-mandoc";
+	switch (type) {
+	case (WARN_COMPAT):
+		wtype = "compat";
+		if (flags & WARN_WCOMPAT)
+			break;
+		return(1);
+	case (WARN_SYNTAX):
+		wtype = "syntax";
+		if (flags & WARN_WSYNTAX)
+			break;
+		return(1);
+	}
 
-	args[i++] = in;
-	args[i++] = (char *)NULL;
+	assert(wtype);
+	warnx("%s warning: %s (line %d, column %d)", 
+			wtype, msg, line, col);
 
-	(void)execvp("nroff", args);
-	errx(1, "exec");
-	/* NOTREACHED */
+	if ( ! (flags & WARN_WERR))
+		return(1);
+
+	warnx("%s: considering warnings as errors", 
+			__progname);
+	return(0);
 }
+