version 1.163, 2017/03/07 20:00:08 |
version 1.184, 2017/07/01 09:47:30 |
|
|
const char *file; /* filename of current input file */ |
const char *file; /* filename of current input file */ |
struct buf *primary; /* buffer currently being parsed */ |
struct buf *primary; /* buffer currently being parsed */ |
struct buf *secondary; /* preprocessed copy of input */ |
struct buf *secondary; /* preprocessed copy of input */ |
const char *defos; /* default operating system */ |
const char *os_s; /* default operating system */ |
mandocmsg mmsg; /* warning/error message handler */ |
mandocmsg mmsg; /* warning/error message handler */ |
enum mandoclevel file_status; /* status of current parse */ |
enum mandoclevel file_status; /* status of current parse */ |
enum mandoclevel wlevel; /* ignore messages below this */ |
enum mandocerr mmin; /* ignore messages below this */ |
int options; /* parser options */ |
int options; /* parser options */ |
int gzip; /* current input file is gzipped */ |
int gzip; /* current input file is gzipped */ |
int filenc; /* encoding of the current file */ |
int filenc; /* encoding of the current file */ |
Line 75 static void mparse_parse_buffer(struct mparse *, str |
|
Line 75 static void mparse_parse_buffer(struct mparse *, str |
|
|
|
static const enum mandocerr mandoclimits[MANDOCLEVEL_MAX] = { |
static const enum mandocerr mandoclimits[MANDOCLEVEL_MAX] = { |
MANDOCERR_OK, |
MANDOCERR_OK, |
|
MANDOCERR_STYLE, |
MANDOCERR_WARNING, |
MANDOCERR_WARNING, |
MANDOCERR_WARNING, |
|
MANDOCERR_ERROR, |
MANDOCERR_ERROR, |
MANDOCERR_UNSUPP, |
MANDOCERR_UNSUPP, |
MANDOCERR_MAX, |
MANDOCERR_MAX, |
Line 86 static const enum mandocerr mandoclimits[MANDOCLEVEL_M |
|
Line 86 static const enum mandocerr mandoclimits[MANDOCLEVEL_M |
|
static const char * const mandocerrs[MANDOCERR_MAX] = { |
static const char * const mandocerrs[MANDOCERR_MAX] = { |
"ok", |
"ok", |
|
|
|
"base system convention", |
|
|
|
"Mdocdate found", |
|
"Mdocdate missing", |
|
"unknown architecture", |
|
"operating system explicitly specified", |
|
"RCS id missing", |
|
"referenced manual not found", |
|
|
|
"generic style suggestion", |
|
|
|
"legacy man(7) date format", |
|
"duplicate RCS id", |
|
"typo in section name", |
|
"useless macro", |
|
"consider using OS macro", |
|
"errnos out of order", |
|
"duplicate errno", |
|
"description line ends with a full stop", |
|
"no blank before trailing delimiter", |
|
"function name without markup", |
|
|
"generic warning", |
"generic warning", |
|
|
/* related to the prologue */ |
/* related to the prologue */ |
Line 130 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
Line 152 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
"blocks badly nested", |
"blocks badly nested", |
"nested displays are not portable", |
"nested displays are not portable", |
"moving content out of list", |
"moving content out of list", |
|
"first macro on line", |
"fill mode already enabled, skipping", |
"fill mode already enabled, skipping", |
"fill mode already disabled, skipping", |
"fill mode already disabled, skipping", |
"line scope broken", |
"line scope broken", |
|
"skipping blank line in line scope", |
|
|
/* related to missing macro arguments */ |
/* related to missing macro arguments */ |
"skipping empty request", |
"skipping empty request", |
Line 147 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
Line 171 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
"missing function name, using \"\"", |
"missing function name, using \"\"", |
"empty head in list item", |
"empty head in list item", |
"empty list item", |
"empty list item", |
|
"missing argument, using next line", |
"missing font type, using \\fR", |
"missing font type, using \\fR", |
"unknown font type, using \\fR", |
"unknown font type, using \\fR", |
"nothing follows prefix", |
"nothing follows prefix", |
Line 168 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
Line 193 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
"unknown AT&T UNIX version", |
"unknown AT&T UNIX version", |
"comma in function argument", |
"comma in function argument", |
"parenthesis in function name", |
"parenthesis in function name", |
|
"unknown library name", |
"invalid content in Rs block", |
"invalid content in Rs block", |
"invalid Boolean argument", |
"invalid Boolean argument", |
"unknown font, skipping request", |
"unknown font, skipping request", |
Line 220 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
Line 246 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
"NOT IMPLEMENTED: Bd -file", |
"NOT IMPLEMENTED: Bd -file", |
"skipping display without arguments", |
"skipping display without arguments", |
"missing list type, using -item", |
"missing list type, using -item", |
|
"argument is not numeric, using 1", |
"missing manual name, using \"\"", |
"missing manual name, using \"\"", |
"uname(3) system call failed, using UNKNOWN", |
"uname(3) system call failed, using UNKNOWN", |
"unknown standard specifier", |
"unknown standard specifier", |
Line 241 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
Line 268 static const char * const mandocerrs[MANDOCERR_MAX] = |
|
|
|
static const char * const mandoclevels[MANDOCLEVEL_MAX] = { |
static const char * const mandoclevels[MANDOCLEVEL_MAX] = { |
"SUCCESS", |
"SUCCESS", |
"RESERVED", |
"STYLE", |
"WARNING", |
"WARNING", |
"ERROR", |
"ERROR", |
"UNSUPP", |
"UNSUPP", |
Line 293 choose_parser(struct mparse *curp) |
|
Line 320 choose_parser(struct mparse *curp) |
|
} |
} |
|
|
if (format == MPARSE_MDOC) { |
if (format == MPARSE_MDOC) { |
mdoc_hash_init(); |
|
curp->man->macroset = MACROSET_MDOC; |
curp->man->macroset = MACROSET_MDOC; |
curp->man->first->tok = TOKEN_NONE; |
if (curp->man->mdocmac == NULL) |
|
curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX); |
} else { |
} else { |
man_hash_init(); |
|
curp->man->macroset = MACROSET_MAN; |
curp->man->macroset = MACROSET_MAN; |
curp->man->first->tok = TOKEN_NONE; |
if (curp->man->manmac == NULL) |
|
curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX); |
} |
} |
|
curp->man->first->tok = TOKEN_NONE; |
} |
} |
|
|
/* |
/* |
Line 318 mparse_buf_r(struct mparse *curp, struct buf blk, size |
|
Line 346 mparse_buf_r(struct mparse *curp, struct buf blk, size |
|
const char *save_file; |
const char *save_file; |
char *cp; |
char *cp; |
size_t pos; /* byte number in the ln buffer */ |
size_t pos; /* byte number in the ln buffer */ |
size_t j; /* auxiliary byte number in the blk buffer */ |
|
enum rofferr rr; |
enum rofferr rr; |
int of; |
int of; |
int lnn; /* line number in the real file */ |
int lnn; /* line number in the real file */ |
Line 400 mparse_buf_r(struct mparse *curp, struct buf blk, size |
|
Line 427 mparse_buf_r(struct mparse *curp, struct buf blk, size |
|
continue; |
continue; |
} |
} |
|
|
/* Trailing backslash = a plain char. */ |
|
|
|
if (blk.buf[i] != '\\' || i + 1 == blk.sz) { |
|
ln.buf[pos++] = blk.buf[i++]; |
|
continue; |
|
} |
|
|
|
/* |
|
* Found escape and at least one other character. |
|
* When it's a newline character, skip it. |
|
* When there is a carriage return in between, |
|
* skip that one as well. |
|
*/ |
|
|
|
if ('\r' == blk.buf[i + 1] && i + 2 < blk.sz && |
|
'\n' == blk.buf[i + 2]) |
|
++i; |
|
if ('\n' == blk.buf[i + 1]) { |
|
i += 2; |
|
++lnn; |
|
continue; |
|
} |
|
|
|
if ('"' == blk.buf[i + 1] || '#' == blk.buf[i + 1]) { |
|
j = i; |
|
i += 2; |
|
/* Comment, skip to end of line */ |
|
for (; i < blk.sz; ++i) { |
|
if (blk.buf[i] != '\n') |
|
continue; |
|
if (blk.buf[i - 1] == ' ' || |
|
blk.buf[i - 1] == '\t') |
|
mandoc_msg( |
|
MANDOCERR_SPACE_EOL, |
|
curp, curp->line, |
|
pos + i-1 - j, NULL); |
|
++i; |
|
++lnn; |
|
break; |
|
} |
|
|
|
/* Backout trailing whitespaces */ |
|
for (; pos > 0; --pos) { |
|
if (ln.buf[pos - 1] != ' ') |
|
break; |
|
if (pos > 2 && ln.buf[pos - 2] == '\\') |
|
break; |
|
} |
|
break; |
|
} |
|
|
|
/* Catch escaped bogus characters. */ |
|
|
|
c = (unsigned char) blk.buf[i+1]; |
|
|
|
if ( ! (isascii(c) && |
|
(isgraph(c) || isblank(c)))) { |
|
mandoc_vmsg(MANDOCERR_CHAR_BAD, curp, |
|
curp->line, pos, "0x%x", c); |
|
i += 2; |
|
ln.buf[pos++] = '?'; |
|
continue; |
|
} |
|
|
|
/* Some other escape sequence, copy & cont. */ |
|
|
|
ln.buf[pos++] = blk.buf[i++]; |
ln.buf[pos++] = blk.buf[i++]; |
ln.buf[pos++] = blk.buf[i++]; |
|
} |
} |
|
|
if (pos >= ln.sz) |
if (pos + 1 >= ln.sz) |
resize_buf(&ln, 256); |
resize_buf(&ln, 256); |
|
|
|
if (i == blk.sz || blk.buf[i] == '\0') |
|
ln.buf[pos++] = '\n'; |
ln.buf[pos] = '\0'; |
ln.buf[pos] = '\0'; |
|
|
/* |
/* |
Line 802 mparse_open(struct mparse *curp, const char *file) |
|
Line 764 mparse_open(struct mparse *curp, const char *file) |
|
} |
} |
|
|
struct mparse * |
struct mparse * |
mparse_alloc(int options, enum mandoclevel wlevel, mandocmsg mmsg, |
mparse_alloc(int options, enum mandocerr mmin, mandocmsg mmsg, |
const char *defos) |
enum mandoc_os os_e, const char *os_s) |
{ |
{ |
struct mparse *curp; |
struct mparse *curp; |
|
|
curp = mandoc_calloc(1, sizeof(struct mparse)); |
curp = mandoc_calloc(1, sizeof(struct mparse)); |
|
|
curp->options = options; |
curp->options = options; |
curp->wlevel = wlevel; |
curp->mmin = mmin; |
curp->mmsg = mmsg; |
curp->mmsg = mmsg; |
curp->defos = defos; |
curp->os_s = os_s; |
|
|
curp->roff = roff_alloc(curp, options); |
curp->roff = roff_alloc(curp, options); |
curp->man = roff_man_alloc( curp->roff, curp, curp->defos, |
curp->man = roff_man_alloc(curp->roff, curp, curp->os_s, |
curp->options & MPARSE_QUICK ? 1 : 0); |
curp->options & MPARSE_QUICK ? 1 : 0); |
if (curp->options & MPARSE_MDOC) { |
if (curp->options & MPARSE_MDOC) { |
mdoc_hash_init(); |
|
curp->man->macroset = MACROSET_MDOC; |
curp->man->macroset = MACROSET_MDOC; |
|
if (curp->man->mdocmac == NULL) |
|
curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX); |
} else if (curp->options & MPARSE_MAN) { |
} else if (curp->options & MPARSE_MAN) { |
man_hash_init(); |
|
curp->man->macroset = MACROSET_MAN; |
curp->man->macroset = MACROSET_MAN; |
|
if (curp->man->manmac == NULL) |
|
curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX); |
} |
} |
curp->man->first->tok = TOKEN_NONE; |
curp->man->first->tok = TOKEN_NONE; |
|
curp->man->meta.os_e = os_e; |
return curp; |
return curp; |
} |
} |
|
|
|
|
mparse_free(struct mparse *curp) |
mparse_free(struct mparse *curp) |
{ |
{ |
|
|
|
roffhash_free(curp->man->mdocmac); |
|
roffhash_free(curp->man->manmac); |
roff_man_free(curp->man); |
roff_man_free(curp->man); |
roff_free(curp->roff); |
roff_free(curp->roff); |
if (curp->secondary) |
if (curp->secondary) |
Line 898 mandoc_msg(enum mandocerr er, struct mparse *m, |
|
Line 865 mandoc_msg(enum mandocerr er, struct mparse *m, |
|
{ |
{ |
enum mandoclevel level; |
enum mandoclevel level; |
|
|
|
if (er < m->mmin && er != MANDOCERR_FILE) |
|
return; |
|
|
level = MANDOCLEVEL_UNSUPP; |
level = MANDOCLEVEL_UNSUPP; |
while (er < mandoclimits[level]) |
while (er < mandoclimits[level]) |
level--; |
level--; |
|
|
if (level < m->wlevel && er != MANDOCERR_FILE) |
|
return; |
|
|
|
if (m->mmsg) |
if (m->mmsg) |
(*m->mmsg)(er, level, m->file, ln, col, msg); |
(*m->mmsg)(er, level, m->file, ln, col, msg); |