mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.45 and 1.66

version 1.45, 2009/10/13 10:21:24

version 1.66, 2010/05/15 05:11:50

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 27

Line 31

#include "mdoc.h"

#include "man.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)

# ifndef __dead

# define __attribute__(x)

# 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 62 enum outt {

OUTT_ASCII = 0,

OUTT_TREE,

OUTT_HTML,

OUTT_XHTML,

OUTT_LINT

};

Line 72 struct curparse {

Line 73 struct curparse {

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

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

out_mdoc outmdoc;

out_man outman;

out_free outfree;

void *outdata;

char *outopts;

char outopts[BUFSIZ];

};

extern void *html_alloc(char *);

static void fdesc(struct curparse *);

extern void html_mdoc(void *, const struct mdoc *);

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

extern void html_man(void *, const struct man *);

extern void html_free(void *);

extern void *ascii_alloc(void);

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

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

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

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

extern void terminal_free(void *);

static int foptions(int *, char *);

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

static struct man *man_init(struct curparse *);

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

static struct mdoc *mdoc_init(struct curparse *);

static int woptions(int *, char *);

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

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

static int mwarn(void *, 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;

/* LINTED */

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

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

switch (c) {

case ('f'):

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

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

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

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

return(EXIT_FAILURE);

break;

case ('o'):

case ('O'):

curp.outopts = optarg;

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

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

break;

case ('T'):

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

if ( ! toptions(&curp, optarg))

return(EXIT_FAILURE);

break;

case ('W'):

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

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

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] [-Toutput] [-Werr...]\n",

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

__progname);

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

exit(EXIT_FAILURE);

}

Line 241 static struct man *

Line 207 static struct man *

man_init(struct curparse *curp)

{

int pflags;

struct man *man;

struct man_cb mancb;

mancb.man_err = merr;

Line 249 man_init(struct curparse *curp)

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

}

Line 269 static struct mdoc *

Line 229 static struct mdoc *

mdoc_init(struct curparse *curp)

{

int pflags;

struct mdoc *mdoc;

struct mdoc_cb mdoccb;

mdoccb.mdoc_err = merr;

Line 277 mdoc_init(struct curparse *curp)

Line 236 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

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;

char *buf;

size_t sz, off;

ssize_t ssz;

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

perror(curp->file);

with_error = 1;

return(0);

}

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

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

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

* concerned that this is going to tank any machines.

if (S_ISREG(st.st_mode)) {

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

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

curp->file);

with_error = 1;

return(0);

}

*with_mmap = 1;

fb->sz = st.st_size;

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

MAP_FILE, curp->fd, 0);

if (fb->buf != MAP_FAILED)

return(1);

}

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

*with_mmap = 0;

off = 0;

fb->sz = 0;

fb->buf = NULL;

for (;;) {

if (off == fb->sz) {

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

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

curp->file);

break;

}

if (fb->sz == 0)

sz = 65536;

else

sz = 2 * fb->sz;

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

if (NULL == buf) {

perror(NULL);

break;

}

fb->buf = buf;

fb->sz = sz;

}

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

if (ssz == 0) {

fb->sz = off;

return(1);

}

if (ssz == -1) {

perror(curp->file);

break;

}

off += ssz;

}

free(fb->buf);

fb->buf = NULL;

with_error = 1;

return(0);

}

static void

fdesc(struct curparse *curp)

{

size_t sz;

struct buf ln, blk;

int j, i, pos, lnn, comment, with_mmap;

struct man *man;

struct mdoc *mdoc;

sz = BUFSIZ;

man = NULL;

mdoc = NULL;

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

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

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

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

* growable, hence passed in by ptr-ptr.

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

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

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

return;

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

sz = st.st_blksize;

if (sz > blk->sz) {

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

if (NULL == blk->buf) {

warn("realloc");

return(-1);

}

blk->sz = sz;

}

/* Fill buf with file blocksize. */

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

for (i = lnn = pos = comment = 0; i < (int)blk.sz; ++i) {

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

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

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

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

return(-1);

ln.buf = realloc(ln.buf, ln.sz);

} else if (0 == ssz)

if (NULL == ln.buf) {

break;

perror(NULL);

goto bailout;

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

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

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

if (comment)

continue;

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

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

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

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

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

continue;

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

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

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

break;

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

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

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

comment = 1;

pos -= 2;

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

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

break;

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

break;

}

continue;

}

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

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

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

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

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

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

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

break;

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

pos--;

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

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

}

ln->buf[pos] = 0;

ln.buf[pos] = 0;

lnn++;

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

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

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

pos, curp, &man, &mdoc))

return(-1);

goto bailout;

pos = comment = 0;

/* Pass down into parsers. */

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

if (man && ! man_parseln(man, lnn, ln.buf))

return(0);

goto bailout;

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

if (mdoc && ! mdoc_parseln(mdoc, lnn, ln.buf))

return(0);

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

}

if (mdoc && ! mdoc_endparse(mdoc))

return(0);

goto bailout;

if (man && ! man_endparse(man))

return(0);

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

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

if (mdoc && curp->outmdoc)

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

return(1);

cleanup:

if (curp->mdoc) {

mdoc_free(curp->mdoc);

curp->mdoc = NULL;

}

if (curp->man) {

man_free(curp->man);

curp->man = NULL;

}

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 504 pset(const char *buf, int pos, struct curparse *curp,

Line 547 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 522 pset(const char *buf, int pos, struct curparse *curp,

Line 563 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 530 pset(const char *buf, int pos, struct curparse *curp,

Line 570 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 546 moptions(enum intt *tflags, char *arg)

Line 585 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 555 moptions(enum intt *tflags, char *arg)

Line 594 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 579 static int

Line 623 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 641 woptions(int *wflags, char *arg)

Line 684 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 661 merr(void *arg, int line, int col, const char *msg)

Line 704 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 678 mwarn(void *arg, int line, int col, const char *msg)

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

}

CVSweb