X-Git-Url: https://git.cameronkatri.com/mandoc.git/blobdiff_plain/a1933d3c64fdd2f70b36e98de723f84692e136b1..aaa5d1ca1a2cd9ee706ee668753bf556fd2fe433:/main.c

diff --git a/main.c b/main.c
index f369dc1b..e4d42b55 100644
--- a/main.c
+++ b/main.c
@@ -1,50 +1,48 @@
-/*	$Id: main.c,v 1.146 2011/02/09 09:33:43 kristaps Exp $ */
+/*	$Id: main.c,v 1.248 2015/10/12 00:08:15 schwarze Exp $ */
 /*
- * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
- * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2010-2012, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010 Joerg Sonnenberger <joerg@netbsd.org>
  *
  * 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.
  *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS 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.
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
-#include <sys/mman.h>
-#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/param.h>	/* MACHINE */
+#include <sys/wait.h>
 
 #include <assert.h>
 #include <ctype.h>
+#include <err.h>
 #include <fcntl.h>
+#include <glob.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
+#include "mandoc_aux.h"
 #include "mandoc.h"
-#include "main.h"
+#include "roff.h"
 #include "mdoc.h"
 #include "man.h"
-#include "roff.h"
-
-#ifndef MAP_FILE
-#define	MAP_FILE	0
-#endif
-
-#define	REPARSE_LIMIT	1000
-#define	UNCONST(a)	((void *)(uintptr_t)(const void *)(a))
-
-/* FIXME: Intel's compiler?  LLVM?  pcc?  */
+#include "tag.h"
+#include "main.h"
+#include "manconf.h"
+#include "mansearch.h"
 
 #if !defined(__GNUC__) || (__GNUC__ < 2)
 # if !defined(lint)
@@ -52,520 +50,645 @@
 # endif
 #endif /* !defined(__GNUC__) || (__GNUC__ < 2) */
 
