X-Git-Url: https://git.cameronkatri.com/mandoc.git/blobdiff_plain/9c62a1979e3ea0f278835a15164bf139d2c68fd1..f2d5fc1266321e25b50efaea4fd8a9db1e174038:/main.c?ds=sidebyside

diff --git a/main.c b/main.c
index 67779506..1b1b5b73 100644
--- a/main.c
+++ b/main.c
@@ -1,484 +1,1108 @@
-/* $Id: main.c,v 1.5 2009/03/20 19:56:25 kristaps Exp $ */
+/*	$Id: main.c,v 1.280 2017/01/27 13:47:10 schwarze Exp $ */
 /*
- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
+ * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2010-2012, 2014-2017 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.
+ * 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 AUTHORS DISCLAIM ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * 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.
  */
-#include <sys/stat.h>
+#include "config.h"
+
+#include <sys/types.h>
+#include <sys/param.h>	/* MACHINE */
+#include <sys/wait.h>
 
 #include <assert.h>
+#include <ctype.h>
+#if HAVE_ERR
 #include <err.h>
+#endif
+#include <errno.h>
 #include <fcntl.h>
+#include <glob.h>
+#if HAVE_SANDBOX_INIT
+#include <sandbox.h>
+#endif
+#include <signal.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 
+#include "mandoc_aux.h"
+#include "mandoc.h"
+#include "roff.h"
 #include "mdoc.h"
