mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.27 and 1.41

version 1.27, 2009/06/11 12:07:49

version 1.41, 2009/07/28 10:15:12

Line 65 struct curparse {

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

int fd; /* Current parse. */

int wflags;

#define WARN_WALL 0x03 /* All-warnings mask. */

#define WARN_WALL (1 << 0) /* 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;

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

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

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

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

enum intt inttype; /* Input parsers. */

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

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

struct man *man;

struct man *lastman;

struct mdoc *mdoc;

struct mdoc *lastmdoc;

enum outt outtype; /* Output devices. */

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

out_mdoc outmdoc;

out_man outman;

out_free outfree;

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

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

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

static int woptions(int *, char *);

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

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

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

static int mdocwarn(void *, int, int,

enum mdoc_warn, const char *);

static int fstdin(struct buf *, struct buf *,

struct curparse *);

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

const char *, struct curparse *);

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

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

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

switch (c) {

case ('f'):

if ( ! foptions(&curp.fflags, optarg))

return(0);

return(EXIT_FAILURE);

break;

case ('m'):

if ( ! moptions(&curp.inttype, optarg))

return(0);

return(EXIT_FAILURE);

break;

case ('T'):

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

return(0);

return(EXIT_FAILURE);

break;

case ('W'):

if ( ! woptions(&curp.wflags, optarg))

return(0);

return(EXIT_FAILURE);

break;

case ('V'):

version();

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

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

argc -= optind;

argv += optind;

/* Configure buffers. */

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

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

rc = 1;

if (NULL == *argv)

if (NULL == *argv) {

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

curp.file = "<stdin>";

rc = 0;

curp.fd = STDIN_FILENO;

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

if ( ! (IGN_ERRORS & curp.fflags))

rc = 1 == c ? 1 : 0;

else

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

}

while (rc && *argv) {

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

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

rc = 0;

if ( ! (IGN_ERRORS & curp.fflags))

rc = 1 == c ? 1 : 0;

else

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

argv++;

if (*argv && rc) {

if (curp.lastman)

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

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

free(blk.buf);

if (ln.buf)

free(ln.buf);

/* TODO: have a curp_free routine. */

if (curp.outfree)

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

if (curp.mdoc)

Line 231 man_init(struct curparse *curp)

Line 233 man_init(struct curparse *curp)

struct man_cb mancb;

mancb.man_err = merr;

mancb.man_warn = manwarn;

mancb.man_warn = mwarn;

/* Defaults from mandoc.1. */

* Default behaviour is to ignore unknown macros. This is

* specified in mandoc.1.

pflags = MAN_IGN_MACRO;

pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;

/* Override default behaviour... */

if (curp->fflags & NO_IGN_MACRO)

pflags &= ~MAN_IGN_MACRO;

if (curp->fflags & NO_IGN_CHARS)

pflags &= ~MAN_IGN_CHARS;

if (curp->fflags & NO_IGN_ESCAPE)

pflags &= ~MAN_IGN_ESCAPE;

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

warnx("memory exhausted");

Line 259 mdoc_init(struct curparse *curp)

Line 260 mdoc_init(struct curparse *curp)

struct mdoc *mdoc;

struct mdoc_cb mdoccb;

mdoccb.mdoc_msg = NULL;

mdoccb.mdoc_err = merr;

mdoccb.mdoc_warn = mdocwarn;

mdoccb.mdoc_warn = mwarn;

/* Defaults from mandoc.1. */

* Default behaviour is to ignore unknown macros, escape

* sequences and characters (very liberal). This is specified

* in mandoc.1.

pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;

/* Override default behaviour... */

if (curp->fflags & IGN_SCOPE)

pflags |= MDOC_IGN_SCOPE;

if (curp->fflags & NO_IGN_ESCAPE)

Line 290 mdoc_init(struct curparse *curp)

Line 284 mdoc_init(struct curparse *curp)

static int

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

{

curp->file = "<stdin>";

curp->fd = STDIN_FILENO;

return(fdesc(blk, ln, curp));

}

static int

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

const char *file, struct curparse *curp)

{

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

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

curp->file = file;

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

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

return(0);

return(-1);

}

c = fdesc(blk, ln, curp);

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

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

size_t sz;

ssize_t ssz;

struct stat st;

int j, i, pos, lnn;

int j, i, pos, lnn, comment;

struct man *man;

struct mdoc *mdoc;

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

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

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

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

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

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

sz = st.st_blksize;

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

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

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

if (NULL == blk->buf) {

warn("realloc");

return(0);

return(-1);

}

blk->sz = sz;

}

/* Fill buf with file blocksize. */

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

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

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

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

return(0);

return(-1);

} else if (0 == ssz)

break;

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

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

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

if (NULL == ln->buf) {

warn("realloc");

return(0);

return(-1);

}

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

