mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.26 and 1.59

version 1.26, 2009/06/10 20:18:43

version 1.59, 2010/01/29 14:39:38

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/stat.h>

#include <assert.h>

#include <err.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "mdoc.h"

#include "man.h"

#include "main.h"

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

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

#ifdef __linux__

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

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

# ifndef __dead

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

# define __dead __attribute__((__noreturn__))

# if !defined(lint)

# define __attribute__(x)

# endif

#elif defined(__dead2)

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

# ifndef __dead

# define __dead __dead2

# endif

#endif

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

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

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

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

typedef void (*out_free)(void *);

struct buf {

Line 58 enum intt {

Line 60 enum intt {

enum outt {

OUTT_ASCII = 0,

OUTT_TREE,

OUTT_HTML,

OUTT_XHTML,

OUTT_LINT

};

Line 65 struct curparse {

Line 69 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;

void *outdata;

char outopts[BUFSIZ];

};

extern void *ascii_alloc(void);

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

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

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

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

extern void terminal_free(void *);

static int foptions(int *, char *);

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 111 static int pset(const char *, int, struct curparse

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

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

__dead static void usage(void);

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

extern char *__progname;

static const char *progname;

int

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

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

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

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

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 ('O'):

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

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

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

argc -= optind;

argv += optind;

/* Configure buffers. */

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

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

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)

if ( ! man_reset(curp.lastman))

man_reset(curp.lastman);

rc = 0;

if (curp.lastmdoc)

if ( ! mdoc_reset(curp.lastmdoc))

mdoc_reset(curp.lastmdoc);

rc = 0;

curp.lastman = NULL;

curp.lastmdoc = NULL;

}

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

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

}

__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...] "

"[-mformat] [-Toutput] [-Werr...]\n",

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

__progname);

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

exit(EXIT_FAILURE);

}

Line 225 static struct man *

Line 235 static struct man *

man_init(struct curparse *curp)

{

int pflags;

struct man *man;

struct man_cb mancb;

mancb.man_err = merr;

mancb.man_warn = manwarn;

mancb.man_warn = mwarn;

pflags = MAN_IGN_MACRO; /* XXX */

/* Defaults from mandoc.1. */

pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;

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

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

warnx("memory exhausted");

return(man);

}

Line 247 static struct mdoc *

Line 259 static struct mdoc *

mdoc_init(struct curparse *curp)

{

int pflags;

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

pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;

if (curp->fflags & IGN_SCOPE)

Line 265 mdoc_init(struct curparse *curp)

Line 277 mdoc_init(struct curparse *curp)

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

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 290 ffile(struct buf *blk, struct buf *ln,

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

curp->file = file;

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

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

perror(curp->file);

return(0);

return(-1);

}

c = fdesc(blk, ln, curp);

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

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

perror(curp->file);

return(c);

}

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

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

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

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

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

perror(curp->file);

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

perror(NULL);

return(0);

exit(EXIT_FAILURE);

}

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

perror(curp->file);

return(0);

return(-1);

} else if (0 == ssz)

break;

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

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

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

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

if (NULL == ln->buf) {

warn("realloc");

perror(NULL);

return(0);

return(EXIT_FAILURE);

}

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

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

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

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

return(0);

}

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

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

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;

curp->outmdoc = html_mdoc;

curp->outfree = html_free;

break;

case (OUTT_TREE):

curp->outman = tree_man;

curp->outmdoc = tree_mdoc;

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

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

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

if (man && curp->outman)

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

(*curp->outman)(curp->outdata, man);

return(0);

if (mdoc && curp->outmdoc)

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

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

return(0);

return(1);

}

Line 453 static int

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

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

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

*tflags = OUTT_LINT;

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

*tflags = OUTT_TREE;

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

*tflags = OUTT_HTML;

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

*tflags = OUTT_XHTML;

else {

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

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

return(0);

}

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

Line 568 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];

const char *toks[8];

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] = "ign-escape";

toks[7] = NULL;

while (*arg)

while (*arg) {

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

o = arg;

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

case (0):

*fflags |= IGN_SCOPE;

break;

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

Line 599 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;

case (6):

*fflags &= ~NO_IGN_ESCAPE;

break;

default:

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

fprintf(stderr, "%s: Bad argument\n", 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];

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

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

o = arg;

switch (getsubopt(&arg, UNCONST(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);

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

return(0);

}

return(1);

}

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

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

curp = (struct curparse *)arg;

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

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

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

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

return(0);

}

static int

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

enum mdoc_warn type, const char *msg)

{

struct curparse *curp;

char *wtype;

curp = (struct curparse *)arg;

wtype = NULL;

switch (type) {

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

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

__progname);

return(0);

}

static int

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

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

{

struct curparse *curp;

curp = (struct curparse *)arg;

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

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

return(1);

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

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

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

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

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

return(1);

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

__progname);

return(0);

}

CVSweb