-
-#ifdef __linux__
-extern	int		  getsubopt(char **, char * const *, char **);
-# ifndef __dead
-#  define __dead __attribute__((__noreturn__))
-# endif
-#endif
-
-struct	buf {
-	char	 	 *buf;
-	size_t		  sz;
+#include "man.h"
+#include "tag.h"
+#include "main.h"
+#include "manconf.h"
+#include "mansearch.h"
+
+enum	outmode {
+	OUTMODE_DEF = 0,
+	OUTMODE_FLN,
+	OUTMODE_LST,
+	OUTMODE_ALL,
+	OUTMODE_INT,
+	OUTMODE_ONE
 };
 
-struct	curparse {
-	const char	 *file;
-	int		  wflags;
-#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. */
+enum	outt {
+	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 */
 };
 
-enum outt {
-	OUTT_ASCII,
-	OUTT_LATIN1,
-	OUTT_UTF8,
-	OUTT_TREE,
-	OUTT_LINT
+struct	curparse {
+	struct mparse	 *mp;
+	enum mandoclevel  wlevel;	/* ignore messages below this */
+	int		  wstop;	/* stop after a file with a warning */
+	enum outt	  outtype;	/* which output to use */
+	void		 *outdata;	/* data for output */
+	struct manoutput *outopts;	/* output options */
 };
 
-typedef	int		(*out_run)(void *, const struct mdoc *);
-typedef	void		(*out_free)(void *);
 
-extern	char		 *__progname;
-
-extern	void		 *ascii_alloc(void);
-extern	void		 *latin1_alloc(void);
-extern	void		 *utf8_alloc(void);
-extern	int		  terminal_run(void *, const struct mdoc *);
-extern	int		  tree_run(void *, const struct mdoc *);
-extern	void		  terminal_free(void *);
-
-__dead	static void	  version(void);
-__dead	static void	  usage(void);
-static	int		  foptions(int *, char *);
-static	int		  toptions(enum outt *, 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	int		  file(struct buf *, struct buf *,
-				const char *, struct mdoc *);
-static	int		  fdesc(struct buf *, struct buf *,
-				const char *, int, struct mdoc *);
+int			  mandocdb(int, char *[]);
+
+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 *);
+static	int		  moptions(int *, char *);
+static	void		  mmsg(enum mandocerr, enum mandoclevel,
+				const char *, int, int, const char *);
+static	void		  outdata_alloc(struct curparse *);
+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(enum argmode) __attribute__((noreturn));
+static	int		  woptions(struct curparse *, char *);
+
+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, rc, fflags, wflags;
-	struct mdoc_cb	 cb;
-	struct mdoc	*mdoc;
-	void		*outdata;
-	enum outt	 outtype;
-	struct buf	 ln, blk;
-	out_run		 outrun;
-	out_free	 outfree;
+	struct manconf	 conf;
 	struct curparse	 curp;
+	struct mansearch search;
+	struct tag_files *tag_files;
+	const char	*progname;
+	char		*auxpaths;
+	char		*defos;
+	unsigned char	*uc;
+	struct manpage	*res, *resp;
+	char		*conf_file, *defpaths;
+	const char	*sec;
+	const char	*thisarg;
+	size_t		 i, sz;
+	int		 prio, best_prio;
+	enum outmode	 outmode;
+	int		 fd;
+	int		 show_usage;
+	int		 options;
+	int		 use_pager;
+	int		 status, signum;
+	int		 c;
+	pid_t		 pager_pid, tc_pgid, man_pgid, pid;
+
+#if HAVE_PROGNAME
+	progname = getprogname();
+#else
+	if (argc < 1)
+		progname = mandoc_strdup("mandoc");
+	else if ((progname = strrchr(argv[0], '/')) == NULL)
+		progname = argv[0];
+	else
+		++progname;
+	setprogname(progname);
+#endif
 
-	fflags = wflags = 0;
-	outtype = OUTT_ASCII;
+	if (strncmp(progname, "mandocdb", 8) == 0 ||
+	    strcmp(progname, BINM_MAKEWHATIS) == 0)
+		return mandocdb(argc, argv);
 
-	bzero(&curp, sizeof(struct curparse));
+#if HAVE_PLEDGE
+	if (pledge("stdio rpath tmppath tty proc exec flock", NULL) == -1)
+		err((int)MANDOCLEVEL_SYSERR, "pledge");
+#endif
 
-	/* LINTED */
-	while (-1 != (c = getopt(argc, argv, "f:VW:T:")))
+#if HAVE_SANDBOX_INIT
+	if (sandbox_init(kSBXProfileNoInternet, SANDBOX_NAMED, NULL) == -1)
+		errx((int)MANDOCLEVEL_SYSERR, "sandbox_init");
+#endif
+
+	/* Search options. */
+
+	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 ('f'):
-			if ( ! foptions(&fflags, optarg))
-				return(0);
+		case 'a':
+			outmode = OUTMODE_ALL;
+			break;
+		case 'C':
+			conf_file = optarg;
 			break;
-		case ('T'):
-			if ( ! toptions(&outtype, optarg))
-				return(0);
+		case 'c':
+			use_pager = 0;
+			break;
+		case 'f':
+			search.argmode = ARG_WORD;
+			break;
+		case 'h':
+			conf.output.synopsisonly = 1;
+			use_pager = 0;
+			outmode = OUTMODE_ALL;
+			break;
+		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) {
+				thisarg = optarg;
+				if (manconf_output(&conf.output,
+				    strsep(&optarg, ","), 0) == 0)
+					continue;
+				warnx("-O %s: Bad argument", thisarg);
+				return (int)MANDOCLEVEL_BADARG;
+			}
 			break;
-		case ('W'):
-			if ( ! woptions(&curp.wflags, optarg))
-				return(0);
+		case 'S':
+			search.arch = optarg;
+			break;
+		case 's':
+			search.sec = optarg;
+			break;
+		case 'T':
+			if ( ! toptions(&curp, optarg))
+				return (int)MANDOCLEVEL_BADARG;
+			break;
+		case 'W':
+			if ( ! woptions(&curp, optarg))
+				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 (show_usage)
+		usage(search.argmode);
 
-	/*
-	 * Allocate the appropriate front-end.  Note that utf8, ascii
-	 * and latin1 all resolve to the terminal front-end with
-	 * different encodings (see terminal.c).  Not all frontends have
-	 * cleanup or alloc routines.
-	 */
+	/* Postprocess options. */
 
-	switch (outtype) {
-	case (OUTT_LATIN1):
-		outdata = latin1_alloc();
-		outrun = terminal_run;
-		outfree = terminal_free;
-		break;
-	case (OUTT_UTF8):
-		outdata = utf8_alloc();
-		outrun = terminal_run;
-		outfree = terminal_free;
-		break;
-	case (OUTT_TREE):
-		outdata = NULL;
-		outrun = tree_run;
-		outfree = NULL;
-		break;
-	case (OUTT_LINT):
-		outdata = NULL;
-		outrun = NULL;
-		outfree = NULL;
-		break;
-	default:
-		outdata = ascii_alloc();
-		outrun = terminal_run;
-		outfree = terminal_free;
-		break;
+	if (outmode == OUTMODE_DEF) {
+		switch (search.argmode) {
+		case ARG_FILE:
+			outmode = OUTMODE_ALL;
+			use_pager = 0;
+			break;
+		case ARG_NAME:
+			outmode = OUTMODE_ONE;
+			break;
+		default:
+			outmode = OUTMODE_LST;
+			break;
+		}
 	}
 
-	/*
-	 * All callbacks route into here, where we print them onto the
-	 * screen.  XXX - for now, no path for debugging messages.
-	 */
+	if (outmode == OUTMODE_FLN ||
+	    outmode == OUTMODE_LST ||
+	    !isatty(STDOUT_FILENO))
+		use_pager = 0;
 
-	cb.mdoc_msg = NULL;
-	cb.mdoc_err = merr;
-	cb.mdoc_warn = mwarn;
+#if HAVE_PLEDGE
+	if (!use_pager)
+		if (pledge("stdio rpath flock", NULL) == -1)
+			err((int)MANDOCLEVEL_SYSERR, "pledge");
+#endif
 
-	bzero(&ln, sizeof(struct buf));
-	bzero(&blk, sizeof(struct buf));
+	/* Parse arguments. */
 
-	mdoc = mdoc_alloc(&curp, fflags, &cb);
+	if (argc > 0) {
+		argc -= optind;
+		argv += optind;
+	}
+	resp = NULL;
 
 	/*
-	 * Loop around available files.
+	 * Quirks for help(1)
+	 * and for a man(1) section argument without -s.
 	 */
 
-	if (NULL == *argv) {
-		curp.file = "<stdin>";
-		c = fdesc(&blk, &ln, "stdin", STDIN_FILENO, mdoc);
-		rc = 0;
-		if (c && NULL == outrun)
-			rc = 1;
-		else if (c && outrun && (*outrun)(outdata, mdoc))
-			rc = 1;
-	} else {
-		while (*argv) {
-			curp.file = *argv;
-			c = file(&blk, &ln, *argv, mdoc);
-			if ( ! c)
-				break;
-			if (outrun && ! (*outrun)(outdata, mdoc))
-				break;
-			/* Reset the parser for another file. */
-			mdoc_reset(mdoc);
+	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--;
 		}
-		rc = NULL == *argv;
+		if (search.arch == NULL)
+			search.arch = getenv("MACHINE");
+#ifdef MACHINE
+		if (search.arch == NULL)
+			search.arch = MACHINE;
+#endif
 	}
 
-	if (blk.buf)
-		free(blk.buf);
-	if (ln.buf)
-		free(ln.buf);
-	if (outfree)
-		(*outfree)(outdata);
+	rc = MANDOCLEVEL_OK;
 
-	mdoc_free(mdoc);
-
-	return(rc ? EXIT_SUCCESS : EXIT_FAILURE);
-}
+	/* man(1), whatis(1), apropos(1) */
 
+	if (search.argmode != ARG_FILE) {
+		if (search.argmode == ARG_NAME &&
+		    outmode == OUTMODE_ONE)
+			search.firstmatch = 1;
 
-__dead static void
-version(void)
-{
+		/* Access the mandoc database. */
 
-	(void)printf("%s %s\n", __progname, VERSION);
-	exit(0);
-	/* NOTREACHED */
-}
+		manconf_parse(&conf, conf_file, defpaths, auxpaths);
+		if ( ! mansearch(&search, &conf.manpath,
+		    argc, argv, &res, &sz))
+			usage(search.argmode);
 
+		if (sz == 0) {
+			if (search.argmode == ARG_NAME)
+				fs_search(&search, &conf.manpath,
+				    argc, argv, &res, &sz);
+			else
+				warnx("nothing appropriate");
+		}
 
-__dead static void
-usage(void)
-{
-
-	(void)fprintf(stderr, "usage: %s\n", __progname);
-	exit(1);
-	/* NOTREACHED */
-}
+		if (sz == 0) {
+			rc = MANDOCLEVEL_BADARG;
+			goto out;
+		}
 
+		/*
+		 * 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 = 20;
+		} 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. */
+				sec = res[i].file;
+				sec += strcspn(sec, "123456789");
+				if (sec[0] == '\0')
+					continue;
+				prio = sec_prios[sec[0] - '1'];
+				if (sec[1] != '/')
+					prio += 10;
+				if (prio >= best_prio)
+					continue;
+				best_prio = prio;
+				resp = res + i;
+			}
+		}
 
-static int
-file(struct buf *blk, struct buf *ln,
-		const char *file, struct mdoc *mdoc)
-{
-	int		 fd, c;
+		/*
+		 * 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.
+		 */
 
-	if (-1 == (fd = open(file, O_RDONLY, 0))) {
-		warn("%s", file);
-		return(0);
+		if (outmode == OUTMODE_FLN || outmode == OUTMODE_LST)
+			goto out;
 	}
 
-	c = fdesc(blk, ln, file, fd, mdoc);
-
-	if (-1 == close(fd))
-		warn("%s", file);
+	/* mandoc(1) */
 
-	return(c);
-}
+#if HAVE_PLEDGE
+	if (use_pager) {
+		if (pledge("stdio rpath tmppath tty proc exec", NULL) == -1)
+			err((int)MANDOCLEVEL_SYSERR, "pledge");
+	} else {
+		if (pledge("stdio rpath", NULL) == -1)
+			err((int)MANDOCLEVEL_SYSERR, "pledge");
+	}
+#endif
 
+	if (search.argmode == ARG_FILE && ! moptions(&options, auxpaths))
+		return (int)MANDOCLEVEL_BADARG;
 
-static int
-fdesc(struct buf *blk, struct buf *ln,
-		const char *f, int fd, struct mdoc *mdoc)
-{
-	size_t		 sz;
-	ssize_t		 ssz;
-	struct stat	 st;
-	int		 j, i, pos, lnn;
+	mchars_alloc();
+	curp.mp = mparse_alloc(options, curp.wlevel, mmsg, defos);
 
 	/*
-	 * 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.
+	 * Conditionally start up the lookaside buffer before parsing.
 	 */
+	if (OUTT_MAN == curp.outtype)
+		mparse_keep(curp.mp);
 
-	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 > blk->sz) {
-		blk->buf = realloc(blk->buf, sz);
-		if (NULL == blk->buf)
-			err(1, "realloc");
-		blk->sz = sz;
+	if (argc < 1) {
+		if (use_pager)
+			tag_files = tag_init();
+		parse(&curp, STDIN_FILENO, "<stdin>");
 	}
 
-	/*
-	 * Fill buf with file blocksize and parse newlines into ln.
-	 */
+	while (argc > 0) {
+		fd = mparse_open(curp.mp, resp != NULL ? resp->file : *argv);
+		if (fd != -1) {
+			if (use_pager) {
+				tag_files = tag_init();
+				use_pager = 0;
+			}
 
-	for (lnn = 1, pos = 0; ; ) {
-		if (-1 == (ssz = read(fd, blk->buf, sz))) {
-			warn("%s", f);
-			return(0);
-		} else if (0 == ssz) 
+			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) {
+				if (curp.outdata == NULL)
+					outdata_alloc(&curp);
+				terminal_sepline(curp.outdata);
+			}
+		} else if (rc < MANDOCLEVEL_ERROR)
+			rc = MANDOCLEVEL_ERROR;
+
+		if (MANDOCLEVEL_OK != rc && curp.wstop)
 			break;
 
-		for (i = 0; i < (int)ssz; i++) {
-			if (pos >= (int)ln->sz) {
-				ln->sz += 256; /* Step-size. */
-				ln->buf = realloc(ln->buf, ln->sz);
-				if (NULL == ln->buf)
-					err(1, "realloc");
-			}
+		if (resp != NULL)
+			resp++;
+		else
+			argv++;
+		if (--argc)
+			mparse_reset(curp.mp);
+	}
+
+	if (curp.outdata != NULL) {
+		switch (curp.outtype) {
+		case OUTT_HTML:
+			html_free(curp.outdata);
+			break;
+		case OUTT_UTF8:
+		case OUTT_LOCALE:
+		case OUTT_ASCII:
+			ascii_free(curp.outdata);
+			break;
+		case OUTT_PDF:
+		case OUTT_PS:
+			pspdf_free(curp.outdata);
+			break;
+		default:
+			break;
+		}
+	}
+	mparse_free(curp.mp);
+	mchars_free();
+
+out:
+	if (search.argmode != ARG_FILE) {
+		manconf_free(&conf);
+		mansearch_free(res, sz);
+	}
+
+	free(defos);
+
+	/*
+	 * When using a pager, finish writing both temporary files,
+	 * fork it, wait for the user to close it, and clean up.
+	 */
 
-			if ('\n' != blk->buf[i]) {
-				ln->buf[pos++] = blk->buf[i];
+	if (tag_files != NULL) {
+		fclose(stdout);
+		tag_write();
+		man_pgid = getpgid(0);
+		tag_files->tcpgid = man_pgid == getpid() ?
+		    getpgid(getppid()) : man_pgid;
+		pager_pid = 0;
+		signum = SIGSTOP;
+		for (;;) {
+
+			/* Stop here until moved to the foreground. */
+
+			tc_pgid = tcgetpgrp(tag_files->ofd);
+			if (tc_pgid != man_pgid) {
+				if (tc_pgid == pager_pid) {
+					(void)tcsetpgrp(tag_files->ofd,
+					    man_pgid);
+					if (signum == SIGTTIN)
+						continue;
+				} else
+					tag_files->tcpgid = tc_pgid;
+				kill(0, signum);
 				continue;
 			}
 
-			/* Check for CPP-escaped newline.  */
+			/* Once in the foreground, activate the pager. */
 
-			if (pos > 0 && '\\' == ln->buf[pos - 1]) {
-				for (j = pos - 1; j >= 0; j--)
-					if ('\\' != ln->buf[j])
-						break;
+			if (pager_pid) {
+				(void)tcsetpgrp(tag_files->ofd, pager_pid);
+				kill(pager_pid, SIGCONT);
+			} else
+				pager_pid = spawn_pager(tag_files);
 
-				if ( ! ((pos - j) % 2)) {
-					pos--;
-					lnn++;
-					continue;
-				}
+			/* Wait for the pager to stop or exit. */
+
+			while ((pid = waitpid(pager_pid, &status,
+			    WUNTRACED)) == -1 && errno == EINTR)
+				continue;
+
+			if (pid == -1) {
+				warn("wait");
+				rc = MANDOCLEVEL_SYSERR;
+				break;
 			}
+			if (!WIFSTOPPED(status))
+				break;
 
-			ln->buf[pos] = 0;
-			if ( ! mdoc_parseln(mdoc, lnn, ln->buf))
-				return(0);
-			lnn++;
-			pos = 0;
+			signum = WSTOPSIG(status);
 		}
+		tag_unlink();
 	}
 
-	return(mdoc_endparse(mdoc));
+	return (int)rc;
 }
 
+static void
+usage(enum argmode argmode)
+{
+
+	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);
+}
 
 static int
-toptions(enum outt *tflags, char *arg)
+fs_lookup(const struct manpaths *paths, size_t ipath,
+	const char *sec, const char *arch, const char *name,
+	struct manpage **res, size_t *ressz)
 {
-
-	if (0 == strcmp(arg, "ascii"))
-		*tflags = OUTT_ASCII;
-	else if (0 == strcmp(arg, "latin1"))
-		*tflags = OUTT_LATIN1;
-	else if (0 == strcmp(arg, "utf8"))
-		*tflags = OUTT_UTF8;
-	else if (0 == strcmp(arg, "lint"))
-		*tflags = OUTT_LINT;
-	else if (0 == strcmp(arg, "tree"))
-		*tflags = OUTT_TREE;
-	else {
-		warnx("bad argument: -T%s", arg);
-		return(0);
+	glob_t		 globinfo;
+	struct manpage	*page;
+	char		*file;
+	int		 globres;
+	enum form	 form;
+
+	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);
 	}
 
-	return(1);
+	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:
+	warnx("outdated mandoc.db lacks %s(%s) entry, run %s %s",
+	    name, sec, BINM_MAKEWHATIS, paths->paths[ipath]);
+	*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;
 }
 
+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", "5", "7", "4", "9", "3p"};
+	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--;
+	}
+}
 
