mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.20 and 1.35

version 1.20, 2009/04/02 16:37:40

version 1.35, 2009/07/06 09:21:24

Line 1

/* $Id$ */

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

* purpose with or without fee is hereby granted, provided that the

* purpose with or without fee is hereby granted, provided that the above

* above copyright notice and this permission notice appear in all

* copyright notice and this permission notice appear in all copies.

* copies.

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED

* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE

* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

* PERFORMANCE OF THIS SOFTWARE.

#include <sys/stat.h>

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

Line 40 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 62 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;

enum intt inttype;

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

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

#define IGN_ESCAPE (1 << 1) /* Ignore bad escapes. */

#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 97 static int moptions(enum intt *, char *);

Line 99 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 mdocwarn(void *, int, int,

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

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 *,

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

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(&outtype, optarg))

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

Line 156 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) {

rc = 0;

curp.file = "<stdin>";

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

curp.fd = STDIN_FILENO;

if ( ! fdesc(&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 229 man_init(struct curparse *curp)

mancb.man_err = merr;

mancb.man_warn = manwarn;

/* Set command defaults. */

/* Defaults from mandoc.1. */

pflags = MAN_IGN_MACRO;

if (curp->fflags & IGN_MACRO)

pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;

pflags |= MAN_IGN_MACRO;

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 287 mdoc_init(struct curparse *curp)

Line 254 mdoc_init(struct curparse *curp)

struct mdoc *mdoc;

struct mdoc_cb mdoccb;

mdoccb.mdoc_msg = NULL;

mdoccb.mdoc_err = merr;

mdoccb.mdoc_warn = mdocwarn;

pflags = 0;

/* Defaults from mandoc.1. */

pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;

if (curp->fflags & IGN_SCOPE)

pflags |= MDOC_IGN_SCOPE;

if (curp->fflags & IGN_ESCAPE)

if (curp->fflags & NO_IGN_ESCAPE)

pflags |= MDOC_IGN_ESCAPE;

pflags &= ~MDOC_IGN_ESCAPE;

if (curp->fflags & IGN_MACRO)

if (curp->fflags & NO_IGN_MACRO)

pflags |= MDOC_IGN_MACRO;

pflags &= ~MDOC_IGN_MACRO;

if (curp->fflags & NO_IGN_CHARS)

pflags &= ~MDOC_IGN_CHARS;

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

warnx("memory allocated");

warnx("memory exhausted");

return(mdoc);

}

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 344 fdesc(struct buf *blk, struct buf *ln, struct curparse

Line 304 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 359 fdesc(struct buf *blk, struct buf *ln, struct curparse

Line 319 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 374 fdesc(struct buf *blk, struct buf *ln, struct curparse

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

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

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

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

}

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 414 fdesc(struct buf *blk, struct buf *ln, struct curparse

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

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 435 fdesc(struct buf *blk, struct buf *ln, struct curparse

Line 409 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 (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 unset, allocate output dev now (if applicable). */

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)

{

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 469 pset(const char *buf, size_t pos, struct curparse *cur

Line 481 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 487 pset(const char *buf, size_t pos, struct curparse *cur

Line 499 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 494 pset(const char *buf, size_t pos, struct curparse *cur

Line 507 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 536 toptions(enum outt *tflags, char *arg)

Line 550 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[5];

char *toks[6];

toks[0] = "ign-scope";

toks[1] = "ign-escape";

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

toks[2] = "ign-macro";

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

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

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

toks[4] = "strict";

toks[5] = NULL;

while (*arg)

while (*arg) {

o = arg;

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

case (0):

*fflags |= IGN_SCOPE;

break;

case (1):

*fflags |= IGN_ESCAPE;

*fflags |= NO_IGN_ESCAPE;

break;

case (2):

*fflags |= IGN_MACRO;

*fflags |= NO_IGN_MACRO;

break;

case (3):

*fflags |= NO_IGN_MACRO;

*fflags |= NO_IGN_CHARS;

break;

case (4):

*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];

toks[0] = "all";

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

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

toks[3] = "error";

toks[4] = NULL;

while (*arg)

while (*arg) {

o = arg;

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

case (0):

*wflags |= WARN_WALL;

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

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

*wflags |= WARN_WERR;

break;

default:

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

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

return(0);

}

return(1);

}

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

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

return(0);

}

static int

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

mdocwarn(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) {

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

case (WARN_COMPAT):

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

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

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

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

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

return(1);

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

warnx("considering warnings as errors");

__progname);

return(0);

}

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

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

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

return(1);

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

warnx("considering warnings as errors");

__progname);

return(0);

}

CVSweb