mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.238 and 1.322

version 1.238, 2015/04/29 11:04:17

version 1.322, 2019/03/06 10:18:58

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

Line 19

#include "config.h"

#include <sys/types.h>

#include <sys/ioctl.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 <termios.h>

#include <time.h>

#include <unistd.h>

#include "mandoc_aux.h"

#include "mandoc.h"

#include "mandoc_xr.h"

#include "roff.h"

#include "mdoc.h"

#include "man.h"

#include "mandoc_parse.h"

#include "tag.h"

#include "main.h"

#include "manconf.h"

#include "mansearch.h"

#if !defined(__GNUC__) || (__GNUC__ < 2)

# if !defined(lint)

# define __attribute__(x)

# endif

#endif /* !defined(__GNUC__) || (__GNUC__ < 2) */

enum outmode {

OUTMODE_DEF = 0,

OUTMODE_FLN,

OUTMODE_LST,

OUTMODE_ALL,

OUTMODE_INT,

OUTMODE_ONE

};

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, /* -Tascii */

OUTT_LOCALE, /* -Tlocale */

Line 69 enum outt {

Line 70 enum outt {

OUTT_TREE, /* -Ttree */

OUTT_MAN, /* -Tman */

OUTT_HTML, /* -Thtml */

OUTT_MARKDOWN, /* -Tmarkdown */

OUTT_LINT, /* -Tlint */

OUTT_PS, /* -Tps */

OUTT_PDF /* -Tpdf */

Line 76 enum outt {

Line 78 enum outt {

struct curparse {

struct mparse *mp;

struct mchars *mchars; /* character table */

struct manoutput *outopts; /* output options */

enum mandoclevel wlevel; /* ignore messages below this */

void *outdata; /* data for output */

char *os_s; /* operating system for display */

int wstop; /* stop after a file with a warning */

enum mandoc_os os_e; /* check base system conventions */

enum outt outtype; /* which output to use */

out_mdoc outmdoc; /* mdoc output ptr */

out_man outman; /* man output ptr */

out_free outfree; /* free output ptr */

void *outdata; /* data for output */

struct manoutput *outopts; /* output options */

};

int mandocdb(int, char *[]);

static void check_xr(void);

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 *,

static int fs_search(const struct mansearch *,

const struct manpaths *, int, char**,

struct manpage **, size_t *);

static void handle_sigpipe(int);

static int koptions(int *, char *);

#if HAVE_SQLITE3

static void moptions(int *, char *);

int mandocdb(int, char**);

static void outdata_alloc(struct curparse *);

#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(void);

static pid_t spawn_pager(struct tag_files *);

static int toptions(struct curparse *, char *);

static void usage(enum argmode) __attribute__((noreturn));

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 const char *progname;

static enum mandoclevel rc;

int

main(int argc, char *argv[])

{

struct manconf conf;

struct curparse curp;

struct mansearch search;

char *auxpaths;

struct curparse curp;

char *defos;

struct winsize ws;

unsigned char *uc;

struct tag_files *tag_files;

struct manpage *res, *resp;

char *conf_file, *defpaths;

const char *progname, *sec, *thisarg;

size_t isec, i, sz;

char *conf_file, *defpaths, *auxpaths;

char *oarg, *tagarg;

unsigned char *uc;

size_t i, sz;

int prio, best_prio;

char sec;

enum mandoclevel rctmp;

enum outmode outmode;

int fd;

int fd, startdir;

int show_usage;

int options;

int use_pager;

int status, signum;

int c;

pid_t pager_pid; /* 0: don't use; 1: not yet spawned. */

pid_t pager_pid, tc_pgid, man_pgid, pid;

#if HAVE_PROGNAME

progname = getprogname();

#else

if (argc < 1)

progname = "mandoc";

progname = mandoc_strdup("mandoc");

else if ((progname = strrchr(argv[0], '/')) == NULL)

progname = argv[0];

else

++progname;

setprogname(progname);

#endif

#if HAVE_SQLITE3

mandoc_msg_setoutfile(stderr);

if (strcmp(progname, BINM_MAKEWHATIS) == 0)

if (strncmp(progname, "mandocdb", 8) == 0 ||

return(mandocdb(argc, argv));

strcmp(progname, BINM_MAKEWHATIS) == 0)

return mandocdb(argc, argv);

#if HAVE_PLEDGE

if (pledge("stdio rpath tmppath tty proc exec", NULL) == -1)

err((int)MANDOCLEVEL_SYSERR, "pledge");

#endif

#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));

Line 158 main(int argc, char *argv[])

Line 171 main(int argc, char *argv[])

memset(&search, 0, sizeof(struct mansearch));

search.outkey = "Nd";

oarg = NULL;

if (strcmp(progname, BINM_MAN) == 0)

search.argmode = ARG_NAME;

Line 174 main(int argc, char *argv[])

Line 188 main(int argc, char *argv[])

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;

pager_pid = 1;

use_pager = 1;

tag_files = NULL;

show_usage = 0;

outmode = OUTMODE_DEF;

while (-1 != (c = getopt(argc, argv,

while ((c = getopt(argc, argv,

"aC:cfhI:iK:klM:m:O:S:s:T:VW:w"))) {

"aC:cfhI:iK:klM:m:O:S:s:T:VW:w")) != -1) {

if (c == 'i' && search.argmode == ARG_EXPR) {

optind--;

break;

}

switch (c) {

case 'a':

outmode = OUTMODE_ALL;

Line 193 main(int argc, char *argv[])

Line 210 main(int argc, char *argv[])

conf_file = optarg;

break;

case 'c':

pager_pid = 0;

use_pager = 0;

break;

case 'f':

search.argmode = ARG_WORD;

break;

case 'h':

conf.output.synopsisonly = 1;

pager_pid = 0;

use_pager = 0;

outmode = OUTMODE_ALL;

break;

case 'I':

if (strncmp(optarg, "os=", 3)) {

fprintf(stderr,

warnx("-I %s: Bad argument", optarg);

"%s: -I %s: Bad argument\n",

return (int)MANDOCLEVEL_BADARG;

progname, optarg);

return((int)MANDOCLEVEL_BADARG);

}

if (defos) {

if (curp.os_s != NULL) {

fprintf(stderr,

warnx("-I %s: Duplicate argument", optarg);

"%s: -I %s: Duplicate argument\n",

return (int)MANDOCLEVEL_BADARG;

progname, optarg);

return((int)MANDOCLEVEL_BADARG);

}

defos = mandoc_strdup(optarg + 3);

curp.os_s = mandoc_strdup(optarg + 3);

break;

case 'i':

outmode = OUTMODE_INT;

break;

case 'K':

if ( ! koptions(&options, optarg))

return((int)MANDOCLEVEL_BADARG);

return (int)MANDOCLEVEL_BADARG;

break;

case 'k':

search.argmode = ARG_EXPR;

Line 239 main(int argc, char *argv[])

Line 249 main(int argc, char *argv[])

auxpaths = optarg;

break;

case 'O':

search.outkey = optarg;

oarg = optarg;

while (optarg != NULL)

manconf_output(&conf.output,

strsep(&optarg, ","));

break;

case 'S':

search.arch = optarg;

Line 252 main(int argc, char *argv[])

Line 259 main(int argc, char *argv[])

break;

case 'T':

if ( ! toptions(&curp, optarg))

return((int)MANDOCLEVEL_BADARG);

return (int)MANDOCLEVEL_BADARG;

break;

case 'W':

if ( ! woptions(&curp, optarg))

return((int)MANDOCLEVEL_BADARG);

return (int)MANDOCLEVEL_BADARG;

break;

case 'w':

outmode = OUTMODE_FLN;

Line 276 main(int argc, char *argv[])

Line 283 main(int argc, char *argv[])

switch (search.argmode) {

case ARG_FILE:

outmode = OUTMODE_ALL;

pager_pid = 0;

use_pager = 0;

break;

case ARG_NAME:

outmode = OUTMODE_ONE;

Line 287 main(int argc, char *argv[])

Line 294 main(int argc, char *argv[])

}

if (oarg != NULL) {

if (outmode == OUTMODE_LST)

search.outkey = oarg;

else {

while (oarg != NULL) {

thisarg = oarg;

if (manconf_output(&conf.output,

strsep(&oarg, ","), 0) == 0)

continue;

warnx("-O %s: Bad argument", thisarg);

return (int)MANDOCLEVEL_BADARG;

}

if (curp.outtype != OUTT_TREE || !curp.outopts->noval)

options |= MPARSE_VALIDATE;

if (outmode == OUTMODE_FLN ||

outmode == OUTMODE_LST ||

!isatty(STDOUT_FILENO))

use_pager = 0;

if (use_pager &&

(conf.output.width == 0 || conf.output.indent == 0) &&

ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) != -1 &&

ws.ws_col > 1) {

if (conf.output.width == 0 && ws.ws_col < 79)

conf.output.width = ws.ws_col - 1;

if (conf.output.indent == 0 && ws.ws_col < 66)

conf.output.indent = 3;

}

#if HAVE_PLEDGE

if (!use_pager)

if (pledge("stdio rpath", NULL) == -1)

err((int)MANDOCLEVEL_SYSERR, "pledge");

#endif

/* Parse arguments. */

if (argc > 0) {

Line 323 main(int argc, char *argv[])

Line 369 main(int argc, char *argv[])

#endif

}

rc = MANDOCLEVEL_OK;

* Use the first argument for -O tag in addition to

* using it as a search term for man(1) or apropos(1).

if (conf.output.tag != NULL && *conf.output.tag == '\0') {

tagarg = argc > 0 && search.argmode == ARG_EXPR ?

strchr(*argv, '=') : NULL;

conf.output.tag = tagarg == NULL ? *argv : tagarg + 1;

}

/* man(1), whatis(1), apropos(1) */

if (search.argmode != ARG_FILE) {

if (argc == 0)

usage(search.argmode);

if (search.argmode == ARG_NAME &&

outmode == OUTMODE_ONE)

search.firstmatch = 1;

Line 338 main(int argc, char *argv[])

Line 390 main(int argc, char *argv[])

/* Access the mandoc database. */

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

if (sz == 0) {

if (sz == 0 && search.argmode == ARG_NAME)

if (search.argmode == ARG_NAME)

fs_search(&search, &conf.manpath,

argc, argv, &res, &sz);

else

if (search.argmode == ARG_NAME) {

fprintf(stderr,

for (c = 0; c < argc; c++) {

"%s: nothing appropriate\n",

if (strchr(argv[c], '/') == NULL)

progname);

continue;

if (access(argv[c], R_OK) == -1) {

warn("%s", argv[c]);

continue;

}

res = mandoc_reallocarray(res,

sz + 1, sizeof(*res));

res[sz].file = mandoc_strdup(argv[c]);

res[sz].names = NULL;

res[sz].output = NULL;

res[sz].ipath = SIZE_MAX;

res[sz].sec = 10;

res[sz].form = FORM_SRC;

sz++;

}

if (sz == 0) {

rc = MANDOCLEVEL_BADARG;

if (search.argmode != ARG_NAME)

warnx("nothing appropriate");

mandoc_msg_setrc(MANDOCLEVEL_BADARG);

goto out;

}

Line 375 main(int argc, char *argv[])

Line 433 main(int argc, char *argv[])

if (outmode == OUTMODE_ONE) {

argc = 1;

best_prio = 10;

best_prio = 20;

} else if (outmode == OUTMODE_ALL)

argc = (int)sz;

Line 391 main(int argc, char *argv[])

Line 449 main(int argc, char *argv[])

res[i].output);

else if (outmode == OUTMODE_ONE) {

/* Search for the best section. */

isec = strcspn(res[i].file, "123456789");

sec = res[i].file;

sec = res[i].file[isec];

sec += strcspn(sec, "123456789");

if ('\0' == sec)

if (sec[0] == '\0')

continue;

prio = sec_prios[sec - '1'];

prio = sec_prios[sec[0] - '1'];

if (sec[1] != '/')

prio += 10;

if (prio >= best_prio)

continue;

best_prio = prio;

Line 415 main(int argc, char *argv[])

Line 475 main(int argc, char *argv[])

/* mandoc(1) */

if (search.argmode == ARG_FILE && ! moptions(&options, auxpaths))

#if HAVE_PLEDGE

return((int)MANDOCLEVEL_BADARG);

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

curp.mchars = mchars_alloc();

if (search.argmode == ARG_FILE)

curp.mp = mparse_alloc(options, curp.wlevel, mmsg,

moptions(&options, auxpaths);

curp.mchars, defos);

mchars_alloc();

* Conditionally start up the lookaside buffer before parsing.

curp.mp = mparse_alloc(options, curp.os_e, curp.os_s);

if (OUTT_MAN == curp.outtype)

mparse_keep(curp.mp);

if (argc < 1) {

if (pager_pid == 1 && isatty(STDOUT_FILENO))

if (use_pager) {

pager_pid = spawn_pager();

tag_files = tag_init();

parse(&curp, STDIN_FILENO, "<stdin>");

tag_files->tagname = conf.output.tag;

}

thisarg = "<stdin>";

mandoc_msg_setinfilename(thisarg);

parse(&curp, STDIN_FILENO, thisarg);

mandoc_msg_setinfilename(NULL);

}

* Remember the original working directory, if possible.

* This will be needed if some names on the command line

* are page names and some are relative file names.

* Do not error out if the current directory is not

* readable: Maybe it won't be needed after all.

startdir = open(".", O_RDONLY | O_DIRECTORY);

while (argc > 0) {

rctmp = mparse_open(curp.mp, &fd,

resp != NULL ? resp->file : *argv);

if (rc < rctmp)

rc = rctmp;

* Changing directories is not needed in ARG_FILE mode.

* Do it on a best-effort basis. Even in case of

* failure, some functionality may still work.

if (resp != NULL) {

if (resp->ipath != SIZE_MAX)

(void)chdir(conf.manpath.paths[resp->ipath]);

else if (startdir != -1)

(void)fchdir(startdir);

thisarg = resp->file;

} else

thisarg = *argv;

fd = mparse_open(curp.mp, thisarg);

if (fd != -1) {

if (pager_pid == 1 && isatty(STDOUT_FILENO))

if (use_pager) {

pager_pid = spawn_pager();

use_pager = 0;

tag_files = tag_init();

tag_files->tagname = conf.output.tag;

}

if (resp == NULL)

mandoc_msg_setinfilename(thisarg);

parse(&curp, fd, *argv);

if (resp == NULL || resp->form == FORM_SRC)

else if (resp->form & FORM_SRC) {

parse(&curp, fd, thisarg);

/* For .so only; ignore failure. */

else

chdir(conf.manpath.paths[resp->ipath]);

parse(&curp, fd, resp->file);

} else

passthrough(resp->file, fd,

conf.output.synopsisonly);

mandoc_msg_setinfilename(NULL);

rctmp = mparse_wait(curp.mp);

if (ferror(stdout)) {

if (rc < rctmp)

if (tag_files != NULL) {

rc = rctmp;

warn("%s", tag_files->ofn);

tag_unlink();

tag_files = NULL;

} else

warn("stdout");

mandoc_msg_setrc(MANDOCLEVEL_SYSERR);

break;

}

if (argc > 1 && curp.outtype <= OUTT_UTF8)

if (argc > 1 && curp.outtype <= OUTT_UTF8) {

ascii_sepline(curp.outdata);

if (curp.outdata == NULL)

}

outdata_alloc(&curp);

terminal_sepline(curp.outdata);

}

} else

mandoc_msg(MANDOCERR_FILE, 0, 0,

"%s: %s", thisarg, strerror(errno));

if (MANDOCLEVEL_OK != rc && curp.wstop)

if (curp.wstop && mandoc_msg_getrc() != MANDOCLEVEL_OK)

break;

if (resp != NULL)

Line 472 main(int argc, char *argv[])

Line 573 main(int argc, char *argv[])

if (--argc)

mparse_reset(curp.mp);

}

if (startdir != -1) {

(void)fchdir(startdir);

close(startdir);

}

if (curp.outfree)

if (curp.outdata != NULL) {

(*curp.outfree)(curp.outdata);

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;

}

mandoc_xr_free();

mparse_free(curp.mp);

mchars_free(curp.mchars);

mchars_free();

out:

if (search.argmode != ARG_FILE) {

manconf_free(&conf);

#if HAVE_SQLITE3

mansearch_free(res, sz);

mansearch_setup(0);

#endif

}

free(defos);

free(curp.os_s);

* If a pager is attached, flush the pipe leading to it

* When using a pager, finish writing both temporary files,

* and signal end of file such that the user can browse

* fork it, wait for the user to close it, and clean up.

* to the end. Then wait for the user to close the pager.

if (pager_pid != 0 && pager_pid != 1) {

if (tag_files != NULL) {

fclose(stdout);

waitpid(pager_pid, NULL, 0);

tag_write();

}

man_pgid = getpgid(0);

tag_files->tcpgid = man_pgid == getpid() ?

getpgid(getppid()) : man_pgid;

pager_pid = 0;

signum = SIGSTOP;

for (;;) {

return((int)rc);

/* 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;

}

/* Once in the foreground, activate the pager. */

if (pager_pid) {

(void)tcsetpgrp(tag_files->ofd, pager_pid);

kill(pager_pid, SIGCONT);

} else

pager_pid = spawn_pager(tag_files);

/* Wait for the pager to stop or exit. */

while ((pid = waitpid(pager_pid, &status,

WUNTRACED)) == -1 && errno == EINTR)

continue;

if (pid == -1) {

warn("wait");

mandoc_msg_setrc(MANDOCLEVEL_SYSERR);

break;

}

if (!WIFSTOPPED(status))

break;

signum = WSTOPSIG(status);

}

tag_unlink();

}

return (int)mandoc_msg_getrc();

}

static void

Line 509 usage(enum argmode argmode)

Line 673 usage(enum argmode argmode)

switch (argmode) {

case ARG_FILE:

fputs("usage: mandoc [-acfhkl] [-I os=name] "

fputs("usage: mandoc [-ac] [-I os=name] "

"[-K encoding] [-mformat] [-O option]\n"

"[-K encoding] [-mdoc | -man] [-O options]\n"

"\t [-T output] [-W level] [file ...]\n", stderr);

break;

case ARG_NAME:

fputs("usage: man [-acfhklw] [-C file] [-I os=name] "

fputs("usage: man [-acfhklw] [-C file] [-M path] "

"[-K encoding] [-M path] [-m path]\n"

"[-m path] [-S subsection]\n"

"\t [-O option=value] [-S subsection] [-s section] "

"\t [[-s] section] name ...\n", stderr);

"[-T output] [-W level]\n"

"\t [section] name ...\n", stderr);

break;

case ARG_WORD:

fputs("usage: whatis [-acfhklw] [-C file] "

fputs("usage: whatis [-afk] [-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] "

fputs("usage: apropos [-afk] [-C file] "

"[-M path] [-m path] [-O outkey] [-S arch]\n"

"\t [-s section] expression ...\n", stderr);

break;

Line 542 fs_lookup(const struct manpaths *paths, size_t ipath,

Line 704 fs_lookup(const struct manpaths *paths, size_t ipath,

glob_t globinfo;

struct manpage *page;

char *file;

int form, globres;

int globres;

enum form form;

form = FORM_SRC;

mandoc_asprintf(&file, "%s/man%s/%s.%s",

Line 567 fs_lookup(const struct manpaths *paths, size_t ipath,

Line 730 fs_lookup(const struct manpaths *paths, size_t ipath,

free(file);

}

mandoc_asprintf(&file, "%s/man%s/%s.*",

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)

fprintf(stderr, "%s: %s: glob: %s\n",

warn("%s: glob", file);

progname, file, strerror(errno));

free(file);

if (globres == 0)

file = mandoc_strdup(*globinfo.gl_pathv);

globfree(&globinfo);

if (globres != 0)

if (globres == 0)

return(0);

goto found;

if (res != NULL || ipath + 1 != paths->sz)

return 0;

mandoc_asprintf(&file, "%s.%s", name, sec);

globres = access(file, R_OK);

free(file);

return globres != -1;

found:

#if HAVE_SQLITE3

warnx("outdated mandoc.db lacks %s(%s) entry, run %s %s",

fprintf(stderr, "%s: outdated mandoc.db lacks %s(%s) entry, run "

name, sec, BINM_MAKEWHATIS, paths->paths[ipath]);

"makewhatis %s\n", progname, name, sec, paths->paths[ipath]);

if (res == NULL) {

#endif

free(file);

return 1;

}

*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);

return 1;

}

static void

static int

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"};

{"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;

if (res != NULL)

*res = NULL;

*ressz = lastsz = 0;

while (argc) {

for (ipath = 0; ipath < paths->sz; ipath++) {

Line 617 fs_search(const struct mansearch *cfg, const struct ma

Line 788 fs_search(const struct mansearch *cfg, const struct ma

if (fs_lookup(paths, ipath, cfg->sec,

cfg->arch, *argv, res, ressz) &&

cfg->firstmatch)

return;

return 1;

} else for (isec = 0; isec < nsec; isec++)

if (fs_lookup(paths, ipath, sections[isec],

cfg->arch, *argv, res, ressz) &&

cfg->firstmatch)

return;

return 1;

}

if (*ressz == lastsz)

if (res != NULL && *ressz == lastsz &&

fprintf(stderr,

strchr(*argv, '/') == NULL) {

"%s: No entry for %s in the manual.\n",

if (cfg->arch != NULL &&

progname, *argv);

arch_valid(cfg->arch, OSENUM) == 0)

warnx("Unknown architecture \"%s\".",

cfg->arch);

else if (cfg->sec == NULL)

warnx("No entry for %s in the manual.",

*argv);

else

warnx("No entry for %s in section %s "

"of the manual.", *argv, cfg->sec);

}

lastsz = *ressz;

argv++;

argc--;

}

return 0;

}

static void

parse(struct curparse *curp, int fd, const char *file)

{

enum mandoclevel rctmp;

struct roff_meta *meta;

struct roff_man *man;

/* Begin by parsing the file itself. */

assert(file);

assert(fd >= -1);

assert(fd >= 0);

rctmp = mparse_readfd(curp->mp, fd, file);

mparse_readfd(curp->mp, fd, file);

if (rc < rctmp)

if (fd != STDIN_FILENO)

rc = rctmp;

close(fd);

* With -Wstop and warnings or errors of at least the requested

* level, do not produce output.

if (rctmp != MANDOCLEVEL_OK && curp->wstop)

if (curp->wstop && mandoc_msg_getrc() != MANDOCLEVEL_OK)

return;

/* If unset, allocate output dev now (if applicable). */

if (curp->outdata == NULL)

outdata_alloc(curp);

else if (curp->outtype == OUTT_HTML)

html_reset(curp);

if ( ! (curp->outman && curp->outmdoc)) {

mandoc_xr_reset();

meta = mparse_result(curp->mp);

/* Execute the out device, if it exists. */

if (meta->macroset == MACROSET_MDOC) {

switch (curp->outtype) {

case OUTT_HTML:

curp->outdata = html_alloc(curp->mchars,

html_mdoc(curp->outdata, meta);

curp->outopts);

curp->outfree = html_free;

break;

case OUTT_UTF8:

case OUTT_TREE:

curp->outdata = utf8_alloc(curp->mchars,

tree_mdoc(curp->outdata, meta);

curp->outopts);

curp->outfree = ascii_free;

break;

case OUTT_LOCALE:

case OUTT_MAN:

curp->outdata = locale_alloc(curp->mchars,

man_mdoc(curp->outdata, meta);

curp->outopts);

curp->outfree = ascii_free;

break;

case OUTT_ASCII:

curp->outdata = ascii_alloc(curp->mchars,

curp->outopts);

curp->outfree = ascii_free;

break;

case OUTT_PDF:

curp->outdata = pdf_alloc(curp->mchars,

case OUTT_ASCII:

curp->outopts);

case OUTT_UTF8:

curp->outfree = pspdf_free;

case OUTT_LOCALE:

break;

case OUTT_PS:

curp->outdata = ps_alloc(curp->mchars,

terminal_mdoc(curp->outdata, meta);

curp->outopts);

curp->outfree = pspdf_free;

break;

case OUTT_MARKDOWN:

markdown_mdoc(curp->outdata, meta);

break;

default:

break;

}

if (meta->macroset == MACROSET_MAN) {

switch (curp->outtype) {

case OUTT_HTML:

curp->outman = html_man;

html_man(curp->outdata, meta);

curp->outmdoc = html_mdoc;

break;

case OUTT_TREE:

curp->outman = tree_man;

tree_man(curp->outdata, meta);

curp->outmdoc = tree_mdoc;

break;

case OUTT_MAN:

curp->outmdoc = man_mdoc;

mparse_copy(curp->mp);

curp->outman = man_man;

break;

case OUTT_PDF:

/* FALLTHROUGH */

case OUTT_ASCII:

/* FALLTHROUGH */

case OUTT_UTF8:

/* FALLTHROUGH */

case OUTT_LOCALE:

/* FALLTHROUGH */

case OUTT_PS:

curp->outman = terminal_man;

terminal_man(curp->outdata, meta);

curp->outmdoc = terminal_mdoc;

break;

default:

break;

}

if (mandoc_msg_getmin() < MANDOCERR_STYLE)

check_xr();

}

mparse_result(curp->mp, &man, NULL);

static void

check_xr(void)

{

static struct manpaths paths;

struct mansearch search;

struct mandoc_xr *xr;

size_t sz;

/* Execute the out device, if it exists. */

if (paths.sz == 0)

manpath_base(&paths);

if (man == NULL)

for (xr = mandoc_xr_get(); xr != NULL; xr = xr->next) {

return;

if (xr->line == -1)

if (curp->outmdoc != NULL && man->macroset == MACROSET_MDOC)

continue;

(*curp->outmdoc)(curp->outdata, man);

search.arch = NULL;

if (curp->outman != NULL && man->macroset == MACROSET_MAN)

search.sec = xr->sec;

(*curp->outman)(curp->outdata, man);

search.outkey = NULL;

search.argmode = ARG_NAME;

search.firstmatch = 1;

if (mansearch(&search, &paths, 1, &xr->name, NULL, &sz))

continue;

if (fs_search(&search, &paths, 1, &xr->name, NULL, &sz))

continue;

if (xr->count == 1)

mandoc_msg(MANDOCERR_XR_BAD, xr->line,

xr->pos + 1, "Xr %s %s", xr->name, xr->sec);

else

mandoc_msg(MANDOCERR_XR_BAD, xr->line,

xr->pos + 1, "Xr %s %s (%d times)",

xr->name, xr->sec, xr->count);

}

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";

Line 745 passthrough(const char *file, int fd, int synopsis_onl

Line 966 passthrough(const char *file, int fd, int synopsis_onl

FILE *stream;

const char *syscall;

char *line;

char *line, *cp;

size_t len, off;

size_t linesz;

ssize_t nw;

ssize_t len, written;

int print;

fflush(stdout);

line = NULL;

linesz = 0;

if (fflush(stdout) == EOF) {

syscall = "fflush";

goto fail;

}

if ((stream = fdopen(fd, "r")) == NULL) {

close(fd);

syscall = "fdopen";

Line 759 passthrough(const char *file, int fd, int synopsis_onl

Line 986 passthrough(const char *file, int fd, int synopsis_onl

}

print = 0;

while ((line = fgetln(stream, &len)) != NULL) {

while ((len = getline(&line, &linesz, stream)) != -1) {

cp = line;

if (synopsis_only) {

if (print) {

if ( ! isspace((unsigned char)*line))

if ( ! isspace((unsigned char)*cp))

goto done;

while (len &&

while (isspace((unsigned char)*cp)) {

isspace((unsigned char)*line)) {

cp++;

line++;

len--;

}

} else {

if ((len == sizeof(synb) &&

if (strcmp(cp, synb) == 0 ||

! strncmp(line, synb, len - 1)) ||

strcmp(cp, synr) == 0)

(len == sizeof(synr) &&

! strncmp(line, synr, len - 1)))

print = 1;

continue;

}

for (off = 0; off < len; off += nw)

for (; len > 0; len -= written) {

if ((nw = write(STDOUT_FILENO, line + off,

if ((written = write(STDOUT_FILENO, cp, len)) != -1)

len - off)) == -1 || nw == 0) {

continue;

fclose(stream);

syscall = "write";

goto fail;

}

if (ferror(stream)) {

fclose(stream);

syscall = "fgetln";

syscall = "getline";

goto fail;

}

done:

free(line);

fclose(stream);

return;

fail:

fprintf(stderr, "%s: %s: SYSERR: %s: %s",

free(line);

progname, file, syscall, strerror(errno));

warn("%s: SYSERR: %s", file, syscall);

if (rc < MANDOCLEVEL_SYSERR)

mandoc_msg_setrc(MANDOCLEVEL_SYSERR);

rc = MANDOCLEVEL_SYSERR;

}

static int

Line 817 koptions(int *options, char *arg)

Line 1042 koptions(int *options, char *arg)

} else if ( ! strcmp(arg, "us-ascii")) {

*options &= ~(MPARSE_UTF8 | MPARSE_LATIN1);

} else {

fprintf(stderr, "%s: -K %s: Bad argument\n",

warnx("-K %s: Bad argument", arg);

progname, arg);

return 0;

return(0);

}

return(1);

return 1;

}

static int

static void

moptions(int *options, char *arg)

{

if (arg == NULL)

/* nothing to do */;

return;

else if (0 == strcmp(arg, "doc"))

if (strcmp(arg, "doc") == 0)

*options |= MPARSE_MDOC;

else if (0 == strcmp(arg, "andoc"))

else if (strcmp(arg, "an") == 0)

/* nothing to do */;

else if (0 == strcmp(arg, "an"))

*options |= MPARSE_MAN;

else {

fprintf(stderr, "%s: -m %s: Bad argument\n",

progname, arg);

return(0);

}

return(1);

}

static int

Line 853 toptions(struct curparse *curp, char *arg)

Line 1068 toptions(struct curparse *curp, char *arg)

curp->outtype = OUTT_ASCII;

else if (0 == strcmp(arg, "lint")) {

curp->outtype = OUTT_LINT;

curp->wlevel = MANDOCLEVEL_WARNING;

mandoc_msg_setoutfile(stdout);

mandoc_msg_setmin(MANDOCERR_BASE);

} 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, "markdown"))

curp->outtype = OUTT_MARKDOWN;

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 {

fprintf(stderr, "%s: -T %s: Bad argument\n",

warnx("-T %s: Bad argument", arg);

progname, arg);

return 0;

return(0);

}

return(1);

return 1;

}

static int

woptions(struct curparse *curp, char *arg)

{

char *v, *o;

const char *toks[7];

const char *toks[11];

toks[0] = "stop";

toks[1] = "all";

toks[2] = "warning";

toks[2] = "base";

toks[3] = "error";

toks[3] = "style";

toks[4] = "unsupp";

toks[4] = "warning";

toks[5] = "fatal";

toks[5] = "error";

toks[6] = NULL;

toks[6] = "unsupp";

toks[7] = "fatal";

toks[8] = "openbsd";

toks[9] = "netbsd";

toks[10] = NULL;

while (*arg) {

o = arg;

switch (getsubopt(&arg, UNCONST(toks), &v)) {

switch (getsubopt(&arg, (char * const *)toks, &v)) {

case 0:

curp->wstop = 1;

break;

case 1:

/* FALLTHROUGH */

case 2:

curp->wlevel = MANDOCLEVEL_WARNING;

mandoc_msg_setmin(MANDOCERR_BASE);

break;

case 3:

curp->wlevel = MANDOCLEVEL_ERROR;

mandoc_msg_setmin(MANDOCERR_STYLE);

break;

case 4:

curp->wlevel = MANDOCLEVEL_UNSUPP;

mandoc_msg_setmin(MANDOCERR_WARNING);

break;

case 5:

curp->wlevel = MANDOCLEVEL_BADARG;

mandoc_msg_setmin(MANDOCERR_ERROR);

break;

case 6:

mandoc_msg_setmin(MANDOCERR_UNSUPP);

break;

case 7:

mandoc_msg_setmin(MANDOCERR_MAX);

break;

case 8:

mandoc_msg_setmin(MANDOCERR_BASE);

curp->os_e = MANDOC_OS_OPENBSD;

break;

case 9:

mandoc_msg_setmin(MANDOCERR_BASE);

curp->os_e = MANDOC_OS_NETBSD;

break;

default:

fprintf(stderr, "%s: -W %s: Bad argument\n",

warnx("-W %s: Bad argument", o);

progname, o);

return 0;

return(0);

}

return 1;

return(1);

}

static void

mmsg(enum mandocerr t, enum mandoclevel lvl,

const char *file, int line, int col, const char *msg)

{

const char *mparse_msg;

fprintf(stderr, "%s: %s:", progname, file);

if (line)

fprintf(stderr, "%d:%d:", line, col + 1);

fprintf(stderr, " %s", mparse_strlevel(lvl));

if (NULL != (mparse_msg = mparse_strerror(t)))

fprintf(stderr, ": %s", mparse_msg);

if (msg)

fprintf(stderr, ": %s", msg);

fputc('\n', stderr);

}

static void

handle_sigpipe(int signum)

{

exit((int)rc);

}

static pid_t

spawn_pager(void)

spawn_pager(struct tag_files *tag_files)

{

const struct timespec timeout = { 0, 100000000 }; /* 0.1s */

#define MAX_PAGER_ARGS 16

char *argv[MAX_PAGER_ARGS];

const char *pager;

char *cp;

int fildes[2];

#if HAVE_LESS_T

int argc;

size_t cmdlen;

#endif

int argc, use_ofn;

pid_t pager_pid;

if (pipe(fildes) == -1) {

fprintf(stderr, "%s: pipe: %s\n",

progname, strerror(errno));

return(0);

}

switch (pager_pid = fork()) {

case -1:

fprintf(stderr, "%s: fork: %s\n",

progname, strerror(errno));

exit((int)MANDOCLEVEL_SYSERR);

case 0:

break;

default:

close(fildes[0]);

if (dup2(fildes[1], STDOUT_FILENO) == -1) {

fprintf(stderr, "%s: dup output: %s\n",

progname, strerror(errno));

exit((int)MANDOCLEVEL_SYSERR);

}

close(fildes[1]);

signal(SIGPIPE, handle_sigpipe);

return(pager_pid);

}

/* The child process becomes the pager. */

close(fildes[1]);

if (dup2(fildes[0], STDIN_FILENO) == -1) {

fprintf(stderr, "%s: dup input: %s\n",

progname, strerror(errno));

exit((int)MANDOCLEVEL_SYSERR);

}

close(fildes[0]);

pager = getenv("MANPAGER");

if (pager == NULL || *pager == '\0')

pager = getenv("PAGER");

Line 1011 spawn_pager(void)

Line 1180 spawn_pager(void)

argc = 0;

while (argc + 1 < MAX_PAGER_ARGS) {

while (argc + 5 < MAX_PAGER_ARGS) {

argv[argc++] = cp;

cp = strchr(cp, ' ');

if (cp == NULL)

Line 1022 spawn_pager(void)

Line 1191 spawn_pager(void)

if (*cp == '\0')

break;

}

/* For less(1), use the tag file. */

use_ofn = 1;

#if HAVE_LESS_T

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;

if (tag_files->tagname != NULL) {

argv[argc++] = mandoc_strdup("-t");

argv[argc++] = tag_files->tagname;

use_ofn = 0;

}

#endif

if (use_ofn)

argv[argc++] = tag_files->ofn;

argv[argc] = NULL;

/* Hand over to the pager. */

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);

assert(tag_files->tfd == -1);

/* Do not start the pager before controlling the terminal. */

while (tcgetpgrp(STDOUT_FILENO) != getpid())

nanosleep(&timeout, NULL);

execvp(argv[0], argv);

fprintf(stderr, "%s: exec %s: %s\n",

err((int)MANDOCLEVEL_SYSERR, "exec %s", argv[0]);

progname, argv[0], strerror(errno));

exit((int)MANDOCLEVEL_SYSERR);

}

CVSweb