-typedef	void		(*out_mdoc)(void *, const struct mdoc *);
-typedef	void		(*out_man)(void *, const struct man *);
-typedef	void		(*out_free)(void *);
-
-struct	buf {
-	char	 	 *buf;
-	size_t		  sz;
+enum	outmode {
+	OUTMODE_DEF = 0,
+	OUTMODE_FLN,
+	OUTMODE_LST,
+	OUTMODE_ALL,
+	OUTMODE_INT,
+	OUTMODE_ONE
 };
 
-enum	intt {
-	INTT_AUTO,
-	INTT_MDOC,
-	INTT_MAN
-};
+typedef	void		(*out_mdoc)(void *, const struct roff_man *);
+typedef	void		(*out_man)(void *, const struct roff_man *);
+typedef	void		(*out_free)(void *);
 
 enum	outt {
-	OUTT_ASCII = 0,
-	OUTT_TREE,
-	OUTT_HTML,
-	OUTT_XHTML,
-	OUTT_LINT,
-	OUTT_PS,
-	OUTT_PDF
+	OUTT_ASCII = 0,	/* -Tascii */
+	OUTT_LOCALE,	/* -Tlocale */
+	OUTT_UTF8,	/* -Tutf8 */
+	OUTT_TREE,	/* -Ttree */
+	OUTT_MAN,	/* -Tman */
+	OUTT_HTML,	/* -Thtml */
+	OUTT_LINT,	/* -Tlint */
+	OUTT_PS,	/* -Tps */
+	OUTT_PDF	/* -Tpdf */
 };
 
 struct	curparse {
-	const char	 *file;		/* Current parse. */
-	int		  fd;		/* Current parse. */
-	int		  line;		/* Line number in the file. */
-	enum mandoclevel  wlevel;	/* Ignore messages below this. */
-	int		  wstop;	/* Stop after a file with a warning. */
-	enum intt	  inttype;	/* which parser to use */
-	struct man	 *pman;		/* persistent man parser */
-	struct mdoc	 *pmdoc;	/* persistent mdoc parser */
-	struct man	 *man;		/* man parser */
-	struct mdoc	 *mdoc;		/* mdoc parser */
-	struct roff	 *roff;		/* roff parser (!NULL) */
-	struct regset	  regs;		/* roff registers */
-	int		  reparse_count; /* finite interpolation stack */
-	enum outt	  outtype; 	/* which output to use */
+	struct mparse	 *mp;
+	struct mchars	 *mchars;	/* character table */
+	enum mandoclevel  wlevel;	/* ignore messages below this */
+	int		  wstop;	/* stop after a file with a warning */
+	enum outt	  outtype;	/* which output to use */
 	out_mdoc	  outmdoc;	/* mdoc output ptr */
-	out_man	  	  outman;	/* man output ptr */
+	out_man		  outman;	/* man output ptr */
 	out_free	  outfree;	/* free output ptr */
 	void		 *outdata;	/* data for output */
-	char		  outopts[BUFSIZ]; /* buf of output opts */
-};
-
-static	const char * const	mandoclevels[MANDOCLEVEL_MAX] = {
-	"SUCCESS",
-	"RESERVED",
-	"WARNING",
-	"ERROR",
-	"FATAL",
-	"BADARG",
-	"SYSERR"
-};
-
-static	const enum mandocerr	mandoclimits[MANDOCLEVEL_MAX] = {
-	MANDOCERR_OK,
-	MANDOCERR_WARNING,
-	MANDOCERR_WARNING,
-	MANDOCERR_ERROR,
-	MANDOCERR_FATAL,
-	MANDOCERR_MAX,
-	MANDOCERR_MAX
-};
-
-static	const char * const	mandocerrs[MANDOCERR_MAX] = {
-	"ok",
-
-	"generic warning",
-
-	/* related to the prologue */
-	"no title in document",
-	"document title should be all caps",
-	"unknown manual section",
-	"cannot parse date argument",
-	"prologue macros out of order",
-	"duplicate prologue macro",
-	"macro not allowed in prologue",
-	"macro not allowed in body",
-
-	/* related to document structure */
-	".so is fragile, better use ln(1)",
-	"NAME section must come first",
-	"bad NAME section contents",
-	"manual name not yet set",
-	"sections out of conventional order",
-	"duplicate section name",
-	"section not in conventional manual section",
-
-	/* related to macros and nesting */
-	"skipping obsolete macro",
-	"skipping paragraph macro",
-	"skipping no-space macro",
-	"blocks badly nested",
-	"child violates parent syntax",
-	"nested displays are not portable",
-	"already in literal mode",
-
-	/* related to missing macro arguments */
-	"skipping empty macro",
-	"argument count wrong",
-	"missing display type",
-	"list type must come first",
-	"tag lists require a width argument",
-	"missing font type",
-	"skipping end of block that is not open",
-
-	/* related to bad macro arguments */
-	"skipping argument",
-	"duplicate argument",
-	"duplicate display type",
-	"duplicate list type",
-	"unknown AT&T UNIX version",
-	"bad Boolean value",
-	"unknown font",
-	"unknown standard specifier",
-	"bad width argument",
-
-	/* related to plain text */
-	"blank line in non-literal context",
-	"tab in non-literal context",
-	"end of line whitespace",
-	"bad comment style",
-	"unknown escape sequence",
-	"unterminated quoted string",
-	
-	"generic error",
-
-	/* related to tables */
-	"bad table syntax",
-	"bad table option",
-	"bad table layout",
-	"no table layout cells specified",
-	"no table data cells specified",
-	"ignore data in cell",
-	"data block still open",
-	"ignoring extra data cells",
-
-	"input stack limit exceeded, infinite loop?",
-	"skipping bad character",
-	"escaped character not allowed in a name",
-	"skipping text before the first section header",
-	"skipping unknown macro",
-	"NOT IMPLEMENTED, please use groff: skipping request",
-	"line scope broken",
-	"argument count wrong",
-	"skipping end of block that is not open",
-	"missing end of block",
-	"scope open on exit",
-	"uname(3) system call failed",
-	"macro requires line argument(s)",
-	"macro requires body argument(s)",
-	"macro requires argument(s)",
-	"missing list type",
-	"line argument(s) will be lost",
-	"body argument(s) will be lost",
-
-	"generic fatal error",
-
-	"column syntax is inconsistent",
-	"NOT IMPLEMENTED: .Bd -file",
-	"line scope broken, syntax violated",
-	"argument count wrong, violates syntax",
-	"child violates parent syntax",
-	"argument count wrong, violates syntax",
-	"NOT IMPLEMENTED: .so with absolute path or \"..\"",
-	"no document body",
-	"no document prologue",
-	"static buffer exhausted",
+	struct manoutput *outopts;	/* output options */
 };
 
-static	void		  parsebuf(struct curparse *, struct buf, int);
-static	void		  pdesc(struct curparse *);
-static	void		  fdesc(struct curparse *);
-static	void		  ffile(const char *, struct curparse *);
-static	int		  pfile(const char *, struct curparse *);
-static	int		  moptions(enum intt *, char *);
-static	int		  mmsg(enum mandocerr, void *, 
-				int, int, const char *);
-static	void		  pset(const char *, int, struct curparse *);
+static	int		  fs_lookup(const struct manpaths *,
+				size_t ipath, const char *,
+				const char *, const char *,
+				struct manpage **, size_t *);
+static	void		  fs_search(const struct mansearch *,
+				const struct manpaths *, int, char**,
+				struct manpage **, size_t *);
+static	int		  koptions(int *, char *);
+#if HAVE_SQLITE3
+int			  mandocdb(int, char**);
+#endif
+static	int		  moptions(int *, char *);
+static	void		  mmsg(enum mandocerr, enum mandoclevel,
+				const char *, int, int, const char *);
+static	void		  parse(struct curparse *, int, const char *);
+static	void		  passthrough(const char *, int, int);
+static	pid_t		  spawn_pager(struct tag_files *);
 static	int		  toptions(struct curparse *, char *);
-static	void		  usage(void) __attribute__((noreturn));
-static	void		  version(void) __attribute__((noreturn));
+static	void		  usage(enum argmode) __attribute__((noreturn));
 static	int		  woptions(struct curparse *, char *);
 
-static	const char	 *progname;
-static	enum mandoclevel  file_status = MANDOCLEVEL_OK;
-static	enum mandoclevel  exit_status = MANDOCLEVEL_OK;
+extern	char		 *__progname;
+
+static	const int sec_prios[] = {1, 4, 5, 8, 6, 3, 7, 2, 9};
+static	char		  help_arg[] = "help";
+static	char		 *help_argv[] = {help_arg, NULL};
+static	enum mandoclevel  rc;
+
 
 int
 main(int argc, char *argv[])
 {
-	int		 c;
+	struct manconf	 conf;
 	struct curparse	 curp;
+	struct mansearch search;
+	struct tag_files *tag_files;
+	char		*auxpaths;
+	char		*defos;
+	unsigned char	*uc;
+	struct manpage	*res, *resp;
+	char		*conf_file, *defpaths;
+	size_t		 isec, i, sz;
+	int		 prio, best_prio;
+	char		 sec;
+	enum mandoclevel rctmp;
+	enum outmode	 outmode;
+	int		 fd;
+	int		 show_usage;
+	int		 options;
+	int		 use_pager;
+	int		 c;
 
-	progname = strrchr(argv[0], '/');
-	if (progname == NULL)
-		progname = argv[0];
+#if !HAVE_PROGNAME
+	if (argc < 1)
+		__progname = mandoc_strdup("mandoc");
+	else if ((__progname = strrchr(argv[0], '/')) == NULL)
+		__progname = argv[0];
 	else
-		++progname;
+		++__progname;
+#endif
 
-	memset(&curp, 0, sizeof(struct curparse));
+#if HAVE_SQLITE3
+	if (strcmp(__progname, BINM_MAKEWHATIS) == 0)
+		return mandocdb(argc, argv);
+#endif
 
-	curp.inttype = INTT_AUTO;
-	curp.outtype = OUTT_ASCII;
-	curp.wlevel  = MANDOCLEVEL_FATAL;
+	/* Search options. */
 
-	/* LINTED */
-	while (-1 != (c = getopt(argc, argv, "m:O:T:VW:")))
+	memset(&conf, 0, sizeof(conf));
+	conf_file = defpaths = NULL;
+	auxpaths = NULL;
+
+	memset(&search, 0, sizeof(struct mansearch));
+	search.outkey = "Nd";
+
+	if (strcmp(__progname, BINM_MAN) == 0)
+		search.argmode = ARG_NAME;
+	else if (strcmp(__progname, BINM_APROPOS) == 0)
+		search.argmode = ARG_EXPR;
+	else if (strcmp(__progname, BINM_WHATIS) == 0)
+		search.argmode = ARG_WORD;
+	else if (strncmp(__progname, "help", 4) == 0)
+		search.argmode = ARG_NAME;
+	else
+		search.argmode = ARG_FILE;
+
+	/* Parser and formatter options. */
+
+	memset(&curp, 0, sizeof(struct curparse));
+	curp.outtype = OUTT_LOCALE;
+	curp.wlevel  = MANDOCLEVEL_BADARG;
+	curp.outopts = &conf.output;
+	options = MPARSE_SO | MPARSE_UTF8 | MPARSE_LATIN1;
+	defos = NULL;
+
+	use_pager = 1;
+	tag_files = NULL;
+	show_usage = 0;
+	outmode = OUTMODE_DEF;
+
+	while (-1 != (c = getopt(argc, argv,
+			"aC:cfhI:iK:klM:m:O:S:s:T:VW:w"))) {
 		switch (c) {
-		case ('m'):
-			if ( ! moptions(&curp.inttype, optarg))
-				return((int)MANDOCLEVEL_BADARG);
+		case 'a':
+			outmode = OUTMODE_ALL;
+			break;
+		case 'C':
+			conf_file = optarg;
+			break;
+		case 'c':
+			use_pager = 0;
+			break;
+		case 'f':
+			search.argmode = ARG_WORD;
 			break;
-		case ('O'):
-			(void)strlcat(curp.outopts, optarg, BUFSIZ);
-			(void)strlcat(curp.outopts, ",", BUFSIZ);
+		case 'h':
+			conf.output.synopsisonly = 1;
+			use_pager = 0;
+			outmode = OUTMODE_ALL;
 			break;
-		case ('T'):
+		case 'I':
+			if (strncmp(optarg, "os=", 3)) {
+				warnx("-I %s: Bad argument", optarg);
+				return (int)MANDOCLEVEL_BADARG;
+			}
+			if (defos) {
+				warnx("-I %s: Duplicate argument", optarg);
+				return (int)MANDOCLEVEL_BADARG;
+			}
+			defos = mandoc_strdup(optarg + 3);
+			break;
+		case 'i':
+			outmode = OUTMODE_INT;
+			break;
+		case 'K':
+			if ( ! koptions(&options, optarg))
+				return (int)MANDOCLEVEL_BADARG;
+			break;
+		case 'k':
+			search.argmode = ARG_EXPR;
+			break;
+		case 'l':
+			search.argmode = ARG_FILE;
+			outmode = OUTMODE_ALL;
+			break;
+		case 'M':
+			defpaths = optarg;
+			break;
+		case 'm':
+			auxpaths = optarg;
+			break;
+		case 'O':
+			search.outkey = optarg;
+			while (optarg != NULL)
+				manconf_output(&conf.output,
+				    strsep(&optarg, ","));
+			break;
+		case 'S':
+			search.arch = optarg;
+			break;
+		case 's':
+			search.sec = optarg;
+			break;
+		case 'T':
 			if ( ! toptions(&curp, optarg))
-				return((int)MANDOCLEVEL_BADARG);
+				return (int)MANDOCLEVEL_BADARG;
 			break;
-		case ('W'):
+		case 'W':
 			if ( ! woptions(&curp, optarg))
-				return((int)MANDOCLEVEL_BADARG);
+				return (int)MANDOCLEVEL_BADARG;
+			break;
+		case 'w':
+			outmode = OUTMODE_FLN;
 			break;
-		case ('V'):
-			version();
-			/* NOTREACHED */
 		default:
-			usage();
-			/* NOTREACHED */
+			show_usage = 1;
+			break;
 		}
+	}
 
-	argc -= optind;
-	argv += optind;
-
-	if (NULL == *argv) {
-		curp.file = "<stdin>";
-		curp.fd = STDIN_FILENO;
+	if (show_usage)
+		usage(search.argmode);
 
-		fdesc(&curp);
-	}
+	/* Postprocess options. */
 
-	while (*argv) {
-		ffile(*argv, &curp);
-		if (MANDOCLEVEL_OK != exit_status && curp.wstop)
+	if (outmode == OUTMODE_DEF) {
+		switch (search.argmode) {
+		case ARG_FILE:
+			outmode = OUTMODE_ALL;
+			use_pager = 0;
+			break;
+		case ARG_NAME:
+			outmode = OUTMODE_ONE;
 			break;
-		++argv;
+		default:
+			outmode = OUTMODE_LST;
+			break;
+		}
 	}
 
-	if (curp.outfree)
-		(*curp.outfree)(curp.outdata);
-	if (curp.pmdoc)
-		mdoc_free(curp.pmdoc);
-	if (curp.pman)
-		man_free(curp.pman);
-	if (curp.roff)
-		roff_free(curp.roff);
-
-	return((int)exit_status);
-}
-
-
-static void
-version(void)
-{
-
-	(void)printf("%s %s\n", progname, VERSION);
-	exit((int)MANDOCLEVEL_OK);
-}
-
-
-static void
-usage(void)
-{
-
-	(void)fprintf(stderr, "usage: %s "
-			"[-V] "
-			"[-foption] "
-			"[-mformat] "
-			"[-Ooption] "
-			"[-Toutput] "
-			"[-Werr] "
-			"[file...]\n", 
-			progname);
+	if (outmode == OUTMODE_FLN ||
+	    outmode == OUTMODE_LST ||
+	    !isatty(STDOUT_FILENO))
+		use_pager = 0;
 
-	exit((int)MANDOCLEVEL_BADARG);
-}
+	/* Parse arguments. */
 
-static void
-ffile(const char *file, struct curparse *curp)
-{
+	if (argc > 0) {
+		argc -= optind;
+		argv += optind;
+	}
+	resp = NULL;
 
 	/*
-	 * Called once per input file.  Get the file ready for reading,
-	 * pass it through to the parser-driver, then close it out.
-	 * XXX: don't do anything special as this is only called for
-	 * files; stdin goes directly to fdesc().
+	 * Quirks for help(1)
+	 * and for a man(1) section argument without -s.
 	 */
 
-	curp->file = file;
-
-	if (-1 == (curp->fd = open(curp->file, O_RDONLY, 0))) {
-		perror(curp->file);
-		exit_status = MANDOCLEVEL_SYSERR;
-		return;
+	if (search.argmode == ARG_NAME) {
+		if (*__progname == 'h') {
+			if (argc == 0) {
+				argv = help_argv;
+				argc = 1;
+			}
+		} else if (argc > 1 &&
+		    ((uc = (unsigned char *)argv[0]) != NULL) &&
+		    ((isdigit(uc[0]) && (uc[1] == '\0' ||
+		      (isalpha(uc[1]) && uc[2] == '\0'))) ||
+		     (uc[0] == 'n' && uc[1] == '\0'))) {
+			search.sec = (char *)uc;
+			argv++;
+			argc--;
+		}
+		if (search.arch == NULL)
+			search.arch = getenv("MACHINE");
+#ifdef MACHINE
+		if (search.arch == NULL)
+			search.arch = MACHINE;
+#endif
 	}
 
-	fdesc(curp);
+	rc = MANDOCLEVEL_OK;
 
-	if (-1 == close(curp->fd))
-		perror(curp->file);
-}
+	/* man(1), whatis(1), apropos(1) */
 
-static int
-pfile(const char *file, struct curparse *curp)
-{
-	const char	*savefile;
-	int		 fd, savefd;
+	if (search.argmode != ARG_FILE) {
+		if (argc == 0)
+			usage(search.argmode);
 
-	if (-1 == (fd = open(file, O_RDONLY, 0))) {
-		perror(file);
-		file_status = MANDOCLEVEL_SYSERR;
-		return(0);
-	}
+		if (search.argmode == ARG_NAME &&
+		    outmode == OUTMODE_ONE)
+			search.firstmatch = 1;
 
-	savefile = curp->file;
-	savefd = curp->fd;
+		/* Access the mandoc database. */
 
-	curp->file = file;
-	curp->fd = fd;
-
-	pdesc(curp);
+		manconf_parse(&conf, conf_file, defpaths, auxpaths);
+#if HAVE_SQLITE3
+		mansearch_setup(1);
+		if ( ! mansearch(&search, &conf.manpath,
+		    argc, argv, &res, &sz))
+			usage(search.argmode);
+#else
+		if (search.argmode != ARG_NAME) {
+			fputs("mandoc: database support not compiled in\n",
+			    stderr);
+			return (int)MANDOCLEVEL_BADARG;
+		}
+		sz = 0;
+#endif
 
-	curp->file = savefile;
-	curp->fd = savefd;
+		if (sz == 0) {
+			if (search.argmode == ARG_NAME)
+				fs_search(&search, &conf.manpath,
+				    argc, argv, &res, &sz);
+			else
+				warnx("nothing appropriate");
+		}
 
-	if (-1 == close(fd))
-		perror(file);
+		if (sz == 0) {
+			rc = MANDOCLEVEL_BADARG;
+			goto out;
+		}
 
-	return(MANDOCLEVEL_FATAL > file_status ? 1 : 0);
-}
+		/*
+		 * For standard man(1) and -a output mode,
+		 * prepare for copying filename pointers
+		 * into the program parameter array.
+		 */
 
+		if (outmode == OUTMODE_ONE) {
+			argc = 1;
+			best_prio = 10;
+		} else if (outmode == OUTMODE_ALL)
+			argc = (int)sz;
+
+		/* Iterate all matching manuals. */
+
+		resp = res;
+		for (i = 0; i < sz; i++) {
+			if (outmode == OUTMODE_FLN)
+				puts(res[i].file);
+			else if (outmode == OUTMODE_LST)
+				printf("%s - %s\n", res[i].names,
+				    res[i].output == NULL ? "" :
+				    res[i].output);
+			else if (outmode == OUTMODE_ONE) {
+				/* Search for the best section. */
+				isec = strcspn(res[i].file, "123456789");
+				sec = res[i].file[isec];
+				if ('\0' == sec)
+					continue;
+				prio = sec_prios[sec - '1'];
+				if (prio >= best_prio)
+					continue;
+				best_prio = prio;
+				resp = res + i;
+			}
+		}
 
-static void
-resize_buf(struct buf *buf, size_t initial)
-{
+		/*
+		 * For man(1), -a and -i output mode, fall through
+		 * to the main mandoc(1) code iterating files
+		 * and running the parsers on each of them.
+		 */
 
-	buf->sz = buf->sz > initial/2 ? 2 * buf->sz : initial;
-	buf->buf = realloc(buf->buf, buf->sz);
-	if (NULL == buf->buf) {
-		perror(NULL);
-		exit((int)MANDOCLEVEL_SYSERR);
+		if (outmode == OUTMODE_FLN || outmode == OUTMODE_LST)
+			goto out;
 	}
-}
 
+	/* mandoc(1) */
 
-static int
-read_whole_file(struct curparse *curp, struct buf *fb, int *with_mmap)
-{
-	struct stat	 st;
-	size_t		 off;
-	ssize_t		 ssz;
+	if (search.argmode == ARG_FILE && ! moptions(&options, auxpaths))
+		return (int)MANDOCLEVEL_BADARG;
 
-	if (-1 == fstat(curp->fd, &st)) {
-		perror(curp->file);
-		return(0);
-	}
+	curp.mchars = mchars_alloc();
+	curp.mp = mparse_alloc(options, curp.wlevel, mmsg,
+	    curp.mchars, defos);
 
 	/*
-	 * If we're a regular file, try just reading in the whole entry
-	 * via mmap().  This is faster than reading it into blocks, and
-	 * since each file is only a few bytes to begin with, I'm not
-	 * concerned that this is going to tank any machines.
+	 * Conditionally start up the lookaside buffer before parsing.
 	 */
+	if (OUTT_MAN == curp.outtype)
+		mparse_keep(curp.mp);
 
-	if (S_ISREG(st.st_mode)) {
-		if (st.st_size >= (1U << 31)) {
-			fprintf(stderr, "%s: input too large\n", 
-					curp->file);
-			return(0);
-		}
-		*with_mmap = 1;
-		fb->sz = (size_t)st.st_size;
-		fb->buf = mmap(NULL, fb->sz, PROT_READ, 
-				MAP_FILE|MAP_SHARED, curp->fd, 0);
-		if (fb->buf != MAP_FAILED)
-			return(1);
+	if (argc < 1) {
+		if (use_pager)
+			tag_files = tag_init();
+		parse(&curp, STDIN_FILENO, "<stdin>");
 	}
 
-	/*
-	 * If this isn't a regular file (like, say, stdin), then we must
-	 * go the old way and just read things in bit by bit.
-	 */
+	while (argc > 0) {
+		rctmp = mparse_open(curp.mp, &fd,
+		    resp != NULL ? resp->file : *argv);
+		if (rc < rctmp)
+			rc = rctmp;
 
-	*with_mmap = 0;
-	off = 0;
-	fb->sz = 0;
-	fb->buf = NULL;
-	for (;;) {
-		if (off == fb->sz) {
-			if (fb->sz == (1U << 31)) {
-				fprintf(stderr, "%s: input too large\n", 
-						curp->file);
-				break;
+		if (fd != -1) {
+			if (use_pager) {
+				tag_files = tag_init();
+				use_pager = 0;
 			}
-			resize_buf(fb, 65536);
-		}
-		ssz = read(curp->fd, fb->buf + (int)off, fb->sz - off);
-		if (ssz == 0) {
-			fb->sz = off;
-			return(1);
+
+			if (resp == NULL)
+				parse(&curp, fd, *argv);
+			else if (resp->form & FORM_SRC) {
+				/* For .so only; ignore failure. */
+				chdir(conf.manpath.paths[resp->ipath]);
+				parse(&curp, fd, resp->file);
+			} else
+				passthrough(resp->file, fd,
+				    conf.output.synopsisonly);
+
+			if (argc > 1 && curp.outtype <= OUTT_UTF8)
+				ascii_sepline(curp.outdata);
 		}
-		if (ssz == -1) {
-			perror(curp->file);
+
+		if (MANDOCLEVEL_OK != rc && curp.wstop)
 			break;
-		}
-		off += (size_t)ssz;
-	}
 
-	free(fb->buf);
-	fb->buf = NULL;
-	return(0);
-}
+		if (resp != NULL)
+			resp++;
+		else
+			argv++;
+		if (--argc)
+			mparse_reset(curp.mp);
+	}
 
+	if (curp.outfree)
+		(*curp.outfree)(curp.outdata);
+	mparse_free(curp.mp);
+	mchars_free(curp.mchars);
+
+out:
+	if (search.argmode != ARG_FILE) {
+		manconf_free(&conf);
+#if HAVE_SQLITE3
+		mansearch_free(res, sz);
+		mansearch_setup(0);
+#endif
+	}
 
-static void
-fdesc(struct curparse *curp)
-{
+	free(defos);
 
 	/*
-	 * Called once per file with an opened file descriptor.  All
-	 * pre-file-parse operations (whether stdin or a file) should go
-	 * here.
-	 *
-	 * This calls down into the nested parser, which drills down and
-	 * fully parses a file and all its dependences (i.e., `so').  It
-	 * then runs the cleanup validators and pushes to output.
+	 * When using a pager, finish writing both temporary files,
+	 * fork it, wait for the user to close it, and clean up.
 	 */
 
-	/* Zero the parse type. */
+	if (tag_files != NULL) {
+		fclose(stdout);
+		tag_write();
+		waitpid(spawn_pager(tag_files), NULL, 0);
+		tag_unlink();
+	}
 
-	curp->mdoc = NULL;
-	curp->man = NULL;
-	file_status = MANDOCLEVEL_OK;
+	return (int)rc;
+}
 
-	/* Make sure the mandotory roff parser is initialised. */
+static void
+usage(enum argmode argmode)
+{
 
-	if (NULL == curp->roff) {
-		curp->roff = roff_alloc(&curp->regs, curp, mmsg);
-		assert(curp->roff);
+	switch (argmode) {
+	case ARG_FILE:
+		fputs("usage: mandoc [-acfhkl] [-I os=name] "
+		    "[-K encoding] [-mformat] [-O option]\n"
+		    "\t      [-T output] [-W level] [file ...]\n", stderr);
+		break;
+	case ARG_NAME:
+		fputs("usage: man [-acfhklw] [-C file] [-I os=name] "
+		    "[-K encoding] [-M path] [-m path]\n"
+		    "\t   [-O option=value] [-S subsection] [-s section] "
+		    "[-T output] [-W level]\n"
+		    "\t   [section] name ...\n", stderr);
+		break;
+	case ARG_WORD:
+		fputs("usage: whatis [-acfhklw] [-C file] "
+		    "[-M path] [-m path] [-O outkey] [-S arch]\n"
+		    "\t      [-s section] name ...\n", stderr);
+		break;
+	case ARG_EXPR:
+		fputs("usage: apropos [-acfhklw] [-C file] "
+		    "[-M path] [-m path] [-O outkey] [-S arch]\n"
+		    "\t       [-s section] expression ...\n", stderr);
+		break;
 	}
+	exit((int)MANDOCLEVEL_BADARG);
+}
 
-	/* Fully parse the file. */
-
-	pdesc(curp);
-
-	if (MANDOCLEVEL_FATAL <= file_status)
-		goto cleanup;
+static int
+fs_lookup(const struct manpaths *paths, size_t ipath,
+	const char *sec, const char *arch, const char *name,
+	struct manpage **res, size_t *ressz)
+{
+	glob_t		 globinfo;
+	struct manpage	*page;
+	char		*file;
+	int		 form, globres;
+
+	form = FORM_SRC;
+	mandoc_asprintf(&file, "%s/man%s/%s.%s",
+	    paths->paths[ipath], sec, name, sec);
+	if (access(file, R_OK) != -1)
+		goto found;
+	free(file);
+
+	mandoc_asprintf(&file, "%s/cat%s/%s.0",
+	    paths->paths[ipath], sec, name);
+	if (access(file, R_OK) != -1) {
+		form = FORM_CAT;
+		goto found;
+	}
+	free(file);
+
+	if (arch != NULL) {
+		mandoc_asprintf(&file, "%s/man%s/%s/%s.%s",
+		    paths->paths[ipath], sec, arch, name, sec);
+		if (access(file, R_OK) != -1)
+			goto found;
+		free(file);
+	}
 
-	/* NOTE a parser may not have been assigned, yet. */
+	mandoc_asprintf(&file, "%s/man%s/%s.[01-9]*",
+	    paths->paths[ipath], sec, name);
+	globres = glob(file, 0, NULL, &globinfo);
+	if (globres != 0 && globres != GLOB_NOMATCH)
+		warn("%s: glob", file);
+	free(file);
+	if (globres == 0)
+		file = mandoc_strdup(*globinfo.gl_pathv);
+	globfree(&globinfo);
+	if (globres != 0)
+		return 0;
+
+found:
+#if HAVE_SQLITE3
+	warnx("outdated mandoc.db lacks %s(%s) entry, run makewhatis %s\n",
+	    name, sec, paths->paths[ipath]);
+#endif
+	*res = mandoc_reallocarray(*res, ++*ressz, sizeof(struct manpage));
+	page = *res + (*ressz - 1);
+	page->file = file;
+	page->names = NULL;
+	page->output = NULL;
+	page->ipath = ipath;
+	page->bits = NAME_FILE & NAME_MASK;
+	page->sec = (*sec >= '1' && *sec <= '9') ? *sec - '1' + 1 : 10;
+	page->form = form;
+	return 1;
+}
 
-	if ( ! (curp->man || curp->mdoc)) {
-		fprintf(stderr, "%s: Not a manual\n", curp->file);
-		file_status = MANDOCLEVEL_FATAL;
-		goto cleanup;
+static void
+fs_search(const struct mansearch *cfg, const struct manpaths *paths,
+	int argc, char **argv, struct manpage **res, size_t *ressz)
+{
+	const char *const sections[] =
+	    {"1", "8", "6", "2", "3", "3p", "5", "7", "4", "9"};
+	const size_t nsec = sizeof(sections)/sizeof(sections[0]);
+
+	size_t		 ipath, isec, lastsz;
+
+	assert(cfg->argmode == ARG_NAME);
+
+	*res = NULL;
+	*ressz = lastsz = 0;
+	while (argc) {
+		for (ipath = 0; ipath < paths->sz; ipath++) {
+			if (cfg->sec != NULL) {
+				if (fs_lookup(paths, ipath, cfg->sec,
+				    cfg->arch, *argv, res, ressz) &&
+				    cfg->firstmatch)
+					return;
+			} else for (isec = 0; isec < nsec; isec++)
+				if (fs_lookup(paths, ipath, sections[isec],
+				    cfg->arch, *argv, res, ressz) &&
+				    cfg->firstmatch)
+					return;
+		}
+		if (*ressz == lastsz)
+			warnx("No entry for %s in the manual.", *argv);
+		lastsz = *ressz;
+		argv++;
+		argc--;
 	}
+}
 
-	/* Clean up the parse routine ASTs. */
+static void
+parse(struct curparse *curp, int fd, const char *file)
+{
+	enum mandoclevel  rctmp;
+	struct roff_man	 *man;
 
-	if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
-		assert(MANDOCLEVEL_FATAL <= file_status);
-		goto cleanup;
-	}
+	/* Begin by parsing the file itself. */
 
-	if (curp->man && ! man_endparse(curp->man)) {
-		assert(MANDOCLEVEL_FATAL <= file_status);
-		goto cleanup;
-	}
+	assert(file);
+	assert(fd >= -1);
 
-	assert(curp->roff);
-	roff_endparse(curp->roff);
+	rctmp = mparse_readfd(curp->mp, fd, file);
+	if (rc < rctmp)
+		rc = rctmp;
 
 	/*
-	 * With -Wstop and warnings or errors of at least
-	 * the requested level, do not produce output.
+	 * With -Wstop and warnings or errors of at least the requested
+	 * level, do not produce output.
 	 */
 
-	if (MANDOCLEVEL_OK != file_status && curp->wstop)
-		goto cleanup;
+	if (rctmp != MANDOCLEVEL_OK && curp->wstop)
+		return;
 
 	/* If unset, allocate output dev now (if applicable). */
 
 	if ( ! (curp->outman && curp->outmdoc)) {
 		switch (curp->outtype) {
-		case (OUTT_XHTML):
-			curp->outdata = xhtml_alloc(curp->outopts);
+		case OUTT_HTML:
+			curp->outdata = html_alloc(curp->mchars,
+			    curp->outopts);
+			curp->outfree = html_free;
+			break;
+		case OUTT_UTF8:
+			curp->outdata = utf8_alloc(curp->mchars,
+			    curp->outopts);
+			curp->outfree = ascii_free;
 			break;
-		case (OUTT_HTML):
-			curp->outdata = html_alloc(curp->outopts);
+		case OUTT_LOCALE:
+			curp->outdata = locale_alloc(curp->mchars,
+			    curp->outopts);
+			curp->outfree = ascii_free;
 			break;
-		case (OUTT_ASCII):
-			curp->outdata = ascii_alloc(curp->outopts);
+		case OUTT_ASCII:
+			curp->outdata = ascii_alloc(curp->mchars,
+			    curp->outopts);
 			curp->outfree = ascii_free;
 			break;
-		case (OUTT_PDF):
-			curp->outdata = pdf_alloc(curp->outopts);
+		case OUTT_PDF:
+			curp->outdata = pdf_alloc(curp->mchars,
+			    curp->outopts);
 			curp->outfree = pspdf_free;
 			break;
-		case (OUTT_PS):
-			curp->outdata = ps_alloc(curp->outopts);
+		case OUTT_PS:
+			curp->outdata = ps_alloc(curp->mchars,
+			    curp->outopts);
 			curp->outfree = pspdf_free;
 			break;
 		default:
@@ -573,22 +696,23 @@ fdesc(struct curparse *curp)
 		}
 
 		switch (curp->outtype) {
-		case (OUTT_HTML):
-			/* FALLTHROUGH */
-		case (OUTT_XHTML):
+		case OUTT_HTML:
 			curp->outman = html_man;
 			curp->outmdoc = html_mdoc;
-			curp->outfree = html_free;
 			break;
-		case (OUTT_TREE):
+		case OUTT_TREE:
 			curp->outman = tree_man;
 			curp->outmdoc = tree_mdoc;
 			break;
-		case (OUTT_PDF):
-			/* FALLTHROUGH */
-		case (OUTT_ASCII):
-			/* FALLTHROUGH */
-		case (OUTT_PS):
+		case OUTT_MAN:
+			curp->outmdoc = man_mdoc;
+			curp->outman = man_man;
+			break;
+		case OUTT_PDF:
+		case OUTT_ASCII:
+		case OUTT_UTF8:
+		case OUTT_LOCALE:
+		case OUTT_PS:
 			curp->outman = terminal_man;
 			curp->outmdoc = terminal_mdoc;
 			break;
@@ -597,380 +721,121 @@ fdesc(struct curparse *curp)
 		}
 	}
 
-	/* Execute the out device, if it exists. */
-
-	if (curp->man && curp->outman)
-		(*curp->outman)(curp->outdata, curp->man);
-	if (curp->mdoc && curp->outmdoc)
-		(*curp->outmdoc)(curp->outdata, curp->mdoc);
-
- cleanup:
-
-	memset(&curp->regs, 0, sizeof(struct regset));
-
-	/* Reset the current-parse compilers. */
+	mparse_result(curp->mp, &man, NULL);
 
-	if (curp->mdoc)
-		mdoc_reset(curp->mdoc);
-	if (curp->man)
-		man_reset(curp->man);
-
-	assert(curp->roff);
-	roff_reset(curp->roff);
-
-	if (exit_status < file_status)
-		exit_status = file_status;
-
-	return;
-}
-
-static void
-pdesc(struct curparse *curp)
-{
-	struct buf	 blk;
-	int		 with_mmap;
-
-	/*
-	 * Run for each opened file; may be called more than once for
-	 * each full parse sequence if the opened file is nested (i.e.,
-	 * from `so').  Simply sucks in the whole file and moves into
-	 * the parse phase for the file.
-	 */
+	/* Execute the out device, if it exists. */
 
-	if ( ! read_whole_file(curp, &blk, &with_mmap)) {
-		file_status = MANDOCLEVEL_SYSERR;
+	if (man == NULL)
 		return;
-	}
-
-	/* Line number is per-file. */
-
-	curp->line = 1;
-
-	parsebuf(curp, blk, 1);
-
-	if (with_mmap)
-		munmap(blk.buf, blk.sz);
-	else
-		free(blk.buf);
+	if (curp->outmdoc != NULL && man->macroset == MACROSET_MDOC)
+		(*curp->outmdoc)(curp->outdata, man);
+	if (curp->outman != NULL && man->macroset == MACROSET_MAN)
+		(*curp->outman)(curp->outdata, man);
 }
 
 static void
-parsebuf(struct curparse *curp, struct buf blk, int start)
+passthrough(const char *file, int fd, int synopsis_only)
 {
-	const struct tbl_span	*span;
-	struct buf	 ln;
-	enum rofferr	 rr;
-	int		 i, of, rc;
-	int		 pos; /* byte number in the ln buffer */
-	int		 lnn; /* line number in the real file */
-	unsigned char	 c;
-
-	/*
-	 * Main parse routine for an opened file.  This is called for
-	 * each opened file and simply loops around the full input file,
-	 * possibly nesting (i.e., with `so').
-	 */
-
-	memset(&ln, 0, sizeof(struct buf));
-
-	lnn = curp->line; 
-	pos = 0; 
-
-	for (i = 0; i < (int)blk.sz; ) {
-		if (0 == pos && '\0' == blk.buf[i])
-			break;
-
-		if (start) {
-			curp->line = lnn;
-			curp->reparse_count = 0;
-		}
-
-		while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) {
-
-			/*
-			 * When finding an unescaped newline character,
-			 * leave the character loop to process the line.
-			 * Skip a preceding carriage return, if any.
-			 */
-
-			if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz &&
-			    '\n' == blk.buf[i + 1])
-				++i;
-			if ('\n' == blk.buf[i]) {
-				++i;
-				++lnn;
-				break;
-			}
-
-			/* 
-			 * Warn about bogus characters.  If you're using
-			 * non-ASCII encoding, you're screwing your
-			 * readers.  Since I'd rather this not happen,
-			 * I'll be helpful and drop these characters so
-			 * we don't display gibberish.  Note to manual
-			 * writers: use special characters.
-			 */
-
-			c = (unsigned char) blk.buf[i];
-
-			if ( ! (isascii(c) && 
-					(isgraph(c) || isblank(c)))) {
-				mmsg(MANDOCERR_BADCHAR, curp, 
-				    curp->line, pos, "ignoring byte");
-				i++;
-				continue;
-			}
-
-			/* Trailing backslash = a plain char. */
-
-			if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
-				if (pos >= (int)ln.sz)
-					resize_buf(&ln, 256);
-				ln.buf[pos++] = blk.buf[i++];
-				continue;
-			}
-
-			/*
-			 * Found escape and at least one other character.
-			 * When it's a newline character, skip it.
-			 * When there is a carriage return in between,
-			 * skip that one as well.
-			 */
-
-			if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz &&
-			    '\n' == blk.buf[i + 2])
-				++i;
-			if ('\n' == blk.buf[i + 1]) {
-				i += 2;
-				++lnn;
-				continue;
-			}
-
-			if ('"' == blk.buf[i + 1]) {
-				i += 2;
-				/* Comment, skip to end of line */
-				for (; i < (int)blk.sz; ++i) {
-					if ('\n' == blk.buf[i]) {
-						++i;
-						++lnn;
-						break;
-					}
-				}
+	const char	 synb[] = "S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS";
+	const char	 synr[] = "SYNOPSIS";
+
+	FILE		*stream;
+	const char	*syscall;
+	char		*line;
+	size_t		 len, off;
+	ssize_t		 nw;
+	int		 print;
+
+	fflush(stdout);
+
+	if ((stream = fdopen(fd, "r")) == NULL) {
+		close(fd);
+		syscall = "fdopen";
+		goto fail;
+	}
 
-				/* Backout trailing whitespaces */
-				for (; pos > 0; --pos) {
-					if (ln.buf[pos - 1] != ' ')
-						break;
-					if (pos > 2 && ln.buf[pos - 2] == '\\')
-						break;
+	print = 0;
+	while ((line = fgetln(stream, &len)) != NULL) {
+		if (synopsis_only) {
+			if (print) {
+				if ( ! isspace((unsigned char)*line))
+					goto done;
+				while (len &&
+				    isspace((unsigned char)*line)) {
+					line++;
+					len--;
 				}
-				break;
-			}
-
-			/* Some other escape sequence, copy & cont. */
-
-			if (pos + 1 >= (int)ln.sz)
-				resize_buf(&ln, 256);
-
-			ln.buf[pos++] = blk.buf[i++];
-			ln.buf[pos++] = blk.buf[i++];
-		}
-
- 		if (pos >= (int)ln.sz)
-			resize_buf(&ln, 256);
-
-		ln.buf[pos] = '\0';
-
-		/*
-		 * A significant amount of complexity is contained by
-		 * the roff preprocessor.  It's line-oriented but can be
-		 * expressed on one line, so we need at times to
-		 * readjust our starting point and re-run it.  The roff
-		 * preprocessor can also readjust the buffers with new
-		 * data, so we pass them in wholesale.
-		 */
-
-		of = 0;
-
-rerun:
-		rr = roff_parseln
-			(curp->roff, curp->line, 
-			 &ln.buf, &ln.sz, of, &of);
-
-		switch (rr) {
-		case (ROFF_REPARSE):
-			if (REPARSE_LIMIT >= ++curp->reparse_count)
-				parsebuf(curp, ln, 0);
-			else
-				mmsg(MANDOCERR_ROFFLOOP, curp, 
-				    curp->line, pos, NULL);
-			pos = 0;
-			continue;
-		case (ROFF_APPEND):
-			pos = strlen(ln.buf);
-			continue;
-		case (ROFF_RERUN):
-			goto rerun;
-		case (ROFF_IGN):
-			pos = 0;
-			continue;
-		case (ROFF_ERR):
-			assert(MANDOCLEVEL_FATAL <= file_status);
-			break;
-		case (ROFF_SO):
-			if (pfile(ln.buf + of, curp)) {
-				pos = 0;
+			} else {
+				if ((len == sizeof(synb) &&
+				     ! strncmp(line, synb, len - 1)) ||
+				    (len == sizeof(synr) &&
+				     ! strncmp(line, synr, len - 1)))
+					print = 1;
 				continue;
-			} else
-				break;
-		default:
-			break;
-		}
-
-		/*
-		 * If we encounter errors in the recursive parsebuf()
-		 * call, make sure we don't continue parsing.
-		 */
-
-		if (MANDOCLEVEL_FATAL <= file_status)
-			break;
-
-		/*
-		 * If input parsers have not been allocated, do so now.
-		 * We keep these instanced betwen parsers, but set them
-		 * locally per parse routine since we can use different
-		 * parsers with each one.
-		 */
-
-		if ( ! (curp->man || curp->mdoc))
-			pset(ln.buf + of, pos - of, curp);
-
-		/* 
-		 * Lastly, push down into the parsers themselves.  One
-		 * of these will have already been set in the pset()
-		 * routine.
-		 * If libroff returns ROFF_TBL, then add it to the
-		 * currently open parse.  Since we only get here if
-		 * there does exist data (see tbl_data.c), we're
-		 * guaranteed that something's been allocated.
-		 * Do the same for ROFF_EQN.
-		 */
-
-		rc = -1;
-
-		if (ROFF_TBL == rr)
-			while (NULL != (span = roff_span(curp->roff))) {
-				rc = curp->man ?
-					man_addspan(curp->man, span) :
-					mdoc_addspan(curp->mdoc, span);
-				if (0 == rc)
-					break;
 			}
-		else if (ROFF_EQN == rr)
-			rc = curp->mdoc ? 
-				mdoc_addeqn(curp->mdoc, 
-					roff_eqn(curp->roff)) :
-				man_addeqn(curp->man,
-					roff_eqn(curp->roff));
-		else if (curp->man || curp->mdoc)
-			rc = curp->man ?
-				man_parseln(curp->man, 
-					curp->line, ln.buf, of) :
-				mdoc_parseln(curp->mdoc, 
-					curp->line, ln.buf, of);
-
-		if (0 == rc) {
-			assert(MANDOCLEVEL_FATAL <= file_status);
-			break;
 		}
+		for (off = 0; off < len; off += nw)
+			if ((nw = write(STDOUT_FILENO, line + off,
+			    len - off)) == -1 || nw == 0) {
+				fclose(stream);
+				syscall = "write";
+				goto fail;
+			}
+	}
 
-		/* Temporary buffers typically are not full. */
-
-		if (0 == start && '\0' == blk.buf[i])
-			break;
-
-		/* Start the next input line. */
-
-		pos = 0;
+	if (ferror(stream)) {
+		fclose(stream);
+		syscall = "fgetln";
+		goto fail;
 	}
 
-	free(ln.buf);
+done:
+	fclose(stream);
+	return;
+
+fail:
+	warn("%s: SYSERR: %s", file, syscall);
+	if (rc < MANDOCLEVEL_SYSERR)
+		rc = MANDOCLEVEL_SYSERR;
 }
 
-static void
-pset(const char *buf, int pos, struct curparse *curp)
+static int
+koptions(int *options, char *arg)
 {
-	int		 i;
-
-	/*
-	 * Try to intuit which kind of manual parser should be used.  If
-	 * passed in by command-line (-man, -mdoc), then use that
-	 * explicitly.  If passed as -mandoc, then try to guess from the
-	 * line: either skip dot-lines, use -mdoc when finding `.Dt', or
-	 * default to -man, which is more lenient.
-	 *
-	 * Separate out pmdoc/pman from mdoc/man: the first persists
-	 * through all parsers, while the latter is used per-parse.
-	 */
-
-	if ('.' == buf[0] || '\'' == buf[0]) {
-		for (i = 1; buf[i]; i++)
-			if (' ' != buf[i] && '\t' != buf[i])
-				break;
-		if ('\0' == buf[i])
-			return;
-	}
 
-	switch (curp->inttype) {
-	case (INTT_MDOC):
-		if (NULL == curp->pmdoc) 
-			curp->pmdoc = mdoc_alloc
-				(&curp->regs, curp, mmsg);
-		assert(curp->pmdoc);
-		curp->mdoc = curp->pmdoc;
-		return;
-	case (INTT_MAN):
-		if (NULL == curp->pman) 
-			curp->pman = man_alloc
-				(&curp->regs, curp, mmsg);
-		assert(curp->pman);
-		curp->man = curp->pman;
-		return;
-	default:
-		break;
+	if ( ! strcmp(arg, "utf-8")) {
+		*options |=  MPARSE_UTF8;
+		*options &= ~MPARSE_LATIN1;
+	} else if ( ! strcmp(arg, "iso-8859-1")) {
+		*options |=  MPARSE_LATIN1;
+		*options &= ~MPARSE_UTF8;
+	} else if ( ! strcmp(arg, "us-ascii")) {
+		*options &= ~(MPARSE_UTF8 | MPARSE_LATIN1);
+	} else {
+		warnx("-K %s: Bad argument", arg);
+		return 0;
 	}
-
-	if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
-		if (NULL == curp->pmdoc) 
-			curp->pmdoc = mdoc_alloc
-				(&curp->regs, curp, mmsg);
-		assert(curp->pmdoc);
-		curp->mdoc = curp->pmdoc;
-		return;
-	} 
-
-	if (NULL == curp->pman) 
-		curp->pman = man_alloc(&curp->regs, curp, mmsg);
-	assert(curp->pman);
-	curp->man = curp->pman;
+	return 1;
 }
 
 static int
-moptions(enum intt *tflags, char *arg)
+moptions(int *options, char *arg)
 {
 
-	if (0 == strcmp(arg, "doc"))
-		*tflags = INTT_MDOC;
+	if (arg == NULL)
+		/* nothing to do */;
+	else if (0 == strcmp(arg, "doc"))
+		*options |= MPARSE_MDOC;
 	else if (0 == strcmp(arg, "andoc"))
-		*tflags = INTT_AUTO;
+		/* nothing to do */;
 	else if (0 == strcmp(arg, "an"))
-		*tflags = INTT_MAN;
+		*options |= MPARSE_MAN;
 	else {
-		fprintf(stderr, "%s: Bad argument\n", arg);
-		return(0);
+		warnx("-m %s: Bad argument", arg);
+		return 0;
 	}
 
-	return(1);
+	return 1;
 }
 
 static int
@@ -982,87 +847,157 @@ toptions(struct curparse *curp, char *arg)
 	else if (0 == strcmp(arg, "lint")) {
 		curp->outtype = OUTT_LINT;
 		curp->wlevel  = MANDOCLEVEL_WARNING;
-	}
-	else if (0 == strcmp(arg, "tree"))
+	} else if (0 == strcmp(arg, "tree"))
 		curp->outtype = OUTT_TREE;
+	else if (0 == strcmp(arg, "man"))
+		curp->outtype = OUTT_MAN;
 	else if (0 == strcmp(arg, "html"))
 		curp->outtype = OUTT_HTML;
+	else if (0 == strcmp(arg, "utf8"))
+		curp->outtype = OUTT_UTF8;
+	else if (0 == strcmp(arg, "locale"))
+		curp->outtype = OUTT_LOCALE;
 	else if (0 == strcmp(arg, "xhtml"))
-		curp->outtype = OUTT_XHTML;
+		curp->outtype = OUTT_HTML;
 	else if (0 == strcmp(arg, "ps"))
 		curp->outtype = OUTT_PS;
 	else if (0 == strcmp(arg, "pdf"))
 		curp->outtype = OUTT_PDF;
 	else {
-		fprintf(stderr, "%s: Bad argument\n", arg);
-		return(0);
+		warnx("-T %s: Bad argument", arg);
+		return 0;
 	}
 
-	return(1);
+	return 1;
 }
 
 static int
 woptions(struct curparse *curp, char *arg)
 {
 	char		*v, *o;
-	const char	*toks[6]; 
+	const char	*toks[7];
 
 	toks[0] = "stop";
 	toks[1] = "all";
 	toks[2] = "warning";
 	toks[3] = "error";
-	toks[4] = "fatal";
-	toks[5] = NULL;
+	toks[4] = "unsupp";
+	toks[5] = "fatal";
+	toks[6] = NULL;
 
 	while (*arg) {
 		o = arg;
 		switch (getsubopt(&arg, UNCONST(toks), &v)) {
-		case (0):
+		case 0:
 			curp->wstop = 1;
 			break;
-		case (1):
-			/* FALLTHROUGH */
-		case (2):
+		case 1:
+		case 2:
 			curp->wlevel = MANDOCLEVEL_WARNING;
 			break;
-		case (3):
+		case 3:
 			curp->wlevel = MANDOCLEVEL_ERROR;
 			break;
-		case (4):
-			curp->wlevel = MANDOCLEVEL_FATAL;
+		case 4:
+			curp->wlevel = MANDOCLEVEL_UNSUPP;
+			break;
+		case 5:
+			curp->wlevel = MANDOCLEVEL_BADARG;
 			break;
 		default:
-			fprintf(stderr, "-W%s: Bad argument\n", o);
-			return(0);
+			warnx("-W %s: Bad argument", o);
+			return 0;
 		}
 	}
 
-	return(1);
+	return 1;
 }
 
-static int
-mmsg(enum mandocerr t, void *arg, int ln, int col, const char *msg)
+static void
+mmsg(enum mandocerr t, enum mandoclevel lvl,
+		const char *file, int line, int col, const char *msg)
 {
-	struct curparse *cp;
-	enum mandoclevel level;
+	const char	*mparse_msg;
+
+	fprintf(stderr, "%s: %s:", __progname, file);
 
-	level = MANDOCLEVEL_FATAL;
-	while (t < mandoclimits[level])
-		/* LINTED */
-		level--;
+	if (line)
+		fprintf(stderr, "%d:%d:", line, col + 1);
 
-	cp = (struct curparse *)arg;
-	if (level < cp->wlevel)
-		return(1);
+	fprintf(stderr, " %s", mparse_strlevel(lvl));
+
+	if (NULL != (mparse_msg = mparse_strerror(t)))
+		fprintf(stderr, ": %s", mparse_msg);
 
-	fprintf(stderr, "%s:%d:%d: %s: %s",
-	    cp->file, ln, col + 1, mandoclevels[level], mandocerrs[t]);
 	if (msg)
 		fprintf(stderr, ": %s", msg);
+
 	fputc('\n', stderr);
+}
+
+static pid_t
+spawn_pager(struct tag_files *tag_files)
+{
+#define MAX_PAGER_ARGS 16
+	char		*argv[MAX_PAGER_ARGS];
+	const char	*pager;
+	char		*cp;
+	size_t		 cmdlen;
+	int		 argc;
+	pid_t		 pager_pid;
+
+	pager = getenv("MANPAGER");
+	if (pager == NULL || *pager == '\0')
+		pager = getenv("PAGER");
+	if (pager == NULL || *pager == '\0')
+		pager = "more -s";
+	cp = mandoc_strdup(pager);
+
+	/*
+	 * Parse the pager command into words.
+	 * Intentionally do not do anything fancy here.
+	 */
+
+	argc = 0;
+	while (argc + 4 < MAX_PAGER_ARGS) {
+		argv[argc++] = cp;
+		cp = strchr(cp, ' ');
+		if (cp == NULL)
+			break;
+		*cp++ = '\0';
+		while (*cp == ' ')
+			cp++;
+		if (*cp == '\0')
+			break;
+	}
+
+	/* For more(1) and less(1), use the tag file. */
+
+	if ((cmdlen = strlen(argv[0])) >= 4) {
+		cp = argv[0] + cmdlen - 4;
+		if (strcmp(cp, "less") == 0 || strcmp(cp, "more") == 0) {
+			argv[argc++] = mandoc_strdup("-T");
+			argv[argc++] = tag_files->tfn;
+		}
+	}
+	argv[argc++] = tag_files->ofn;
+	argv[argc] = NULL;
+
+	switch (pager_pid = fork()) {
+	case -1:
+		err((int)MANDOCLEVEL_SYSERR, "fork");
+	case 0:
+		break;
+	default:
+		return pager_pid;
+	}
+
+	/* The child process becomes the pager. */
 
-	if (file_status < level)
-		file_status = level;
-	
-	return(level < MANDOCLEVEL_FATAL);
+	if (dup2(tag_files->ofd, STDOUT_FILENO) == -1)
+		err((int)MANDOCLEVEL_SYSERR, "pager stdout");
+	close(tag_files->ofd);
+	close(tag_files->tfd);
+	execvp(argv[0], argv);
+	err((int)MANDOCLEVEL_SYSERR, "exec %s", argv[0]);
 }