mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.21 and 1.22

version 1.21, 2009/04/02 16:42:35

version 1.22, 2009/04/03 11:08:39

Line 42 extern int getsubopt(char **, char * const *, char

# endif

#endif

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

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

typedef void (*out_free)(void *);

struct buf {

char *buf;

size_t sz;

Line 60 enum outt {

Line 64 enum outt {

};

struct curparse {

const char *file;

const char *file; /* Current parse. */

int fd;

int fd; /* Current parse. */

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

int fflags;

int fflags; /* Per-intt flags. */

enum intt inttype;

enum intt inttype; /* Input parsers. */

struct man *man;

struct man *lastman;

struct mdoc *mdoc;

struct mdoc *lastmdoc;

enum outt outtype; /* Output devices. */

out_mdoc outmdoc;

out_man outman;

out_free outfree;

void *outdata;

};

#define IGN_SCOPE (1 << 0) /* Ignore scope errors. */

Line 78 struct curparse {

Line 89 struct curparse {

#define IGN_MACRO (1 << 2) /* Ignore unknown macros. */

#define NO_IGN_MACRO (1 << 3)

typedef int (*out_run)(void *, const struct man *,

const struct mdoc *);

typedef void (*out_free)(void *);

extern char *__progname;

extern void *ascii_alloc(void);

extern int terminal_run(void *, const struct man *,

extern int tree_mdoc(void *, const struct mdoc *);

const struct mdoc *);

extern int tree_man(void *, const struct man *);

extern int tree_run(void *, const struct man *,

extern int terminal_mdoc(void *, const struct mdoc *);

const struct mdoc *);

extern int terminal_man(void *, const struct man *);

extern void terminal_free(void *);

static int foptions(int *, char *);

Line 105 static int ffile(struct buf *, struct buf *,

Line 110 static int ffile(struct buf *, struct buf *,

const char *, struct curparse *);

static int fdesc(struct buf *, struct buf *,

struct curparse *);

static int pset(const char *, size_t, struct curparse *,

static int pset(const char *, int, struct curparse *,

struct man **, struct mdoc **);

static struct man *man_init(struct curparse *);

static struct mdoc *mdoc_init(struct curparse *);

__dead static void version(void);

__dead static void usage(void);

extern char *__progname;

int

main(int argc, char *argv[])

{

int c, rc;

void *outdata;

enum outt outtype;

struct buf ln, blk;

out_run outrun;

out_free outfree;

struct curparse curp;

outtype = OUTT_ASCII;

bzero(&curp, sizeof(struct curparse));

curp.inttype = INTT_AUTO;

curp.outtype = OUTT_ASCII;

/* LINTED */

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

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

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

return(0);

break;

case ('T'):

if ( ! toptions(&outtype, optarg))

if ( ! toptions(&curp.outtype, optarg))

return(0);

break;

case ('W'):

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

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

argc -= optind;

argv += optind;

* Allocate the appropriate front-end. Note that utf8, latin1

* (both not yet implemented) and ascii all resolve to the

* terminal front-end with different encodings (see terminal.c).

* Not all frontends have cleanup or alloc routines.

switch (outtype) {

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;

}

/* Configure buffers. */

bzero(&ln, sizeof(struct buf));

bzero(&blk, sizeof(struct buf));

rc = 1;

* Main loop around available files.

if (NULL == *argv) {

if (NULL == *argv)

rc = 0;

if ( ! fstdin(&blk, &ln, &curp))

c = fstdin(&blk, &ln, &curp);

rc = 0;

if (c && NULL == outrun)

while (rc && *argv) {

rc = 1;

if ( ! ffile(&blk, &ln, *argv, &curp))

/*else if (c && outrun && (*outrun)(outdata, curp.man, curp.mdoc))

rc = 0;

rc = 1;*/

argv++;

} else {

if (*argv && rc) {

while (*argv) {

if (curp.lastman)

c = ffile(&blk, &ln, *argv, &curp);

if ( ! man_reset(curp.lastman))

if ( ! c)

rc = 0;

break;

if (curp.lastmdoc)

/*if (outrun && ! (*outrun)(outdata, curp.man, curp.mdoc))

if ( ! mdoc_reset(curp.lastmdoc))

break;*/

rc = 0;

if (curp.man)

curp.lastman = NULL;

man_reset(curp.man);

curp.lastmdoc = NULL;

if (curp.mdoc && ! mdoc_reset(curp.mdoc)) {

warnx("memory exhausted");

break;

}

argv++;

}

rc = NULL == *argv;

}

if (blk.buf)

free(blk.buf);

if (ln.buf)

free(ln.buf);

if (outfree)

if (curp.outfree)

(*outfree)(outdata);

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

if (curp.mdoc)

mdoc_free(curp.mdoc);

if (curp.man)

Line 265 man_init(struct curparse *curp)

Line 234 man_init(struct curparse *curp)

mancb.man_err = merr;

mancb.man_warn = manwarn;

/* Set command defaults. */

pflags = MAN_IGN_MACRO; /* XXX */

pflags = MAN_IGN_MACRO;

if (curp->fflags & NO_IGN_MACRO)

pflags &= ~MAN_IGN_MACRO;

Line 289 mdoc_init(struct curparse *curp)

Line 257 mdoc_init(struct curparse *curp)

mdoccb.mdoc_err = merr;

mdoccb.mdoc_warn = mdocwarn;

pflags = 0;

pflags = 0; /* XXX */

if (curp->fflags & IGN_SCOPE)

pflags |= MDOC_IGN_SCOPE;

Line 435 fdesc(struct buf *blk, struct buf *ln, struct curparse

Line 403 fdesc(struct buf *blk, struct buf *ln, struct curparse

/* Note that a parser may not have been assigned, yet. */

if (mdoc)

if ( ! (man || mdoc)) {

return(mdoc_endparse(mdoc));

warnx("%s: not a manual", curp->file);

if (man)

return(0);

return(man_endparse(man));

}

warnx("%s: not a manual", curp->file);

if (mdoc && ! mdoc_endparse(mdoc))

return(0);

if (man && ! man_endparse(man))

return(0);

* If an output device hasn't been allocated, see if we should

* do so now. Note that not all outtypes have functions, so

* this switch statement may be superfluous, but it's

* low-overhead enough not to matter very much.

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

switch (curp->outtype) {

case (OUTT_TREE):

curp->outman = tree_man;

curp->outmdoc = tree_mdoc;

break;

case (OUTT_LINT):

break;

default:

curp->outdata = ascii_alloc();

curp->outman = terminal_man;

curp->outmdoc = terminal_mdoc;

curp->outfree = terminal_free;

break;

}

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

if (man && curp->outman)

if ( ! (*curp->outman)(curp->outdata, man))

return(0);

if (mdoc && curp->outmdoc)

if ( ! (*curp->outmdoc)(curp->outdata, mdoc))

return(0);

return(1);

}

static int

pset(const char *buf, size_t pos, struct curparse *curp,

pset(const char *buf, int pos, struct curparse *curp,

struct man **man, struct mdoc **mdoc)

{

Line 467 pset(const char *buf, size_t pos, struct curparse *cur

Line 472 pset(const char *buf, size_t pos, struct curparse *cur

curp->mdoc = mdoc_init(curp);

if (NULL == (*mdoc = curp->mdoc))

return(0);

warnx("inheriting -mdoc parser");

curp->lastmdoc = *mdoc;

return(1);

case (INTT_MAN):

if (NULL == curp->man)

curp->man = man_init(curp);

if (NULL == (*man = curp->man))

return(0);

warnx("inheriting -man parser");

curp->lastman = *man;

return(1);

default:

break;

Line 485 pset(const char *buf, size_t pos, struct curparse *cur

Line 490 pset(const char *buf, size_t pos, struct curparse *cur

curp->mdoc = mdoc_init(curp);

if (NULL == (*mdoc = curp->mdoc))

return(0);

curp->lastmdoc = *mdoc;

return(1);

}

Line 492 pset(const char *buf, size_t pos, struct curparse *cur

Line 498 pset(const char *buf, size_t pos, struct curparse *cur

curp->man = man_init(curp);

if (NULL == (*man = curp->man))

return(0);

curp->lastman = *man;

return(1);

}

Line 547 foptions(int *fflags, char *arg)

Line 554 foptions(int *fflags, char *arg)

toks[0] = "ign-scope";

toks[1] = "ign-escape";

toks[2] = "ign-macro";

toks[4] = "no-ign-macro";

toks[3] = "no-ign-macro";

toks[5] = NULL;

toks[4] = NULL;

while (*arg)

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

CVSweb