mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

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

version 1.226, 2015/03/17 07:33:07

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

Line 8

* 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

Line 34

#include <string.h>

#include <unistd.h>

#include "mandoc.h"

#include "mandoc_aux.h"

#include "main.h"

#include "mandoc.h"

#include "roff.h"

#include "mdoc.h"

#include "man.h"

#include "manpath.h"

#include "main.h"

#include "manconf.h"

#include "mansearch.h"

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

Line 57 enum outmode {

Line 58 enum outmode {

OUTMODE_ONE

};

typedef void (*out_mdoc)(void *, const struct mdoc *);

typedef void (*out_mdoc)(void *, const struct roff_man *);

typedef void (*out_man)(void *, const struct man *);

typedef void (*out_man)(void *, const struct roff_man *);

typedef void (*out_free)(void *);

enum outt {

Line 83 struct curparse {

Line 84 struct curparse {

out_man outman; /* man output ptr */

out_free outfree; /* free output ptr */

void *outdata; /* data for output */

char outopts[BUFSIZ]; /* buf of output opts */

struct manoutput *outopts; /* output options */

};

static int fs_lookup(const struct manpaths *,

Line 101 int mandocdb(int, char**);

Line 102 int mandocdb(int, char**);

static int moptions(int *, char *);

static void mmsg(enum mandocerr, enum mandoclevel,

const char *, int, int, const char *);

static void parse(struct curparse *, int,

static void parse(struct curparse *, int, const char *);

const char *, enum mandoclevel *);

static void passthrough(const char *, int, int);

static enum mandoclevel passthrough(const char *, int, int);

static pid_t spawn_pager(void);

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

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

Line 119 static enum mandoclevel rc;

int

main(int argc, char *argv[])

{

struct manconf conf;

struct curparse curp;

struct mansearch search;

struct manpaths paths;

char *auxpaths;

char *defos;

unsigned char *uc;

struct manpage *res, *resp;

char *conf_file, *defpaths;

size_t isec, i, sz;

int prio, best_prio, synopsis_only;

int prio, best_prio;

char sec;

enum mandoclevel rctmp;

enum outmode outmode;

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

/* Search options. */

memset(&paths, 0, sizeof(struct manpaths));

memset(&conf, 0, sizeof(conf));

conf_file = defpaths = NULL;

auxpaths = NULL;

Line 175 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;

show_usage = 0;

synopsis_only = 0;

outmode = OUTMODE_DEF;

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

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

search.argmode = ARG_WORD;

break;

case 'h':

(void)strlcat(curp.outopts, "synopsis,", BUFSIZ);

conf.output.synopsisonly = 1;

synopsis_only = 1;

pager_pid = 0;

outmode = OUTMODE_ALL;

break;

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

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

break;

case 'O':

search.outkey = optarg;

(void)strlcat(curp.outopts, optarg, BUFSIZ);

while (optarg != NULL)

(void)strlcat(curp.outopts, ",", BUFSIZ);

manconf_output(&conf.output,

strsep(&optarg, ","));

break;

case 'S':

search.arch = optarg;

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

/* Access the mandoc database. */

manpath_parse(&paths, conf_file, defpaths, auxpaths);

manconf_parse(&conf, conf_file, defpaths, auxpaths);

#if HAVE_SQLITE3

mansearch_setup(1);

if( ! mansearch(&search, &paths, argc, argv, &res, &sz))

if ( ! mansearch(&search, &conf.manpath,

argc, argv, &res, &sz))

usage(search.argmode);

#else

if (search.argmode != ARG_NAME) {

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

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

sz = 0;

#endif

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

if (sz == 0) {

fs_search(&search, &paths, argc, argv, &res, &sz);

if (search.argmode == ARG_NAME)

fs_search(&search, &conf.manpath,

argc, argv, &res, &sz);

else

fprintf(stderr,

"%s: nothing appropriate\n",

progname);

}

if (sz == 0) {

rc = MANDOCLEVEL_BADARG;

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

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

if (argc < 1) {

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

pager_pid = spawn_pager();

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

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

}

while (argc > 0) {

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

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

pager_pid = spawn_pager();

if (resp == NULL)

parse(&curp, fd, *argv, &rc);

parse(&curp, fd, *argv);

else if (resp->form & FORM_SRC) {

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

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

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

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

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

} else {

} else

rctmp = passthrough(resp->file, fd,

passthrough(resp->file, fd,

synopsis_only);

conf.output.synopsisonly);

if (rc < rctmp)

rc = rctmp;

}

rctmp = mparse_wait(curp.mp);

if (rc < rctmp)

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

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

out:

if (search.argmode != ARG_FILE) {

manpath_free(&paths);

manconf_free(&conf);

#if HAVE_SQLITE3

mansearch_free(res, sz);

mansearch_setup(0);

Line 504 usage(enum argmode argmode)

Line 509 usage(enum argmode argmode)

switch (argmode) {

case ARG_FILE:

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

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

"[-Kencoding] [-mformat] [-Ooption]\n"

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

"\t [-Toutput] [-Wlevel] [file ...]\n", stderr);

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

break;

case ARG_NAME:

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

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

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

found:

#if HAVE_SQLITE3

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

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

" consider running # makewhatis %s\n",

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

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

#endif

*res = mandoc_reallocarray(*res, ++*ressz, sizeof(struct manpage));

page = *res + (*ressz - 1);

page->file = file;

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

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

}

static void

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

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

enum mandoclevel *level)

{

enum mandoclevel rc;

enum mandoclevel rctmp;

struct mdoc *mdoc;

struct roff_man *man;

struct man *man;

/* Begin by parsing the file itself. */

assert(file);

assert(fd >= -1);

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

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.

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

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

goto cleanup;

return;

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

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

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

}

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

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

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

if (man && curp->outman)

if (man == NULL)

return;

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

if (mdoc && curp->outmdoc)

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

cleanup:

if (*level < rc)

*level = rc;

}

static enum mandoclevel

static void

passthrough(const char *file, int fd, int synopsis_only)

{

const char synb[] = "S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS";

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

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

done:

fclose(stream);

return(MANDOCLEVEL_OK);

return;

fail:

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

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

return(MANDOCLEVEL_SYSERR);

if (rc < MANDOCLEVEL_SYSERR)

rc = MANDOCLEVEL_SYSERR;

}

static int

Line 947 static void

Line 949 static void

handle_sigpipe(int signum)

{

exit(rc);

exit((int)rc);

}

static pid_t

Line 1000 spawn_pager(void)

Line 1002 spawn_pager(void)

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

pager = getenv("PAGER");

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

pager = "/usr/bin/more -s";

pager = "more -s";

cp = mandoc_strdup(pager);

Line 1025 spawn_pager(void)

Line 1027 spawn_pager(void)

/* Hand over to the pager. */

execvp(argv[0], argv);

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

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

progname, strerror(errno));

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

exit((int)MANDOCLEVEL_SYSERR);

}

CVSweb