if (comment)

continue;

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

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

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

continue;

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

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

break;

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

continue;

comment = 1;

pos -= 2;

continue;

}

/* Check for CPP-escaped newline. */

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

if (pos > 0 && '\\' == ln->buf[pos - 1]) {

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

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

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

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

break;

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

pos--;

lnn++;

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

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

ln->buf[pos] = 0;

lnn++;

* If no manual parser has been assigned, then

* try to assign one in pset(), which may do

* nothing at all. After this, parse the manual

* line accordingly.

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

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

pos, curp, &man, &mdoc))

return(0);

return(-1);

pos = 0;

pos = comment = 0;

/* Pass down into parsers. */

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

return(0);

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

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

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

}

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

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

if ( ! (man || mdoc)) {

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

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

curp->file);

return(0);

}

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

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

if (man && ! man_endparse(man))

return(0);

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

* 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) {

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

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

if (man && curp->outman)

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

return(0);

return(-1);

if (mdoc && curp->outmdoc)

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

return(0);

return(-1);

return(1);

}

Line 470 static int

Line 464 static int

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

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

{

int i;

* Try to intuit which kind of manual parser should be used. If

* passed in by command-line (-man, -mdoc), then use that

* explicitly. If passed as -mandoc, then try to guess from the

* line: either skip comments, use -mdoc when finding `.Dt', or

* line: either skip dot-lines, use -mdoc when finding `.Dt', or

* default to -man, which is more lenient.

if (pos >= 3 && 0 == memcmp(buf, ".\\\"", 3))

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

return(1);

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

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

break;

if (0 == buf[i])

return(1);

}

switch (curp->inttype) {

case (INTT_MDOC):

Line 557 toptions(enum outt *tflags, char *arg)

}

* Parse out the options for [-fopt...] setting compiler options. These

* can be comma-delimited or called again.

static int

foptions(int *fflags, char *arg)

{

char *v;

char *v, *o;

char *toks[6];

char *toks[7];

toks[0] = "ign-scope";

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

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

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

toks[4] = "strict";

toks[4] = "ign-errors";

toks[5] = NULL;

toks[5] = "strict";

toks[6] = NULL;

while (*arg)

while (*arg) {

o = arg;

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

case (0):

*fflags |= IGN_SCOPE;

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

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

*fflags |= NO_IGN_CHARS;

break;

case (4):

*fflags |= IGN_ERRORS;

break;

case (5):

*fflags |= NO_IGN_ESCAPE |

NO_IGN_MACRO | NO_IGN_CHARS;

break;

default:

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

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

return(0);

}

return(1);

}

* Parse out the options for [-Werr...], which sets warning modes.

* These can be comma-delimited or called again.

static int

woptions(int *wflags, char *arg)

{

char *v;

char *v, *o;

char *toks[5];

char *toks[3];

toks[0] = "all";

toks[1] = "compat";

toks[1] = "error";

toks[2] = "syntax";

toks[2] = NULL;

toks[3] = "error";

toks[4] = NULL;

while (*arg)

while (*arg) {

o = arg;

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

case (0):

*wflags |= WARN_WALL;

break;

case (1):

*wflags |= WARN_WCOMPAT;

break;

case (2):

*wflags |= WARN_WSYNTAX;

break;

case (3):

*wflags |= WARN_WERR;

break;

default:

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

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

return(0);

}

return(1);

}

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

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

struct curparse *curp;

curp = (struct curparse *)arg;

warnx("%s:%d: error: %s (column %d)",

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

/* Always exit on errors... */

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

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

return(0);

}

static int

mdocwarn(void *arg, int line, int col,

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

enum mdoc_warn type, const char *msg)

{

struct curparse *curp;

char *wtype;

curp = (struct curparse *)arg;

wtype = NULL;

switch (type) {

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

case (WARN_COMPAT):

wtype = "compat";

if (curp->wflags & WARN_WCOMPAT)

break;

return(1);

case (WARN_SYNTAX):

wtype = "syntax";

if (curp->wflags & WARN_WSYNTAX)

break;

return(1);

}

assert(wtype);

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

warnx("%s:%d: %s warning: %s (column %d)",

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

curp->file, line, wtype, msg, col);

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

return(1);

* If the -Werror flag is passed in, as in gcc, then all

* warnings are considered as errors.

warnx("%s: considering warnings as errors",

__progname);

return(0);

}

static int

manwarn(void *arg, int line, int col, const char *msg)

{

struct curparse *curp;

curp = (struct curparse *)arg;

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

return(1);

warnx("%s:%d: syntax warning: %s (column %d)",

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

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

return(1);

* If the -Werror flag is passed in, as in gcc, then all

* warnings are considered as errors.

warnx("%s: considering warnings as errors",

__progname);

return(0);

}

CVSweb