mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.169 and 1.181

version 1.169, 2014/01/06 00:53:33

version 1.181, 2014/08/20 21:04:35

Line 1

/* $Id$ */

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

Line 16

* 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/types.h>

#include <assert.h>

#include <stdio.h>

#include <stdint.h>

Line 28

#include <unistd.h>

#include "mandoc.h"

#include "mandoc_aux.h"

#include "main.h"

#include "mdoc.h"

#include "man.h"

#include "manpath.h"

#include "mansearch.h"

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

# if !defined(lint)

Line 38

Line 41

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

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

typedef void (*out_free)(void *);

Line 59 struct curparse {

Line 71 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 */

out_mdoc outmdoc; /* mdoc 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 int moptions(enum mparset *, 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,

const char *, enum mandoclevel *);

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

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

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

static void version(void) __attribute__((noreturn));

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

static const char *progname;

int

main(int argc, char *argv[])

{

int c;

struct curparse curp;

enum mparset type;

struct mansearch search;

enum mandoclevel rc;

struct manpaths paths;

char *conf_file, *defpaths, *auxpaths;

char *defos;

#if HAVE_SQLITE3

struct manpage *res;

size_t i, sz;

#endif

enum mandoclevel rc;

enum outmode outmode;

int show_usage;

int options;

int c;

progname = strrchr(argv[0], '/');

if (progname == NULL)

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

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

else

++progname;

memset(&curp, 0, sizeof(struct curparse));

/* Search options. */

type = MPARSE_AUTO;

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

conf_file = defpaths = auxpaths = NULL;

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

search.outkey = "Nd";

if (strcmp(progname, "man") == 0)

search.argmode = ARG_NAME;

else if (strncmp(progname, "apropos", 7) == 0)

search.argmode = ARG_EXPR;

else if (strncmp(progname, "whatis", 6) == 0)

search.argmode = ARG_WORD;

else

search.argmode = ARG_FILE;

/* Parser and formatter options. */

memset(&curp, 0, sizeof(struct curparse));

curp.outtype = OUTT_ASCII;

curp.wlevel = MANDOCLEVEL_FATAL;

options = MPARSE_SO;

defos = NULL;

/* LINTED */

show_usage = 0;

while (-1 != (c = getopt(argc, argv, "I:m:O:T:VW:")))

outmode = OUTMODE_DEF;

while (-1 != (c = getopt(argc, argv, "aC:fI:ikM:m:O:S:s:T:VW:w"))) {

switch (c) {

case ('I'):

case 'a':

outmode = OUTMODE_ALL;

break;

case 'C':

conf_file = optarg;

break;

case 'f':

search.argmode = ARG_WORD;

break;

case 'I':

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

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

fprintf(stderr,

optarg);

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

progname, optarg);

return((int)MANDOCLEVEL_BADARG);

}

if (defos) {

fprintf(stderr, "-I%s: Duplicate argument\n",

fprintf(stderr,

optarg);

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

progname, optarg);

return((int)MANDOCLEVEL_BADARG);

}

defos = mandoc_strdup(optarg + 3);

break;

case ('m'):

case 'i':

if ( ! moptions(&type, optarg))

outmode = OUTMODE_INT;

return((int)MANDOCLEVEL_BADARG);

break;

case ('O'):

case 'k':

search.argmode = ARG_EXPR;

break;

case 'M':

defpaths = optarg;

break;

case 'm':

auxpaths = optarg;

break;

case 'O':

search.outkey = optarg;

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

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

break;

case ('T'):

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'):

case 'W':

if ( ! woptions(&curp, optarg))

return((int)MANDOCLEVEL_BADARG);

break;

case ('V'):

case 'w':

outmode = OUTMODE_FLN;

break;

case 'V':

version();

/* NOTREACHED */

default:

usage();

show_usage = 1;

/* NOTREACHED */

break;

}

curp.mp = mparse_alloc(type, curp.wlevel, mmsg, defos, 0);

if (show_usage)

usage(search.argmode);

