mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.49 and 1.76

version 1.49, 2009/10/26 08:42:37

version 1.76, 2010/05/16 10:59:36

Line 14

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

#include <sys/stat.h>

#include <assert.h>

#include <err.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdint.h>

Line 25

Line 29

#include <string.h>

#include <unistd.h>

#include "mandoc.h"

#include "mdoc.h"

#include "man.h"

#include "roff.h"

#include "main.h"

#define UNCONST(a) ((void *)(uintptr_t)(const void *)(a))

/* Account for FreeBSD and Linux in our declarations. */

/* FIXME: Intel's compiler? LLVM? pcc? */

#ifdef __linux__

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

extern int getsubopt(char **, char * const *, char **);

# if !defined(lint)

extern size_t strlcat(char *, const char *, size_t);

# define __attribute__(x)

# ifndef __dead

# define __dead __attribute__((__noreturn__))

# endif

#elif defined(__dead2)

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

# ifndef __dead

# define __dead __dead2

# endif

#endif

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

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

Line 64 enum outt {

OUTT_ASCII = 0,

OUTT_TREE,

OUTT_HTML,

OUTT_XHTML,

OUTT_LINT

};

Line 71 struct curparse {

Line 72 struct curparse {

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

int fd; /* Current parse. */

int wflags;

/* FIXME: set by max error */

#define WARN_WALL (1 << 0) /* All-warnings mask. */

#define WARN_WERR (1 << 2) /* Warnings->errors. */

int fflags;

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

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

#define NO_IGN_ESCAPE (1 << 1) /* Don't ignore bad escapes. */

#define FL_NIGN_ESCAPE (1 << 1) /* Don't ignore bad escapes. */

#define NO_IGN_MACRO (1 << 2) /* Don't ignore bad macros. */

#define FL_NIGN_MACRO (1 << 2) /* Don't ignore bad macros. */

#define NO_IGN_CHARS (1 << 3) /* Don't ignore bad chars. */

#define FL_IGN_ERRORS (1 << 4) /* Ignore failed parse. */

#define IGN_ERRORS (1 << 4) /* Ignore failed parse. */

#define FL_STRICT FL_NIGN_ESCAPE | \

FL_NIGN_MACRO

enum intt inttype; /* Input parsers... */

struct man *man;

struct man *lastman;

struct mdoc *mdoc;

struct mdoc *lastmdoc;

struct roff *roff;

enum outt outtype; /* Output devices... */

out_mdoc outmdoc;

out_man outman;

Line 92 struct curparse {

Line 94 struct curparse {

char outopts[BUFSIZ];

};

static void fdesc(struct curparse *);

static void ffile(const char *, struct curparse *);

static int foptions(int *, char *);

static int toptions(enum outt *, char *);

static struct man *man_init(struct curparse *);

static struct mdoc *mdoc_init(struct curparse *);

static struct roff *roff_init(struct curparse *);

static int merr(void *, int, int, const char *); /* DEPRECATED */

static int moptions(enum intt *, char *);

static int woptions(int *, char *);

static int mwarn(void *, int, int, const char *); /* DEPRECATED */

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

static int mmsg(enum mandocerr, void *,

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

int, int, const char *);

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 *, int, struct curparse *,

struct man **, struct mdoc **);

static struct man *man_init(struct curparse *);

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

static struct mdoc *mdoc_init(struct curparse *);

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

__dead static void version(void);

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

__dead static void usage(void);

static int woptions(int *, char *);

extern char *__progname;

static const char *progname;

static int with_error;

static int with_warning;

int

main(int argc, char *argv[])

{

int c, rc;

int c;

struct buf ln, blk;

struct curparse curp;

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

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

if (progname == NULL)

progname = argv[0];

else

++progname;

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

curp.inttype = INTT_AUTO;

curp.outtype = OUTT_ASCII;

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

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

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

break;

case ('T'):

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

if ( ! toptions(&curp, optarg))

return(EXIT_FAILURE);

break;

case ('W'):

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

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

argc -= optind;

argv += optind;

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

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

rc = 1;

if (NULL == *argv) {

curp.file = "<stdin>";

curp.fd = STDIN_FILENO;

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

fdesc(&curp);

if ( ! (IGN_ERRORS & curp.fflags))

rc = 1 == c ? 1 : 0;

else

rc = -1 == c ? 0 : 1;

}

while (rc && *argv) {

while (*argv) {

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

ffile(*argv, &curp);

if ( ! (IGN_ERRORS & curp.fflags))

rc = 1 == c ? 1 : 0;

else

rc = -1 == c ? 0 : 1;

argv++;

if (with_error && !(curp.fflags & FL_IGN_ERRORS))

if (*argv && rc) {

break;

if (curp.lastman)

++argv;

if ( ! man_reset(curp.lastman))

rc = 0;

if (curp.lastmdoc)

if ( ! mdoc_reset(curp.lastmdoc))

rc = 0;

curp.lastman = NULL;

curp.lastmdoc = NULL;

}

if (blk.buf)

free(blk.buf);

if (ln.buf)

free(ln.buf);

if (curp.outfree)

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

if (curp.mdoc)

mdoc_free(curp.mdoc);

if (curp.man)

man_free(curp.man);

if (curp.roff)

roff_free(curp.roff);

return(rc ? EXIT_SUCCESS : EXIT_FAILURE);

return((with_warning || with_error) ?

EXIT_FAILURE : EXIT_SUCCESS);

}

__dead static void

static void

version(void)

{

(void)printf("%s %s\n", __progname, VERSION);

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

exit(EXIT_SUCCESS);

}

__dead static void

static void

usage(void)

{

(void)fprintf(stderr, "usage: %s [-V] [-foption...] "

(void)fprintf(stderr, "usage: %s [-V] [-foption] "

"[-mformat] [-Ooption] [-Toutput] "

"[-Werr...]\n", __progname);

"[-Werr] [file...]\n", progname);

exit(EXIT_FAILURE);

}

Line 233 static struct man *

Line 220 static struct man *

man_init(struct curparse *curp)

{

int pflags;

struct man *man;

struct man_cb mancb;

mancb.man_err = merr;

Line 241 man_init(struct curparse *curp)

Line 227 man_init(struct curparse *curp)

/* Defaults from mandoc.1. */

pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;

pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE;

if (curp->fflags & NO_IGN_MACRO)

if (curp->fflags & FL_NIGN_MACRO)

pflags &= ~MAN_IGN_MACRO;

if (curp->fflags & NO_IGN_CHARS)

if (curp->fflags & FL_NIGN_ESCAPE)

pflags &= ~MAN_IGN_CHARS;

if (curp->fflags & NO_IGN_ESCAPE)

pflags &= ~MAN_IGN_ESCAPE;

if (NULL == (man = man_alloc(curp, pflags, &mancb)))

return(man_alloc(curp, pflags, &mancb));

warnx("memory exhausted");

}

return(man);

static struct roff *

roff_init(struct curparse *curp)

{

return(roff_alloc(mmsg, curp));

}

Line 261 static struct mdoc *

Line 250 static struct mdoc *

mdoc_init(struct curparse *curp)

{

int pflags;

struct mdoc *mdoc;

struct mdoc_cb mdoccb;

mdoccb.mdoc_err = merr;

Line 269 mdoc_init(struct curparse *curp)

Line 257 mdoc_init(struct curparse *curp)

/* Defaults from mandoc.1. */

pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;

pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE;

if (curp->fflags & IGN_SCOPE)

if (curp->fflags & FL_IGN_SCOPE)

pflags |= MDOC_IGN_SCOPE;

if (curp->fflags & NO_IGN_ESCAPE)

if (curp->fflags & FL_NIGN_ESCAPE)

pflags &= ~MDOC_IGN_ESCAPE;

if (curp->fflags & NO_IGN_MACRO)

if (curp->fflags & FL_NIGN_MACRO)

pflags &= ~MDOC_IGN_MACRO;

if (curp->fflags & NO_IGN_CHARS)

pflags &= ~MDOC_IGN_CHARS;

if (NULL == (mdoc = mdoc_alloc(curp, pflags, &mdoccb)))

return(mdoc_alloc(curp, pflags, &mdoccb));

warnx("memory exhausted");

return(mdoc);

}

static int

static void

ffile(struct buf *blk, struct buf *ln,

ffile(const char *file, struct curparse *curp)

const char *file, struct curparse *curp)

{

int c;

curp->file = file;

if (-1 == (curp->fd = open(curp->file, O_RDONLY, 0))) {

warn("%s", curp->file);

perror(curp->file);

return(-1);

with_error = 1;

return;

}

c = fdesc(blk, ln, curp);

fdesc(curp);

if (-1 == close(curp->fd))

warn("%s", curp->file);

perror(curp->file);

}

return(c);

static int

resize_buf(struct buf *buf, size_t initial)

{

void *tmp;

size_t sz;

if (buf->sz == 0)

sz = initial;

else

sz = 2 * buf->sz;

tmp = realloc(buf->buf, sz);

if (NULL == tmp) {

perror(NULL);

return(0);

}

buf->buf = tmp;

buf->sz = sz;

return(1);

}

static int

fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)

read_whole_file(struct curparse *curp, struct buf *fb, int *with_mmap)

{

size_t sz;

ssize_t ssz;

struct stat st;

int j, i, pos, lnn, comment;

size_t off;

struct man *man;

ssize_t ssz;

struct mdoc *mdoc;

sz = BUFSIZ;

if (-1 == fstat(curp->fd, &st)) {

man = NULL;

perror(curp->file);

mdoc = NULL;

with_error = 1;

return(0);

}

* Two buffers: ln and buf. buf is the input buffer optimised

* If we're a regular file, try just reading in the whole entry

* here for each file's block size. ln is a line buffer. Both

* via mmap(). This is faster than reading it into blocks, and

* growable, hence passed in by ptr-ptr.

* since each file is only a few bytes to begin with, I'm not

* concerned that this is going to tank any machines.

if (-1 == fstat(curp->fd, &st))

if (S_ISREG(st.st_mode)) {

warn("%s", curp->file);

if (st.st_size >= (1U << 31)) {

else if ((size_t)st.st_blksize > sz)

fprintf(stderr, "%s: input too large\n",

sz = st.st_blksize;

curp->file);

with_error = 1;

if (sz > blk->sz) {

return(0);

blk->buf = realloc(blk->buf, sz);

if (NULL == blk->buf) {

warn("realloc");

return(-1);

}

blk->sz = sz;

*with_mmap = 1;

fb->sz = (size_t)st.st_size;

fb->buf = mmap(NULL, fb->sz, PROT_READ,

MAP_FILE, curp->fd, 0);

if (fb->buf != MAP_FAILED)

return(1);

}

/* Fill buf with file blocksize. */

* If this isn't a regular file (like, say, stdin), then we must

* go the old way and just read things in bit by bit.

for (lnn = pos = comment = 0; ; ) {

*with_mmap = 0;

if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {

off = 0;

warn("%s", curp->file);

fb->sz = 0;

return(-1);

fb->buf = NULL;

} else if (0 == ssz)

for (;;) {

if (off == fb->sz) {

if (fb->sz == (1U << 31)) {

fprintf(stderr, "%s: input too large\n",

curp->file);

break;

}

if (! resize_buf(fb, 65536))

break;

}

ssz = read(curp->fd, fb->buf + (int)off, fb->sz - off);

if (ssz == 0) {

fb->sz = off;

return(1);

}

if (ssz == -1) {

perror(curp->file);

break;

}

off += (size_t)ssz;

}

/* Parse the read block into partial or full lines. */

free(fb->buf);

fb->buf = NULL;

with_error = 1;

return(0);

}

for (i = 0; i < (int)ssz; i++) {

if (pos >= (int)ln->sz) {

ln->sz += 256; /* Step-size. */

ln->buf = realloc(ln->buf, ln->sz);

if (NULL == ln->buf) {

warn("realloc");

return(-1);

}

if ('\n' != blk->buf[i]) {

static void

if (comment)

fdesc(struct curparse *curp)

continue;

{

ln->buf[pos++] = blk->buf[i];

struct buf ln, blk;

int i, pos, lnn, lnn_start, with_mmap, of;

enum rofferr re;

struct man *man;

struct mdoc *mdoc;

struct roff *roff;

/* Handle in-line `\"' comments. */

man = NULL;

mdoc = NULL;

roff = NULL;

memset(&ln, 0, sizeof(struct buf));

if (1 == pos || '\"' != ln->buf[pos - 1])

continue;

* Two buffers: ln and buf. buf is the input file and may be

* memory mapped. ln is a line buffer and grows on-demand.

for (j = pos - 2; j >= 0; j--)

if ( ! read_whole_file(curp, &blk, &with_mmap))

if ('\\' != ln->buf[j])

return;

break;

if ( ! ((pos - 2 - j) % 2))

if (NULL == curp->roff)

continue;

curp->roff = roff_init(curp);

if (NULL == (roff = curp->roff))

goto bailout;

comment = 1;

for (i = 0, lnn = 1; i < (int)blk.sz;) {

pos -= 2;

pos = 0;

lnn_start = lnn;

while (i < (int)blk.sz) {

if ('\n' == blk.buf[i]) {

++i;

++lnn;

break;

}

/* Trailing backslash is like a plain character. */

if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {

if (pos >= (int)ln.sz)

if (! resize_buf(&ln, 256))

goto bailout;

ln.buf[pos++] = blk.buf[i++];

continue;

}

/* Found an escape and at least one other character. */

/* Handle escaped `\\n' newlines. */

if ('\n' == blk.buf[i + 1]) {

/* Escaped newlines are skipped over */

if (pos > 0 && 0 == comment &&

i += 2;

'\\' == ln->buf[pos - 1]) {

++lnn;

for (j = pos - 1; j >= 0; j--)

continue;

if ('\\' != ln->buf[j])

}

if ('"' == blk.buf[i + 1]) {

i += 2;

/* Comment, skip to end of line */

for (; i < (int)blk.sz; ++i) {

if ('\n' == blk.buf[i]) {

++i;

++lnn;

break;

if ( ! ((pos - j) % 2)) {

}

pos--;

lnn++;

continue;

}

/* Backout trailing whitespaces */

for (; pos > 0; --pos) {

if (ln.buf[pos - 1] != ' ')

break;

if (pos > 2 && ln.buf[pos - 2] == '\\')

break;

}

break;

}

/* Some other escape sequence, copy and continue. */

if (pos + 1 >= (int)ln.sz)

if (! resize_buf(&ln, 256))

goto bailout;

ln->buf[pos] = 0;

ln.buf[pos++] = blk.buf[i++];

lnn++;

ln.buf[pos++] = blk.buf[i++];

}

/* If unset, assign parser in pset(). */

if (pos >= (int)ln.sz)

if (! resize_buf(&ln, 256))

goto bailout;

ln.buf[pos] = '\0';

if ( ! (man || mdoc) && ! pset(ln->buf,

pos, curp, &man, &mdoc))

* A significant amount of complexity is contained by

return(-1);

* the roff preprocessor. It's line-oriented but can be

* expressed on one line, so we need at times to

* readjust our starting point and re-run it. The roff

* preprocessor can also readjust the buffers with new

* data, so we pass them in wholesale.

pos = comment = 0;

of = 0;

do {

re = roff_parseln(roff, lnn_start,

&ln.buf, &ln.sz, of, &of);

} while (ROFF_RERUN == re);

/* Pass down into parsers. */

if (ROFF_IGN == re)

continue;

else if (ROFF_ERR == re)

goto bailout;

if (man && ! man_parseln(man, lnn, ln->buf))

return(0);

* If input parsers have not been allocated, do so now.

if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))

* We keep these instanced betwen parsers, but set them

return(0);

* locally per parse routine since we can use different

}

* parsers with each one.

if ( ! (man || mdoc))

if ( ! pset(ln.buf + of, pos - of, curp, &man, &mdoc))

goto bailout;

/* Lastly, push down into the parsers themselves. */

if (man && ! man_parseln(man, lnn_start, ln.buf, of))

goto bailout;

if (mdoc && ! mdoc_parseln(mdoc, lnn_start, ln.buf, of))

goto bailout;

}

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

if ( ! (man || mdoc)) {

(void)fprintf(stderr, "%s: not a manual\n",

fprintf(stderr, "%s: Not a manual\n", curp->file);

curp->file);

goto bailout;

return(0);

}

/* Clean up the parse routine ASTs. */

if (mdoc && ! mdoc_endparse(mdoc))

return(0);

goto bailout;

if (man && ! man_endparse(man))

return(0);

goto bailout;

if (roff && ! roff_endparse(roff))

goto bailout;

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

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

switch (curp->outtype) {

case (OUTT_XHTML):

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

curp->outman = html_man;

curp->outmdoc = html_mdoc;

curp->outfree = html_free;

break;

case (OUTT_HTML):

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

curp->outman = html_man;

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

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

case (OUTT_LINT):

break;

default:

curp->outdata = ascii_alloc();

curp->outdata = ascii_alloc(80);

curp->outman = terminal_man;

curp->outmdoc = terminal_mdoc;

curp->outfree = terminal_free;

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

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

if (mdoc && curp->outmdoc)

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

return(1);

cleanup:

if (mdoc)

mdoc_reset(mdoc);

if (man)

man_reset(man);

if (roff)

roff_reset(roff);

if (ln.buf)

free(ln.buf);

if (with_mmap)

munmap(blk.buf, blk.sz);

else

free(blk.buf);

return;

bailout:

with_error = 1;

goto cleanup;

}

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

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

* default to -man, which is more lenient.

if (buf[0] == '.') {

if ('.' == buf[0] || '\'' == buf[0]) {

for (i = 1; buf[i]; i++)

if (' ' != buf[i] && '\t' != buf[i])

break;

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

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

curp->mdoc = mdoc_init(curp);

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

return(0);

curp->lastmdoc = *mdoc;

return(1);

case (INTT_MAN):

if (NULL == curp->man)

curp->man = man_init(curp);

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

return(0);

curp->lastman = *man;

return(1);

default:

break;

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

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

curp->mdoc = mdoc_init(curp);

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

return(0);

curp->lastmdoc = *mdoc;

return(1);

}

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

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

curp->man = man_init(curp);

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

return(0);

curp->lastman = *man;

return(1);

}

Line 538 moptions(enum intt *tflags, char *arg)

Line 648 moptions(enum intt *tflags, char *arg)

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

*tflags = INTT_MAN;

else {

warnx("bad argument: -m%s", arg);

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

return(0);

}

Line 547 moptions(enum intt *tflags, char *arg)

Line 657 moptions(enum intt *tflags, char *arg)

static int

toptions(enum outt *tflags, char *arg)

toptions(struct curparse *curp, char *arg)

{

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

*tflags = OUTT_ASCII;

curp->outtype = OUTT_ASCII;

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

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

*tflags = OUTT_LINT;

curp->outtype = OUTT_LINT;

curp->wflags |= WARN_WALL;

curp->fflags |= FL_STRICT;

}

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

*tflags = OUTT_TREE;

curp->outtype = OUTT_TREE;

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

*tflags = OUTT_HTML;

curp->outtype = OUTT_HTML;

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

curp->outtype = OUTT_XHTML;

else {

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

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

return(0);

}

Line 571 static int

Line 686 static int

foptions(int *fflags, char *arg)

{

char *v, *o;

const char *toks[7];

const char *toks[8];

toks[0] = "ign-scope";

toks[1] = "no-ign-escape";

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

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

toks[3] = "ign-errors";

toks[4] = "ign-errors";

toks[4] = "strict";

toks[5] = "strict";

toks[5] = "ign-escape";

toks[6] = NULL;

while (*arg) {

o = arg;

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

case (0):

*fflags |= IGN_SCOPE;

*fflags |= FL_IGN_SCOPE;

break;

case (1):

*fflags |= NO_IGN_ESCAPE;

*fflags |= FL_NIGN_ESCAPE;

break;

case (2):

*fflags |= NO_IGN_MACRO;

*fflags |= FL_NIGN_MACRO;

break;

case (3):

*fflags |= NO_IGN_CHARS;

*fflags |= FL_IGN_ERRORS;

break;

case (4):

*fflags |= IGN_ERRORS;

*fflags |= FL_STRICT;

break;

case (5):

*fflags |= NO_IGN_ESCAPE |

*fflags &= ~FL_NIGN_ESCAPE;

NO_IGN_MACRO | NO_IGN_CHARS;

break;

default:

warnx("bad argument: -f%s", o);

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

return(0);

}

Line 633 woptions(int *wflags, char *arg)

Line 747 woptions(int *wflags, char *arg)

*wflags |= WARN_WERR;

break;

default:

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

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

return(0);

}

Line 653 merr(void *arg, int line, int col, const char *msg)

Line 767 merr(void *arg, int line, int col, const char *msg)

(void)fprintf(stderr, "%s:%d:%d: error: %s\n",

curp->file, line, col + 1, msg);

with_error = 1;

return(0);

}

Line 670 mwarn(void *arg, int line, int col, const char *msg)

Line 786 mwarn(void *arg, int line, int col, const char *msg)

(void)fprintf(stderr, "%s:%d:%d: warning: %s\n",

curp->file, line, col + 1, msg);

if ( ! (curp->wflags & WARN_WERR))

with_warning = 1;

return(1);

if (curp->wflags & WARN_WERR) {

with_error = 1;

return(0);

}

return(1);

}

static const char * const mandocerrs[MANDOCERR_MAX] = {

"ok",

"multi-line scope open on exit",

"request for scope closure when no matching scope is open",

"line arguments will be lost",

"memory exhausted"

};

* XXX: this is experimental code that will eventually become the

* generic means of covering all warnings and errors!

/* ARGSUSED */

static int

mmsg(enum mandocerr t, void *arg, int ln, int col, const char *msg)

{

#if 0

struct curparse *cp;

cp = (struct curparse *)arg;

fprintf(stderr, "%s:%d:%d: %s", cp->file,

ln, col + 1, mandocerrs[t]);

if (msg)

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

fputc('\n', stderr);

#endif

return(1);

}

CVSweb