version 1.2, 2009/02/23 07:09:13 |
version 1.10, 2009/03/09 13:04:01 |
|
|
|
|
#include "mmain.h" |
#include "mmain.h" |
|
|
#define MD_LINE_SZ (256) /* Max input line size. */ |
#define MD_LINE_SZ (256) /* Input line step-size. */ |
|
|
struct mmain { |
struct mmain { |
int warn; /* Warning flags. */ |
int warn; /* Warning flags. */ |
|
|
int dbg; /* Debug level. */ |
int dbg; /* Debug level. */ |
struct mdoc *mdoc; /* Active parser. */ |
struct mdoc *mdoc; /* Active parser. */ |
char *buf; /* Input buffer. */ |
char *buf; /* Input buffer. */ |
u_long bufsz; /* Input buffer size. */ |
size_t bufsz; /* Input buffer size. */ |
char *in; /* Input file name. */ |
char *in; /* Input file name. */ |
int fdin; /* Input file desc. */ |
int fdin; /* Input file desc. */ |
|
int pflags; /* Parse flags. */ |
}; |
}; |
|
|
extern char *__progname; |
extern char *__progname; |
|
|
static int getsopts(struct mmain *, char *); |
static int optswarn(struct mmain *, char *); |
|
static int optsopt(struct mmain *, char *); |
static int parse(struct mmain *); |
static int parse(struct mmain *); |
static void msg_msg(void *, int, int, const char *); |
static void msg_msg(void *, int, int, const char *); |
static int msg_err(void *, int, int, const char *); |
static int msg_err(void *, int, int, const char *); |
Line 57 static int msg_warn(void *, int, int, |
|
Line 59 static int msg_warn(void *, int, int, |
|
|
|
#ifdef __linux__ |
#ifdef __linux__ |
extern int getsubopt(char **, char *const *, char **); |
extern int getsubopt(char **, char *const *, char **); |
|
extern size_t strlcpy(char *, const char *, size_t); |
|
extern size_t strlcat(char *, const char *, size_t); |
#endif |
#endif |
|
|
|
|
|
|
mmain_usage(const char *help) |
mmain_usage(const char *help) |
{ |
{ |
|
|
warnx("usage: %s %s%s[-v] [-Wwarn...] [infile]", __progname, |
warnx("usage: %s %s%s[-v] [-foption...] [-Wwarn...] [infile]", __progname, |
help ? help : "", help ? " " : ""); |
help ? help : "", help ? " " : ""); |
} |
} |
|
|
Line 106 mmain_getopt(struct mmain *p, int argc, char *argv[], |
|
Line 110 mmain_getopt(struct mmain *p, int argc, char *argv[], |
|
size_t sz; |
size_t sz; |
|
|
extern int optind; |
extern int optind; |
extern int optreset; |
|
|
|
sz = strlcpy(opts, "vW:", 32); |
sz = strlcpy(opts, "VvW:f:", 32); |
assert(sz < 32); |
assert(sz < 32); |
|
|
if (u) { |
if (u) { |
Line 116 mmain_getopt(struct mmain *p, int argc, char *argv[], |
|
Line 119 mmain_getopt(struct mmain *p, int argc, char *argv[], |
|
assert(sz < 32); |
assert(sz < 32); |
} |
} |
|
|
|
optind = 1; |
|
|
/* LINTED */ |
/* LINTED */ |
while (-1 != (c = getopt(argc, argv, opts))) |
while (-1 != (c = getopt(argc, argv, opts))) |
switch (c) { |
switch (c) { |
|
case ('f'): |
|
if ( ! optsopt(p, optarg)) |
|
return(-1); |
|
break; |
case ('v'): |
case ('v'): |
p->dbg++; |
p->dbg++; |
break; |
break; |
|
case ('V'): |
|
(void)printf("%s %s\n", __progname, VERSION); |
|
return(0); |
case ('W'): |
case ('W'): |
if ( ! getsopts(p, optarg)) |
if ( ! optswarn(p, optarg)) |
return(0); |
return(-1); |
break; |
break; |
case ('?'): |
case ('?'): |
mmain_usage(help); |
mmain_usage(help); |
return(0); |
return(-1); |
default: |
default: |
assert(getopt_cb); |
assert(getopt_cb); |
if ((*getopt_cb)(arg, c, optarg)) |
if ((*getopt_cb)(arg, c, optarg)) |
break; |
break; |
return(0); |
return(-1); |
} |
} |
|
|
argv += optind; |
argv += optind; |
Line 144 mmain_getopt(struct mmain *p, int argc, char *argv[], |
|
Line 156 mmain_getopt(struct mmain *p, int argc, char *argv[], |
|
} |
} |
|
|
|
|
__dead void |
dead_pre void |
mmain_exit(struct mmain *p, int code) |
mmain_exit(struct mmain *p, int code) |
{ |
{ |
|
|
if (p->mdoc) |
if (p->mdoc) |
Line 178 mmain_mdoc(struct mmain *p) |
|
Line 190 mmain_mdoc(struct mmain *p) |
|
warn("%s", p->in); |
warn("%s", p->in); |
p->bufsz = BUFSIZ; |
p->bufsz = BUFSIZ; |
} else |
} else |
p->bufsz = MAX(st.st_blksize, BUFSIZ); |
p->bufsz = (size_t)MAX(st.st_blksize, BUFSIZ); |
|
|
p->buf = malloc(p->bufsz); |
p->buf = malloc(p->bufsz); |
if (NULL == p->buf) |
if (NULL == p->buf) |
Line 186 mmain_mdoc(struct mmain *p) |
|
Line 198 mmain_mdoc(struct mmain *p) |
|
|
|
/* Allocate the parser. */ |
/* Allocate the parser. */ |
|
|
p->mdoc = mdoc_alloc(p, &cb); |
p->mdoc = mdoc_alloc(p, p->pflags, &cb); |
|
|
/* Parse the input file. */ |
/* Parse the input file. */ |
|
|
Line 202 mmain_mdoc(struct mmain *p) |
|
Line 214 mmain_mdoc(struct mmain *p) |
|
|
|
|
|
static int |
static int |
getsopts(struct mmain *p, char *arg) |
optsopt(struct mmain *p, char *arg) |
{ |
{ |
char *v; |
char *v; |
|
char *toks[] = { "ign-scope", "ign-escape", |
|
"ign-macro", NULL }; |
|
|
|
while (*arg) |
|
switch (getsubopt(&arg, toks, &v)) { |
|
case (0): |
|
p->pflags |= MDOC_IGN_SCOPE; |
|
break; |
|
case (1): |
|
p->pflags |= MDOC_IGN_ESCAPE; |
|
break; |
|
case (2): |
|
p->pflags |= MDOC_IGN_MACRO; |
|
break; |
|
default: |
|
warnx("unknown -f argument"); |
|
return(0); |
|
} |
|
|
|
return(1); |
|
} |
|
|
|
|
|
static int |
|
optswarn(struct mmain *p, char *arg) |
|
{ |
|
char *v; |
char *toks[] = { "all", "compat", |
char *toks[] = { "all", "compat", |
"syntax", "error", NULL }; |
"syntax", "error", NULL }; |
|
|
Line 223 getsopts(struct mmain *p, char *arg) |
|
Line 262 getsopts(struct mmain *p, char *arg) |
|
p->warn |= MD_WARN_ERR; |
p->warn |= MD_WARN_ERR; |
break; |
break; |
default: |
default: |
|
warnx("unknown -W argument"); |
return(0); |
return(0); |
} |
} |
|
|
Line 233 getsopts(struct mmain *p, char *arg) |
|
Line 273 getsopts(struct mmain *p, char *arg) |
|
static int |
static int |
parse(struct mmain *p) |
parse(struct mmain *p) |
{ |
{ |
ssize_t sz, i; |
ssize_t sz; |
size_t pos; |
int j, i, pos, len, lnn; |
char line[MD_LINE_SZ]; |
char *ln; |
int lnn; |
|
|
|
/* |
for (ln = NULL, lnn = 1, len = pos = 0; ; ) { |
* This is a little more complicated than fgets. TODO: have |
|
* some benchmarks that show it's faster (note that I want to |
|
* check many, many manuals simultaneously, so speed is |
|
* important). Fill a buffer (sized to the block size) with a |
|
* single read, then parse \n-terminated lines into a line |
|
* buffer, which is passed to the parser. Hard-code the line |
|
* buffer to a particular size -- a reasonable assumption. |
|
*/ |
|
|
|
for (lnn = 1, pos = 0; ; ) { |
|
if (-1 == (sz = read(p->fdin, p->buf, p->bufsz))) { |
if (-1 == (sz = read(p->fdin, p->buf, p->bufsz))) { |
warn("%s", p->in); |
warn("%s", p->in); |
return(0); |
return(0); |
} else if (0 == sz) |
} else if (0 == sz) |
break; |
break; |
|
|
for (i = 0; i < sz; i++) { |
for (i = 0; i < (int)sz; i++) { |
|
if (pos >= len) { |
|
len += MD_LINE_SZ; |
|
ln = realloc(ln, (size_t)len); |
|
if (NULL == ln) |
|
err(1, "realloc"); |
|
} |
|
|
if ('\n' != p->buf[i]) { |
if ('\n' != p->buf[i]) { |
if (pos < sizeof(line)) { |
ln[pos++] = p->buf[i]; |
line[(int)pos++] = p->buf[(int)i]; |
continue; |
|
} |
|
|
|
/* Check for escaped newline. */ |
|
|
|
if (pos > 0 && '\\' == ln[pos - 1]) { |
|
for (j = pos - 1; j >= 0; j--) |
|
if ('\\' != ln[j]) |
|
break; |
|
|
|
if ( ! ((pos - j) % 2)) { |
|
pos--; |
|
lnn++; |
continue; |
continue; |
} |
} |
warnx("%s: line %d too long", p->in, lnn); |
|
return(0); |
|
} |
} |
|
|
line[(int)pos] = 0; |
|
if ( ! mdoc_parseln(p->mdoc, lnn, line)) |
|
return(0); |
|
|
|
|
ln[pos] = 0; |
|
if ( ! mdoc_parseln(p->mdoc, lnn, ln)) |
|
return(0); |
lnn++; |
lnn++; |
pos = 0; |
pos = 0; |
} |
} |
} |
} |
|
|
|
if (pos > 0) |
|
warnx("%s: file not eof-terminated", p->in); |
|
|
|
if (ln) |
|
free(ln); |
return(mdoc_endparse(p->mdoc)); |
return(mdoc_endparse(p->mdoc)); |
} |
} |
|
|