if (outmode == OUTMODE_DEF) {

switch (search.argmode) {

case ARG_FILE:

outmode = OUTMODE_ALL;

break;

case ARG_NAME:

outmode = OUTMODE_ONE;

break;

default:

outmode = OUTMODE_LST;

break;

}

argc -= optind;

argv += optind;

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

if (search.argmode != ARG_FILE) {

#if HAVE_SQLITE3

if (argc == 0)

usage(search.argmode);

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

mansearch_setup(1);

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

usage(search.argmode);

manpath_free(&paths);

for (i = 0; i < sz; i++) {

if (outmode == OUTMODE_FLN)

puts(res[i].file);

else

printf("%s - %s\n", res[i].names,

res[i].output == NULL ? "" :

res[i].output);

}

mansearch_free(res, sz);

mansearch_setup(0);

return((int)MANDOCLEVEL_OK);

#else

fputs("mandoc: database support not compiled in\n",

stderr);

return((int)MANDOCLEVEL_BADARG);

#endif

}

/* mandoc(1) */

if ( ! moptions(&options, auxpaths))

return((int)MANDOCLEVEL_BADARG);

curp.mp = mparse_alloc(options, curp.wlevel, mmsg, defos);

* Conditionally start up the lookaside buffer before parsing.

if (OUTT_MAN == curp.outtype)

mparse_keep(curp.mp);

argc -= optind;

argv += optind;

rc = MANDOCLEVEL_OK;

if (NULL == *argv)

Line 177 static void

Line 299 static void

version(void)

{

printf("%s %s\n", progname, VERSION);

printf("mandoc %s\n", VERSION);

exit((int)MANDOCLEVEL_OK);

}

static void

usage(void)

usage(enum argmode argmode)

{

fprintf(stderr, "usage: %s "

switch (argmode) {

"[-V] "

case ARG_FILE:

"[-Ios=name] "

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

"[-mformat] "

" [-Ooption] [-Toutput] [-Wlevel]\n"

"[-Ooption] "

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

"[-Toutput] "

break;

"[-Wlevel]\n"

case ARG_NAME:

"\t [file ...]\n",

fputs("usage: man [-acfhkVw] [-C file] "

progname);

"[-M path] [-m path] [-S arch] [-s section]\n"

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

break;

case ARG_WORD:

fputs("usage: whatis [-V] [-C file] [-M path] [-m path] "

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

break;

case ARG_EXPR:

fputs("usage: apropos [-V] [-C file] [-M path] [-m path] "

"[-O outkey] [-S arch]\n"

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

break;

}

exit((int)MANDOCLEVEL_BADARG);

}

static void

parse(struct curparse *curp, int fd,

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

const char *file, enum mandoclevel *level)

enum mandoclevel *level)

{

enum mandoclevel rc;

struct mdoc *mdoc;

Line 230 parse(struct curparse *curp, int fd,

Line 363 parse(struct curparse *curp, int fd,

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

switch (curp->outtype) {

case (OUTT_XHTML):

case OUTT_XHTML:

curp->outdata = xhtml_alloc(curp->outopts);

curp->outfree = html_free;

break;

case (OUTT_HTML):

case OUTT_HTML:

curp->outdata = html_alloc(curp->outopts);

curp->outfree = html_free;

break;

case (OUTT_UTF8):

case OUTT_UTF8:

curp->outdata = utf8_alloc(curp->outopts);

curp->outfree = ascii_free;

break;

case (OUTT_LOCALE):

case OUTT_LOCALE:

curp->outdata = locale_alloc(curp->outopts);

curp->outfree = ascii_free;

break;

case (OUTT_ASCII):

case OUTT_ASCII:

curp->outdata = ascii_alloc(curp->outopts);

curp->outfree = ascii_free;

break;

case (OUTT_PDF):

case OUTT_PDF:

curp->outdata = pdf_alloc(curp->outopts);

curp->outfree = pspdf_free;

break;

case (OUTT_PS):

case OUTT_PS:

curp->outdata = ps_alloc(curp->outopts);

curp->outfree = pspdf_free;

break;

Line 263 parse(struct curparse *curp, int fd,

Line 396 parse(struct curparse *curp, int fd,

}

switch (curp->outtype) {

case (OUTT_HTML):

case OUTT_HTML:

/* FALLTHROUGH */

case (OUTT_XHTML):

case OUTT_XHTML:

curp->outman = html_man;

curp->outmdoc = html_mdoc;

break;

case (OUTT_TREE):

case OUTT_TREE:

curp->outman = tree_man;

curp->outmdoc = tree_mdoc;

break;

case (OUTT_MAN):

case OUTT_MAN:

curp->outmdoc = man_mdoc;

curp->outman = man_man;

break;

case (OUTT_PDF):

case OUTT_PDF:

/* FALLTHROUGH */

case (OUTT_ASCII):

case OUTT_ASCII:

/* FALLTHROUGH */

case (OUTT_UTF8):

case OUTT_UTF8:

/* FALLTHROUGH */

case (OUTT_LOCALE):

case OUTT_LOCALE:

/* FALLTHROUGH */

case (OUTT_PS):

case OUTT_PS:

curp->outman = terminal_man;

curp->outmdoc = terminal_mdoc;

break;

Line 294 parse(struct curparse *curp, int fd,

Line 427 parse(struct curparse *curp, int fd,

}

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

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

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

Line 312 parse(struct curparse *curp, int fd,

Line 445 parse(struct curparse *curp, int fd,

}

static int

moptions(enum mparset *tflags, char *arg)

moptions(int *options, char *arg)

{

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

if (arg == NULL)

*tflags = MPARSE_MDOC;

/* nothing to do */;

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

*options |= MPARSE_MDOC;

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

*tflags = MPARSE_AUTO;

/* nothing to do */;

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

*tflags = MPARSE_MAN;

*options |= MPARSE_MAN;

else {

fprintf(stderr, "%s: Bad argument\n", arg);

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

progname, arg);

return(0);

}

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

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

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

curp->outtype = OUTT_PDF;

else {

fprintf(stderr, "%s: Bad argument\n", arg);

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

progname, arg);

return(0);

}

Line 366 static int

Line 503 static int

woptions(struct curparse *curp, char *arg)

{

char *v, *o;

const char *toks[6];

toks[0] = "stop";

toks[1] = "all";

Line 378 woptions(struct curparse *curp, char *arg)

Line 515 woptions(struct curparse *curp, char *arg)

while (*arg) {

o = arg;

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

case (0):

case 0:

curp->wstop = 1;

break;

case (1):

case 1:

/* FALLTHROUGH */

case (2):

case 2:

curp->wlevel = MANDOCLEVEL_WARNING;

break;

case (3):

case 3:

curp->wlevel = MANDOCLEVEL_ERROR;

break;

case (4):

case 4:

curp->wlevel = MANDOCLEVEL_FATAL;

break;

default:

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

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

progname, o);

return(0);

}

Line 402 woptions(struct curparse *curp, char *arg)

Line 540 woptions(struct curparse *curp, char *arg)

}

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:%d:%d: %s: %s",

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

file, line, col + 1,

mparse_strlevel(lvl),

if (line)

mparse_strerror(t));

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

CVSweb