diff options
| -rw-r--r-- | main.c | 86 | ||||
| -rw-r--r-- | mandoc.h | 39 | ||||
| -rw-r--r-- | roff.c | 306 | ||||
| -rw-r--r-- | roff.h | 10 |
4 files changed, 418 insertions, 23 deletions
@@ -29,8 +29,10 @@ #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)) @@ -70,6 +72,7 @@ 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; @@ -82,6 +85,7 @@ struct curparse { enum intt inttype; /* Input parsers... */ struct man *man; struct mdoc *mdoc; + struct roff *roff; enum outt outtype; /* Output devices... */ out_mdoc outmdoc; out_man outman; @@ -95,9 +99,12 @@ static void ffile(const char *, struct curparse *); static int foptions(int *, char *); static struct man *man_init(struct curparse *); static struct mdoc *mdoc_init(struct curparse *); -static int merr(void *, int, int, const char *); +static struct roff *roff_init(struct curparse *); +static int merr(void *, int, int, const char *); /* DEPRECATED */ static int moptions(enum intt *, char *); -static int mwarn(void *, int, int, const char *); +static int mwarn(void *, int, int, const char *); /* DEPRECATED */ +static int mmsg(enum mandocerr, void *, + int, int, const char *); static int pset(const char *, int, struct curparse *, struct man **, struct mdoc **); static int toptions(struct curparse *, char *); @@ -177,6 +184,12 @@ main(int argc, char *argv[]) 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((with_warning || with_error) ? EXIT_FAILURE : EXIT_SUCCESS); @@ -225,6 +238,14 @@ man_init(struct curparse *curp) } +static struct roff * +roff_init(struct curparse *curp) +{ + + return(roff_alloc(mmsg, curp)); +} + + static struct mdoc * mdoc_init(struct curparse *curp) { @@ -316,7 +337,7 @@ read_whole_file(struct curparse *curp, struct buf *fb, int *with_mmap) return(0); } *with_mmap = 1; - fb->sz = st.st_size; + 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) @@ -342,7 +363,7 @@ read_whole_file(struct curparse *curp, struct buf *fb, int *with_mmap) if (! resize_buf(fb, 65536)) break; } - ssz = read(curp->fd, fb->buf + off, fb->sz - off); + ssz = read(curp->fd, fb->buf + (int)off, fb->sz - off); if (ssz == 0) { fb->sz = off; return(1); @@ -351,7 +372,7 @@ read_whole_file(struct curparse *curp, struct buf *fb, int *with_mmap) perror(curp->file); break; } - off += ssz; + off += (size_t)ssz; } free(fb->buf); @@ -366,11 +387,14 @@ fdesc(struct curparse *curp) { struct buf ln, blk; int i, pos, lnn, lnn_start, with_mmap; + enum rofferr re; struct man *man; struct mdoc *mdoc; + struct roff *roff; man = NULL; mdoc = NULL; + roff = NULL; memset(&ln, 0, sizeof(struct buf)); /* @@ -378,9 +402,14 @@ fdesc(struct curparse *curp) * memory mapped. ln is a line buffer and grows on-demand. */ - if (!read_whole_file(curp, &blk, &with_mmap)) + if ( ! read_whole_file(curp, &blk, &with_mmap)) return; + if (NULL == curp->roff) + curp->roff = roff_init(curp); + if (NULL == (roff = curp->roff)) + goto bailout; + for (i = 0, lnn = 1; i < (int)blk.sz;) { pos = 0; lnn_start = lnn; @@ -436,7 +465,13 @@ fdesc(struct curparse *curp) if (pos >= (int)ln.sz) if (! resize_buf(&ln, 256)) goto bailout; - ln.buf[pos] = 0; + ln.buf[pos] = '\0'; + + re = roff_parseln(roff, lnn_start, &ln.buf, &ln.sz); + if (ROFF_IGN == re) + continue; + else if (ROFF_ERR == re) + goto bailout; /* If unset, assign parser in pset(). */ @@ -445,9 +480,9 @@ fdesc(struct curparse *curp) /* Pass down into parsers. */ - if (man && ! man_parseln(man, lnn, ln.buf)) + if (man && ! man_parseln(man, lnn_start, ln.buf)) goto bailout; - if (mdoc && ! mdoc_parseln(mdoc, lnn, ln.buf)) + if (mdoc && ! mdoc_parseln(mdoc, lnn_start, ln.buf)) goto bailout; } @@ -462,6 +497,8 @@ fdesc(struct curparse *curp) goto bailout; if (man && ! man_endparse(man)) goto bailout; + if (roff && ! roff_endparse(roff)) + goto bailout; /* If unset, allocate output dev now (if applicable). */ @@ -502,20 +539,19 @@ fdesc(struct curparse *curp) (*curp->outmdoc)(curp->outdata, mdoc); cleanup: - if (curp->mdoc) { - mdoc_free(curp->mdoc); - curp->mdoc = NULL; - } - if (curp->man) { - man_free(curp->man); - curp->man = NULL; - } + 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: @@ -737,3 +773,19 @@ mwarn(void *arg, int line, int col, const char *msg) return(1); } +/* + * 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) +{ + struct curparse *cp; + + cp = (struct curparse *)arg; + + fprintf(stderr, "%s:%d:%d: %s\n", cp->file, ln, col + 1, msg); + + return(1); +} diff --git a/mandoc.h b/mandoc.h new file mode 100644 index 00000000..cfdc4b5b --- /dev/null +++ b/mandoc.h @@ -0,0 +1,39 @@ +/* $Id$ */ +/* + * Copyright (c) 2010 Kristaps Dzonsons <kristaps@bsd.lv> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#ifndef MANDOC_H +#define MANDOC_H + +__BEGIN_DECLS + +enum mandocerr { + MANDOCERR_OK, + MANDOCERR_SCOPEEXIT, /* scope open on exit */ + MANDOCERR_NOSCOPE, /* request scope close w/none open */ +#define MANDOCERR_WARNING MANDOCERR_SCOPEEXIT + + MANDOCERR_MEM, /* memory exhausted */ +#define MANDOCERR_FATAL MANDOCERR_MEM + + MANDOCERR_MAX +}; + +typedef int (*mandocmsg)(enum mandocerr, + void *, int, int, const char *); + +__END_DECLS + +#endif /*!MANDOC_H*/ @@ -1,6 +1,6 @@ /* $Id$ */ /* - * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@bsd.lv> + * Copyright (c) 2010 Kristaps Dzonsons <kristaps@bsd.lv> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -18,7 +18,311 @@ #include "config.h" #endif +#include <assert.h> #include <stdlib.h> +#include <string.h> +#include "mandoc.h" #include "roff.h" +enum rofft { + ROFF_de, + ROFF_dei, + ROFF_am, + ROFF_ami, + ROFF_ig, + ROFF_close, + ROFF_MAX +}; + +struct roff { + struct roffnode *last; /* leaf of stack */ + mandocmsg msg; /* err/warn/fatal messages */ + void *data; /* privdata for messages */ +}; + +struct roffnode { + enum rofft tok; /* type of node */ + struct roffnode *parent; /* up one in stack */ + int line; /* parse line */ + int col; /* parse col */ +}; + +#define ROFF_ARGS struct roff *r, /* parse ctx */ \ + char **bufp, /* input buffer */ \ + size_t *szp, /* size of input buffer */ \ + int ln, /* parse line */ \ + int ppos /* current pos in buffer */ + +typedef enum rofferr (*roffproc)(ROFF_ARGS); + +struct roffmac { + const char *name; /* macro name */ + roffproc sub; /* child of control black */ + roffproc new; /* root of stack (type = ROFF_MAX) */ +}; + +static enum rofferr roff_ignore(ROFF_ARGS); +static enum rofferr roff_new_close(ROFF_ARGS); +static enum rofferr roff_new_ig(ROFF_ARGS); +static enum rofferr roff_sub_ig(ROFF_ARGS); + +const struct roffmac roffs[ROFF_MAX] = { + { "de", NULL, roff_ignore }, + { "dei", NULL, roff_ignore }, + { "am", NULL, roff_ignore }, + { "ami", NULL, roff_ignore }, + { "ig", roff_sub_ig, roff_new_ig }, + { ".", NULL, roff_new_close }, +}; + +static void roff_alloc1(struct roff *); +static void roff_free1(struct roff *); +static enum rofft roff_hash_find(const char *); +static int roffnode_push(struct roff *, + enum rofft, int, int); +static void roffnode_pop(struct roff *); +static enum rofft roff_parse(const char *, int *); + + +/* + * Look up a roff token by its name. Returns ROFF_MAX if no macro by + * the nil-terminated string name could be found. + */ +static enum rofft +roff_hash_find(const char *p) +{ + int i; + + /* FIXME: make this be fast and efficient. */ + + for (i = 0; i < (int)ROFF_MAX; i++) + if (0 == strcmp(roffs[i].name, p)) + return((enum rofft)i); + + return(ROFF_MAX); +} + + +/* + * Pop the current node off of the stack of roff instructions currently + * pending. + */ +static void +roffnode_pop(struct roff *r) +{ + struct roffnode *p; + + if (NULL == (p = r->last)) + return; + r->last = p->parent; + free(p); +} + + +/* + * Push a roff node onto the instruction stack. This must later be + * removed with roffnode_pop(). + */ +static int +roffnode_push(struct roff *r, enum rofft tok, int line, int col) +{ + struct roffnode *p; + + if (NULL == (p = calloc(1, sizeof(struct roffnode)))) { + (*r->msg)(MANDOCERR_MEM, r->data, line, col, NULL); + return(0); + } + + p->tok = tok; + p->parent = r->last; + p->line = line; + p->col = col; + + r->last = p; + return(1); +} + + +static void +roff_free1(struct roff *r) +{ + + while (r->last) + roffnode_pop(r); +} + + +static void +roff_alloc1(struct roff *r) +{ + + memset(r, 0, sizeof(struct roff)); +} + + +void +roff_reset(struct roff *r) +{ + + roff_free1(r); + roff_alloc1(r); +} + + +void +roff_free(struct roff *r) +{ + + roff_free1(r); + free(r); +} + + +struct roff * +roff_alloc(const mandocmsg msg, void *data) +{ + struct roff *r; + + if (NULL == (r = calloc(1, sizeof(struct roff)))) { + (*msg)(MANDOCERR_MEM, data, 0, 0, NULL); + return(0); + } + + r->msg = msg; + r->data = data; + return(r); +} + + +enum rofferr +roff_parseln(struct roff *r, int ln, char **bufp, size_t *szp) +{ + enum rofft t; + int ppos; + + if (NULL != r->last) { + /* + * If there's a node on the stack, then jump directly + * into its processing function. + */ + t = r->last->tok; + assert(roffs[t].sub); + return((*roffs[t].sub)(r, bufp, szp, ln, 0)); + } else if ('.' != (*bufp)[0] && NULL == r->last) + /* Return when in free text without a context. */ + return(ROFF_CONT); + + /* There's nothing on the stack: make us anew. */ + + if (ROFF_MAX == (t = roff_parse(*bufp, &ppos))) + return(ROFF_CONT); + + assert(roffs[t].new); + return((*roffs[t].new)(r, bufp, szp, ln, ppos)); +} + + +/* + * Parse a roff node's type from the input buffer. This must be in the + * form of ".foo xxx" in the usual way. + */ +static enum rofft +roff_parse(const char *buf, int *pos) +{ + int j; + char mac[5]; + enum rofft t; + + assert('.' == buf[0]); + *pos = 1; + + while (buf[*pos] && (' ' == buf[*pos] || '\t' == buf[*pos])) + (*pos)++; + + if ('\0' == buf[*pos]) + return(ROFF_MAX); + + for (j = 0; j < 4; j++, (*pos)++) + if ('\0' == (mac[j] = buf[*pos])) + break; + else if (' ' == buf[*pos]) + break; + + if (j == 4 || j < 1) + return(ROFF_MAX); + + mac[j] = '\0'; + + if (ROFF_MAX == (t = roff_hash_find(mac))) + return(t); + + while (buf[*pos] && ' ' == buf[*pos]) + (*pos)++; + + return(t); +} + + +/* ARGSUSED */ +static enum rofferr +roff_ignore(ROFF_ARGS) +{ + + return(ROFF_IGN); +} + + +/* ARGSUSED */ +static enum rofferr +roff_sub_ig(ROFF_ARGS) +{ + enum rofft t; + int pos; + + /* Ignore free-text lines. */ + + if ('.' != (*bufp)[ppos]) + return(ROFF_IGN); + + /* Ignore macros unless it's a closing macro. */ + + t = roff_parse(*bufp, &pos); + if (ROFF_close != t) + return(ROFF_IGN); + + roffnode_pop(r); + return(ROFF_IGN); +} + + +/* ARGSUSED */ +static enum rofferr +roff_new_close(ROFF_ARGS) +{ + + if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) + return(ROFF_ERR); + return(ROFF_IGN); +} + + +/* ARGSUSED */ +static enum rofferr +roff_new_ig(ROFF_ARGS) +{ + + return(roffnode_push(r, ROFF_ig, ln, ppos) ? + ROFF_IGN : ROFF_ERR); +} + + +int +roff_endparse(struct roff *r) +{ + + if (NULL == r->last) + return(1); + return((*r->msg)(MANDOCERR_SCOPEEXIT, r->data, + r->last->line, r->last->col, NULL)); +} @@ -1,6 +1,6 @@ /* $Id$ */ /* - * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@bsd.lv> + * Copyright (c) 2010 Kristaps Dzonsons <kristaps@bsd.lv> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -18,9 +18,9 @@ #define ROFF_H enum rofferr { - ROFF_CONT, - ROFF_IGN, - ROFF_ERROR + ROFF_CONT, /* re-process line with libmdoc or libman */ + ROFF_IGN, /* ignore line */ + ROFF_ERR, /* badness */ }; __BEGIN_DECLS @@ -28,7 +28,7 @@ __BEGIN_DECLS struct roff; void roff_free(struct roff *); -struct roff *roff_alloc(void *); +struct roff *roff_alloc(mandocmsg, void *); void roff_reset(struct roff *); enum rofferr roff_parseln(struct roff *, int, char **, size_t *); int roff_endparse(struct roff *); |