mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.224 and 1.229

version 1.224, 2015/03/10 03:02:28

version 1.229, 2015/03/27 17:37:25

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 27

#include <errno.h>

#include <fcntl.h>

#include <glob.h>

#include <signal.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

Line 38

Line 39

#include "main.h"

#include "mdoc.h"

#include "man.h"

#include "manpath.h"

#include "manconf.h"

#include "mansearch.h"

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

Line 92 static int fs_lookup(const struct manpaths *,

Line 93 static int fs_lookup(const struct manpaths *,

static void 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

int mandocdb(int, char**);

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

Line 101 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 void spawn_pager(void);

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

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

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

Line 111 static const int sec_prios[] = {1, 4, 5, 8, 6, 3, 7, 2

Line 112 static const int sec_prios[] = {1, 4, 5, 8, 6, 3, 7, 2

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;

struct manpaths paths;

char *auxpaths;

char *defos;

unsigned char *uc;

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

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

size_t isec, i, sz;

int prio, best_prio, synopsis_only;

char sec;

enum mandoclevel rc, rctmp;

enum mandoclevel rctmp;

enum outmode outmode;

int fd;

int show_usage;

int use_pager;

int options;

int c;

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

if (argc < 1)

progname = "mandoc";

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

Line 151 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[])

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

options = MPARSE_SO | MPARSE_UTF8 | MPARSE_LATIN1;

defos = NULL;

use_pager = 1;

pager_pid = 1;

show_usage = 0;

synopsis_only = 0;

outmode = OUTMODE_DEF;

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

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

conf_file = optarg;

break;

case 'c':

use_pager = 0;

pager_pid = 0;

break;

case 'f':

search.argmode = ARG_WORD;

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

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

case 'h':

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

synopsis_only = 1;

use_pager = 0;

pager_pid = 0;

outmode = OUTMODE_ALL;

break;

case 'I':

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

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

switch (search.argmode) {

case ARG_FILE:

outmode = OUTMODE_ALL;

use_pager = 0;

pager_pid = 0;

break;

case ARG_NAME:

outmode = OUTMODE_ONE;

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

Line 336 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 349 main(int argc, char *argv[])

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

#endif

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

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

fs_search(&search, &conf.manpath,

argc, argv, &res, &sz);

if (sz == 0) {

rc = MANDOCLEVEL_BADARG;

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

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

mparse_keep(curp.mp);

if (argc < 1) {

if (use_pager && isatty(STDOUT_FILENO))

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

spawn_pager();

pager_pid = spawn_pager();

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

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

}

while (argc > 0) {

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

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

rc = rctmp;

if (fd != -1) {

if (use_pager && isatty(STDOUT_FILENO))

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

spawn_pager();

pager_pid = spawn_pager();

use_pager = 0;

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

synopsis_only);

if (rc < rctmp)

rc = rctmp;

}

rctmp = mparse_wait(curp.mp);

if (rc < rctmp)

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

Line 472 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 483 out:

Line 482 out:

free(defos);

* Flush the output and signal end of file.

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

* If a pager is attached, it allows browsing to the end.

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

* Otherwise, it does no harm, we are about to exit anyway.

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

fclose(stdout);

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

fclose(stdout);

waitpid(pager_pid, NULL, 0);

}

* If we spawned a pager, wait for the user to close it.

* Otherwise, this call fails with no adverse effect.

wait(NULL);

return((int)rc);

}

Line 506 usage(enum argmode argmode)

Line 501 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 634 fs_search(const struct mansearch *cfg, const struct ma

Line 629 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 man *man;

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

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

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 732 parse(struct curparse *curp, int fd, const char *file,

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

(*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 796 passthrough(const char *file, int fd, int synopsis_onl

Line 788 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 946 mmsg(enum mandocerr t, enum mandoclevel lvl,

Line 939 mmsg(enum mandocerr t, enum mandoclevel lvl,

}

static void

handle_sigpipe(int signum)

{

exit((int)rc);

}

static pid_t

spawn_pager(void)

{

#define MAX_PAGER_ARGS 16

Line 954 spawn_pager(void)

char *cp;

int fildes[2];

int argc;

pid_t pager_pid;

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

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

progname, strerror(errno));

return;

return(0);

}

switch (fork()) {

switch (pager_pid = fork()) {

case -1:

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

progname, strerror(errno));

Line 976 spawn_pager(void)

Line 977 spawn_pager(void)

exit((int)MANDOCLEVEL_SYSERR);

}

close(fildes[1]);

return;

signal(SIGPIPE, handle_sigpipe);

return(pager_pid);

}

/* The child process becomes the pager. */

CVSweb