-/*
- * Parse out the options for [-fopt...] setting compiler options.  These
- * can be comma-delimited or called again.
- */
-static int
-foptions(int *fflags, char *arg)
+static void
+parse(struct curparse *curp, int fd, const char *file)
 {
-	char		*v;
-	char		*toks[4];
+	enum mandoclevel  rctmp;
+	struct roff_man	 *man;
 
-	toks[0] = "ign-scope";
-	toks[1] = "ign-escape";
-	toks[2] = "ign-macro";
-	toks[3] = NULL;
+	/* Begin by parsing the file itself. */
 
-	while (*arg) 
-		switch (getsubopt(&arg, toks, &v)) {
-		case (0):
-			*fflags |= MDOC_IGN_SCOPE;
+	assert(file);
+	assert(fd >= 0);
+
+	rctmp = mparse_readfd(curp->mp, fd, file);
+	if (fd != STDIN_FILENO)
+		close(fd);
+	if (rc < rctmp)
+		rc = rctmp;
+
+	/*
+	 * With -Wstop and warnings or errors of at least the requested
+	 * level, do not produce output.
+	 */
+
+	if (rctmp != MANDOCLEVEL_OK && curp->wstop)
+		return;
+
+	if (curp->outdata == NULL)
+		outdata_alloc(curp);
+
+	mparse_result(curp->mp, &man, NULL);
+
+	/* Execute the out device, if it exists. */
+
+	if (man == NULL)
+		return;
+	if (man->macroset == MACROSET_MDOC) {
+		mdoc_validate(man);
+		switch (curp->outtype) {
+		case OUTT_HTML:
+			html_mdoc(curp->outdata, man);
 			break;
-		case (1):
-			*fflags |= MDOC_IGN_ESCAPE;
+		case OUTT_TREE:
+			tree_mdoc(curp->outdata, man);
 			break;
-		case (2):
-			*fflags |= MDOC_IGN_MACRO;
+		case OUTT_MAN:
+			man_mdoc(curp->outdata, man);
+			break;
+		case OUTT_PDF:
+		case OUTT_ASCII:
+		case OUTT_UTF8:
+		case OUTT_LOCALE:
+		case OUTT_PS:
+			terminal_mdoc(curp->outdata, man);
 			break;
 		default:
-			warnx("bad argument: -f%s", arg);
-			return(0);
+			break;
 		}
+	}
+	if (man->macroset == MACROSET_MAN) {
+		man_validate(man);
+		switch (curp->outtype) {
+		case OUTT_HTML:
+			html_man(curp->outdata, man);
+			break;
+		case OUTT_TREE:
+			tree_man(curp->outdata, man);
+			break;
+		case OUTT_MAN:
+			man_man(curp->outdata, man);
+			break;
+		case OUTT_PDF:
+		case OUTT_ASCII:
+		case OUTT_UTF8:
+		case OUTT_LOCALE:
+		case OUTT_PS:
+			terminal_man(curp->outdata, man);
+			break;
+		default:
+			break;
+		}
+	}
+	mparse_updaterc(curp->mp, &rc);
+}
 
-	return(1);
+static void
+outdata_alloc(struct curparse *curp)
+{
+	switch (curp->outtype) {
+	case OUTT_HTML:
+		curp->outdata = html_alloc(curp->outopts);
+		break;
+	case OUTT_UTF8:
+		curp->outdata = utf8_alloc(curp->outopts);
+		break;
+	case OUTT_LOCALE:
+		curp->outdata = locale_alloc(curp->outopts);
+		break;
+	case OUTT_ASCII:
+		curp->outdata = ascii_alloc(curp->outopts);
+		break;
+	case OUTT_PDF:
+		curp->outdata = pdf_alloc(curp->outopts);
+		break;
+	case OUTT_PS:
+		curp->outdata = ps_alloc(curp->outopts);
+		break;
+	default:
+		break;
+	}
 }
 
+static void
+passthrough(const char *file, int fd, int synopsis_only)
+{
+	const char	 synb[] = "S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS";
+	const char	 synr[] = "SYNOPSIS";
+
+	FILE		*stream;
+	const char	*syscall;
+	char		*line, *cp;
+	size_t		 linesz;
+	ssize_t		 len, written;
+	int		 print;
+
+	line = NULL;
+	linesz = 0;
+
+	if (fflush(stdout) == EOF) {
+		syscall = "fflush";
+		goto fail;
+	}
+
+	if ((stream = fdopen(fd, "r")) == NULL) {
+		close(fd);
+		syscall = "fdopen";
+		goto fail;
+	}
+
+	print = 0;
+	while ((len = getline(&line, &linesz, stream)) != -1) {
+		cp = line;
+		if (synopsis_only) {
+			if (print) {
+				if ( ! isspace((unsigned char)*cp))
+					goto done;
+				while (isspace((unsigned char)*cp)) {
+					cp++;
+					len--;
+				}
+			} else {
+				if (strcmp(cp, synb) == 0 ||
+				    strcmp(cp, synr) == 0)
+					print = 1;
+				continue;
+			}
+		}
+		for (; len > 0; len -= written) {
+			if ((written = write(STDOUT_FILENO, cp, len)) != -1)
+				continue;
+			fclose(stream);
+			syscall = "write";
+			goto fail;
+		}
+	}
+
+	if (ferror(stream)) {
+		fclose(stream);
+		syscall = "getline";
+		goto fail;
+	}
+
+done:
+	free(line);
+	fclose(stream);
+	return;
+
+fail:
+	free(line);
+	warn("%s: SYSERR: %s", file, syscall);
+	if (rc < MANDOCLEVEL_SYSERR)
+		rc = MANDOCLEVEL_SYSERR;
+}
 
-/* 
- * Parse out the options for [-Werr...], which sets warning modes.
- * These can be comma-delimited or called again.  
- */
 static int
-woptions(int *wflags, char *arg)
+koptions(int *options, char *arg)
 {
-	char		*v;
-	char		*toks[5]; 
 
-	toks[0] = "all";
-	toks[1] = "compat";
-	toks[2] = "syntax";
-	toks[3] = "error";
-	toks[4] = NULL;
+	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;
+	}
+	return 1;
+}
+
+static int
+moptions(int *options, char *arg)
+{
+
+	if (arg == NULL)
+		/* nothing to do */;
+	else if (0 == strcmp(arg, "doc"))
+		*options |= MPARSE_MDOC;
+	else if (0 == strcmp(arg, "andoc"))
+		/* nothing to do */;
+	else if (0 == strcmp(arg, "an"))
+		*options |= MPARSE_MAN;
+	else {
+		warnx("-m %s: Bad argument", arg);
+		return 0;
+	}
+
+	return 1;
+}
+
+static int
+toptions(struct curparse *curp, char *arg)
+{
+
+	if (0 == strcmp(arg, "ascii"))
+		curp->outtype = OUTT_ASCII;
+	else if (0 == strcmp(arg, "lint")) {
+		curp->outtype = OUTT_LINT;
+		curp->wlevel  = MANDOCLEVEL_WARNING;
+	} 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_HTML;
+	else if (0 == strcmp(arg, "ps"))
+		curp->outtype = OUTT_PS;
+	else if (0 == strcmp(arg, "pdf"))
+		curp->outtype = OUTT_PDF;
+	else {
+		warnx("-T %s: Bad argument", arg);
+		return 0;
+	}
+
+	return 1;
+}
+
+static int
+woptions(struct curparse *curp, char *arg)
+{
+	char		*v, *o;
+	const char	*toks[7];
 
-	while (*arg) 
-		switch (getsubopt(&arg, toks, &v)) {
-		case (0):
-			*wflags |= WARN_WALL;
+	toks[0] = "stop";
+	toks[1] = "all";
+	toks[2] = "warning";
+	toks[3] = "error";
+	toks[4] = "unsupp";
+	toks[5] = "fatal";
+	toks[6] = NULL;
+
+	while (*arg) {
+		o = arg;
+		switch (getsubopt(&arg, (char * const *)toks, &v)) {
+		case 0:
+			curp->wstop = 1;
+			break;
+		case 1:
+		case 2:
+			curp->wlevel = MANDOCLEVEL_WARNING;
 			break;
-		case (1):
-			*wflags |= WARN_WCOMPAT;
+		case 3:
+			curp->wlevel = MANDOCLEVEL_ERROR;
 			break;
-		case (2):
-			*wflags |= WARN_WSYNTAX;
+		case 4:
+			curp->wlevel = MANDOCLEVEL_UNSUPP;
 			break;
-		case (3):
-			*wflags |= WARN_WERR;
+		case 5:
+			curp->wlevel = MANDOCLEVEL_BADARG;
 			break;
 		default:
-			warnx("bad argument: -W%s", arg);
-			return(0);
+			warnx("-W %s: Bad argument", o);
+			return 0;
 		}
+	}
 
-	return(1);
+	return 1;
 }
 
-
-/* ARGSUSED */
-static int
-merr(void *arg, int line, 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 *curp;
+	const char	*mparse_msg;
 
-	curp = (struct curparse *)arg;
+	fprintf(stderr, "%s: %s:", getprogname(),
+	    file == NULL ? "<stdin>" : file);
 
-	warnx("%s:%d: error: %s (column %d)", 
-			curp->file, line, msg, col);
-	return(0);
-}
+	if (line)
+		fprintf(stderr, "%d:%d:", line, col + 1);
 
+	fprintf(stderr, " %s", mparse_strlevel(lvl));
 
-static int
-mwarn(void *arg, int line, int col, 
-		enum mdoc_warn type, const char *msg)
+	if (NULL != (mparse_msg = mparse_strerror(t)))
+		fprintf(stderr, ": %s", mparse_msg);
+
+	if (msg)
+		fprintf(stderr, ": %s", msg);
+
+	fputc('\n', stderr);
+}
+
+static pid_t
+spawn_pager(struct tag_files *tag_files)
 {
-	struct curparse *curp;
-	char		*wtype;
+	const struct timespec timeout = { 0, 100000000 };  /* 0.1s */
+#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);
 
-	curp = (struct curparse *)arg;
-	wtype = NULL;
+	/*
+	 * Parse the pager command into words.
+	 * Intentionally do not do anything fancy here.
+	 */
 
-	switch (type) {
-	case (WARN_COMPAT):
-		wtype = "compat";
-		if (curp->wflags & WARN_WCOMPAT)
+	argc = 0;
+	while (argc + 4 < MAX_PAGER_ARGS) {
+		argv[argc++] = cp;
+		cp = strchr(cp, ' ');
+		if (cp == NULL)
 			break;
-		return(1);
-	case (WARN_SYNTAX):
-		wtype = "syntax";
-		if (curp->wflags & WARN_WSYNTAX)
+		*cp++ = '\0';
+		while (*cp == ' ')
+			cp++;
+		if (*cp == '\0')
 			break;
-		return(1);
 	}
 
-	assert(wtype);
-	warnx("%s:%d: %s warning: %s (column %d)", 
-			curp->file, line, wtype, msg, col);
+	/* For less(1), use the tag file. */
 
-	if ( ! (curp->wflags & WARN_WERR))
-		return(1);
+	if ((cmdlen = strlen(argv[0])) >= 4) {
+		cp = argv[0] + cmdlen - 4;
+		if (strcmp(cp, "less") == 0) {
+			argv[argc++] = mandoc_strdup("-T");
+			argv[argc++] = tag_files->tfn;
+		}
+	}
+	argv[argc++] = tag_files->ofn;
+	argv[argc] = NULL;
 
-	warnx("%s: considering warnings as errors", 
-			__progname);
-	return(0);
-}
+	switch (pager_pid = fork()) {
+	case -1:
+		err((int)MANDOCLEVEL_SYSERR, "fork");
+	case 0:
+		break;
+	default:
+		(void)setpgid(pager_pid, 0);
+		(void)tcsetpgrp(tag_files->ofd, pager_pid);
+#if HAVE_PLEDGE
+		if (pledge("stdio rpath tmppath tty proc", NULL) == -1)
+			err((int)MANDOCLEVEL_SYSERR, "pledge");
+#endif
+		tag_files->pager_pid = pager_pid;
+		return pager_pid;
+	}
+
+	/* The child process becomes the pager. */
 
+	if (dup2(tag_files->ofd, STDOUT_FILENO) == -1)
+		err((int)MANDOCLEVEL_SYSERR, "pager stdout");
+	close(tag_files->ofd);
+	close(tag_files->tfd);
 
+	/* Do not start the pager before controlling the terminal. */
+
+	while (tcgetpgrp(STDOUT_FILENO) != getpid())
+		nanosleep(&timeout, NULL);
+
+	execvp(argv[0], argv);
+	err((int)MANDOCLEVEL_SYSERR, "exec %s", argv[0]);
+}