version 1.333, 2017/06/10 01:48:53 |
version 1.345, 2017/06/29 15:22:17 |
Line 53 typedef void (*v_post)(POST_ARGS); |
|
Line 53 typedef void (*v_post)(POST_ARGS); |
|
|
|
static int build_list(struct roff_man *, int); |
static int build_list(struct roff_man *, int); |
static void check_text(struct roff_man *, int, int, char *); |
static void check_text(struct roff_man *, int, int, char *); |
static void check_bsd(struct roff_man *, int, int, char *); |
|
static void check_argv(struct roff_man *, |
static void check_argv(struct roff_man *, |
struct roff_node *, struct mdoc_argv *); |
struct roff_node *, struct mdoc_argv *); |
static void check_args(struct roff_man *, struct roff_node *); |
static void check_args(struct roff_man *, struct roff_node *); |
|
static void check_toptext(struct roff_man *, int, int, const char *); |
static int child_an(const struct roff_node *); |
static int child_an(const struct roff_node *); |
static size_t macro2len(enum roff_tok); |
static size_t macro2len(enum roff_tok); |
static void rewrite_macro2len(struct roff_man *, char **); |
static void rewrite_macro2len(struct roff_man *, char **); |
|
static int similar(const char *, const char *); |
|
|
static void post_an(POST_ARGS); |
static void post_an(POST_ARGS); |
static void post_an_norm(POST_ARGS); |
static void post_an_norm(POST_ARGS); |
Line 184 static const v_post __mdoc_valids[MDOC_MAX - MDOC_Dd] |
|
Line 185 static const v_post __mdoc_valids[MDOC_MAX - MDOC_Dd] |
|
NULL, /* Eo */ |
NULL, /* Eo */ |
post_xx, /* Fx */ |
post_xx, /* Fx */ |
post_delim, /* Ms */ |
post_delim, /* Ms */ |
post_delim, /* No */ |
NULL, /* No */ |
post_ns, /* Ns */ |
post_ns, /* Ns */ |
post_xx, /* Nx */ |
post_xx, /* Nx */ |
post_xx, /* Ox */ |
post_xx, /* Ox */ |
Line 304 mdoc_node_validate(struct roff_man *mdoc) |
|
Line 305 mdoc_node_validate(struct roff_man *mdoc) |
|
if (n->sec != SEC_SYNOPSIS || |
if (n->sec != SEC_SYNOPSIS || |
(n->parent->tok != MDOC_Cd && n->parent->tok != MDOC_Fd)) |
(n->parent->tok != MDOC_Cd && n->parent->tok != MDOC_Fd)) |
check_text(mdoc, n->line, n->pos, n->string); |
check_text(mdoc, n->line, n->pos, n->string); |
if (n->parent->tok == MDOC_Sh || |
if (n->parent->tok == MDOC_It || |
n->parent->tok == MDOC_Ss || |
(n->parent->type == ROFFT_BODY && |
n->parent->tok == MDOC_It) |
(n->parent->tok == MDOC_Sh || |
check_bsd(mdoc, n->line, n->pos, n->string); |
n->parent->tok == MDOC_Ss))) |
|
check_toptext(mdoc, n->line, n->pos, n->string); |
break; |
break; |
case ROFFT_EQN: |
case ROFFT_EQN: |
case ROFFT_TBL: |
case ROFFT_TBL: |
Line 390 check_text(struct roff_man *mdoc, int ln, int pos, cha |
|
Line 392 check_text(struct roff_man *mdoc, int ln, int pos, cha |
|
} |
} |
|
|
static void |
static void |
check_bsd(struct roff_man *mdoc, int ln, int pos, char *p) |
check_toptext(struct roff_man *mdoc, int ln, int pos, const char *p) |
{ |
{ |
const char *cp; |
const char *cp, *cpr; |
|
|
|
if (*p == '\0') |
|
return; |
|
|
if ((cp = strstr(p, "OpenBSD")) != NULL) |
if ((cp = strstr(p, "OpenBSD")) != NULL) |
mandoc_msg(MANDOCERR_BX, mdoc->parse, |
mandoc_msg(MANDOCERR_BX, mdoc->parse, |
ln, pos + (cp - p), "Ox"); |
ln, pos + (cp - p), "Ox"); |
Line 406 check_bsd(struct roff_man *mdoc, int ln, int pos, char |
|
Line 411 check_bsd(struct roff_man *mdoc, int ln, int pos, char |
|
if ((cp = strstr(p, "DragonFly")) != NULL) |
if ((cp = strstr(p, "DragonFly")) != NULL) |
mandoc_msg(MANDOCERR_BX, mdoc->parse, |
mandoc_msg(MANDOCERR_BX, mdoc->parse, |
ln, pos + (cp - p), "Dx"); |
ln, pos + (cp - p), "Dx"); |
|
|
|
cp = p; |
|
while ((cp = strstr(cp + 1, "()")) != NULL) { |
|
for (cpr = cp - 1; cpr >= p; cpr--) |
|
if (*cpr != '_' && !isalnum((unsigned char)*cpr)) |
|
break; |
|
if ((cpr < p || *cpr == ' ') && cpr + 1 < cp) { |
|
cpr++; |
|
mandoc_vmsg(MANDOCERR_FUNC, mdoc->parse, |
|
ln, pos + (cpr - p), |
|
"%.*s()", (int)(cp - cpr), cpr); |
|
} |
|
} |
} |
} |
|
|
static void |
static void |
post_delim(POST_ARGS) |
post_delim(POST_ARGS) |
{ |
{ |
const struct roff_node *nch; |
const struct roff_node *nch; |
const char *lc; |
const char *lc, *cp; |
|
int nw; |
enum mdelim delim; |
enum mdelim delim; |
|
enum roff_tok tok; |
|
|
|
/* |
|
* Find candidates: at least two bytes, |
|
* the last one a closing or middle delimiter. |
|
*/ |
|
|
|
tok = mdoc->last->tok; |
nch = mdoc->last->last; |
nch = mdoc->last->last; |
if (nch == NULL || nch->type != ROFFT_TEXT) |
if (nch == NULL || nch->type != ROFFT_TEXT) |
return; |
return; |
Line 424 post_delim(POST_ARGS) |
|
Line 450 post_delim(POST_ARGS) |
|
delim = mdoc_isdelim(lc); |
delim = mdoc_isdelim(lc); |
if (delim == DELIM_NONE || delim == DELIM_OPEN) |
if (delim == DELIM_NONE || delim == DELIM_OPEN) |
return; |
return; |
|
|
|
/* |
|
* Reduce false positives by allowing various cases. |
|
*/ |
|
|
|
/* Escaped delimiters. */ |
|
if (lc > nch->string + 1 && lc[-2] == '\\' && |
|
(lc[-1] == '&' || lc[-1] == 'e')) |
|
return; |
|
|
|
/* Specific byte sequences. */ |
|
switch (*lc) { |
|
case ')': |
|
for (cp = lc; cp >= nch->string; cp--) |
|
if (*cp == '(') |
|
return; |
|
break; |
|
case '.': |
|
if (lc > nch->string + 1 && lc[-2] == '.' && lc[-1] == '.') |
|
return; |
|
if (lc[-1] == '.') |
|
return; |
|
break; |
|
case ';': |
|
if (tok == MDOC_Vt) |
|
return; |
|
break; |
|
case '?': |
|
if (lc[-1] == '?') |
|
return; |
|
break; |
|
case ']': |
|
for (cp = lc; cp >= nch->string; cp--) |
|
if (*cp == '[') |
|
return; |
|
break; |
|
case '|': |
|
if (lc == nch->string + 1 && lc[-1] == '|') |
|
return; |
|
default: |
|
break; |
|
} |
|
|
|
/* Exactly two non-alphanumeric bytes. */ |
|
if (lc == nch->string + 1 && !isalnum((unsigned char)lc[-1])) |
|
return; |
|
|
|
/* At least three alphabetic words with a sentence ending. */ |
|
if (strchr("!.:?", *lc) != NULL && (tok == MDOC_Em || |
|
tok == MDOC_Li || tok == MDOC_Po || tok == MDOC_Pq || |
|
tok == MDOC_Sy)) { |
|
nw = 0; |
|
for (cp = lc - 1; cp >= nch->string; cp--) { |
|
if (*cp == ' ') { |
|
nw++; |
|
if (cp > nch->string && cp[-1] == ',') |
|
cp--; |
|
} else if (isalpha((unsigned int)*cp)) { |
|
if (nw > 1) |
|
return; |
|
} else |
|
break; |
|
} |
|
} |
|
|
mandoc_vmsg(MANDOCERR_DELIM, mdoc->parse, |
mandoc_vmsg(MANDOCERR_DELIM, mdoc->parse, |
nch->line, nch->pos + (lc - nch->string), |
nch->line, nch->pos + (lc - nch->string), |
"%s%s %s", roff_name[mdoc->last->tok], |
"%s%s %s", roff_name[tok], |
nch == mdoc->last->child ? "" : " ...", nch->string); |
nch == mdoc->last->child ? "" : " ...", nch->string); |
} |
} |
|
|
Line 1369 post_it(POST_ARGS) |
|
Line 1460 post_it(POST_ARGS) |
|
|
|
assert(nit->head->child == NULL); |
assert(nit->head->child == NULL); |
|
|
i = 0; |
if (nit->head->next->child == NULL && |
for (nch = nit->child; nch != NULL; nch = nch->next) |
nit->head->next->next == NULL) { |
if (nch->type == ROFFT_BODY) |
mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse, |
i++; |
nit->line, nit->pos, "It"); |
|
roff_node_delete(mdoc, nit); |
|
break; |
|
} |
|
|
|
i = 0; |
|
for (nch = nit->child; nch != NULL; nch = nch->next) { |
|
if (nch->type != ROFFT_BODY) |
|
continue; |
|
if (i++ && nch->flags & NODE_LINE) |
|
mandoc_msg(MANDOCERR_TA_LINE, mdoc->parse, |
|
nch->line, nch->pos, "Ta"); |
|
} |
if (i < cols || i > cols + 1) |
if (i < cols || i > cols + 1) |
mandoc_vmsg(MANDOCERR_BL_COL, |
mandoc_vmsg(MANDOCERR_BL_COL, |
mdoc->parse, nit->line, nit->pos, |
mdoc->parse, nit->line, nit->pos, |
"%d columns, %d cells", cols, i); |
"%d columns, %d cells", cols, i); |
|
else if (nit->head->next->child != NULL && |
|
nit->head->next->child->line > nit->line) |
|
mandoc_msg(MANDOCERR_IT_NOARG, mdoc->parse, |
|
nit->line, nit->pos, "Bl -column It"); |
break; |
break; |
default: |
default: |
abort(); |
abort(); |
Line 1619 post_bl(POST_ARGS) |
|
Line 1725 post_bl(POST_ARGS) |
|
nchild = nnext; |
nchild = nnext; |
} |
} |
|
|
if (mdoc->meta.os_e != MDOC_OS_NETBSD) |
if (mdoc->meta.os_e != MANDOC_OS_NETBSD) |
return; |
return; |
|
|
prev_Er = NULL; |
prev_Er = NULL; |
Line 1638 post_bl(POST_ARGS) |
|
Line 1744 post_bl(POST_ARGS) |
|
if (order > 0) |
if (order > 0) |
mandoc_vmsg(MANDOCERR_ER_ORDER, |
mandoc_vmsg(MANDOCERR_ER_ORDER, |
mdoc->parse, nnext->line, nnext->pos, |
mdoc->parse, nnext->line, nnext->pos, |
"Er %s %s", prev_Er, nnext->string); |
"Er %s %s (NetBSD)", |
|
prev_Er, nnext->string); |
else if (order == 0) |
else if (order == 0) |
mandoc_vmsg(MANDOCERR_ER_REP, |
mandoc_vmsg(MANDOCERR_ER_REP, |
mdoc->parse, nnext->line, nnext->pos, |
mdoc->parse, nnext->line, nnext->pos, |
"Er %s", prev_Er); |
"Er %s (NetBSD)", prev_Er); |
} |
} |
prev_Er = nnext->string; |
prev_Er = nnext->string; |
} |
} |
Line 1695 post_sm(POST_ARGS) |
|
Line 1802 post_sm(POST_ARGS) |
|
static void |
static void |
post_root(POST_ARGS) |
post_root(POST_ARGS) |
{ |
{ |
|
const char *openbsd_arch[] = { |
|
"alpha", "amd64", "arm64", "armv7", "hppa", "i386", |
|
"landisk", "loongson", "luna88k", "macppc", "mips64", |
|
"octeon", "sgi", "socppc", "sparc64", NULL |
|
}; |
|
const char *netbsd_arch[] = { |
|
"acorn26", "acorn32", "algor", "alpha", "amiga", |
|
"arc", "atari", |
|
"bebox", "cats", "cesfic", "cobalt", "dreamcast", |
|
"emips", "evbarm", "evbmips", "evbppc", "evbsh3", "evbsh5", |
|
"hp300", "hpcarm", "hpcmips", "hpcsh", "hppa", |
|
"i386", "ibmnws", "luna68k", |
|
"mac68k", "macppc", "mipsco", "mmeye", "mvme68k", "mvmeppc", |
|
"netwinder", "news68k", "newsmips", "next68k", |
|
"pc532", "playstation2", "pmax", "pmppc", "prep", |
|
"sandpoint", "sbmips", "sgimips", "shark", |
|
"sparc", "sparc64", "sun2", "sun3", |
|
"vax", "walnut", "x68k", "x86", "x86_64", "xen", NULL |
|
}; |
|
const char **arches[] = { NULL, netbsd_arch, openbsd_arch }; |
|
|
struct roff_node *n; |
struct roff_node *n; |
|
const char **arch; |
|
|
/* Add missing prologue data. */ |
/* Add missing prologue data. */ |
|
|
if (mdoc->meta.date == NULL) |
if (mdoc->meta.date == NULL) |
mdoc->meta.date = mdoc->quick ? |
mdoc->meta.date = mdoc->quick ? mandoc_strdup("") : |
mandoc_strdup("") : |
mandoc_normdate(mdoc, NULL, 0, 0); |
mandoc_normdate(mdoc->parse, NULL, 0, 0); |
|
|
|
if (mdoc->meta.title == NULL) { |
if (mdoc->meta.title == NULL) { |
mandoc_msg(MANDOCERR_DT_NOTITLE, |
mandoc_msg(MANDOCERR_DT_NOTITLE, |
Line 1717 post_root(POST_ARGS) |
|
Line 1845 post_root(POST_ARGS) |
|
mandoc_msg(MANDOCERR_OS_MISSING, |
mandoc_msg(MANDOCERR_OS_MISSING, |
mdoc->parse, 0, 0, NULL); |
mdoc->parse, 0, 0, NULL); |
mdoc->meta.os = mandoc_strdup(""); |
mdoc->meta.os = mandoc_strdup(""); |
|
} else if (mdoc->meta.os_e && |
|
(mdoc->meta.rcsids & (1 << mdoc->meta.os_e)) == 0) |
|
mandoc_msg(MANDOCERR_RCS_MISSING, mdoc->parse, 0, 0, |
|
mdoc->meta.os_e == MANDOC_OS_OPENBSD ? |
|
"(OpenBSD)" : "(NetBSD)"); |
|
|
|
if (mdoc->meta.arch != NULL && |
|
(arch = arches[mdoc->meta.os_e]) != NULL) { |
|
while (*arch != NULL && strcmp(*arch, mdoc->meta.arch)) |
|
arch++; |
|
if (*arch == NULL) { |
|
n = mdoc->first->child; |
|
while (n->tok != MDOC_Dt) |
|
n = n->next; |
|
n = n->child->next->next; |
|
mandoc_vmsg(MANDOCERR_ARCH_BAD, |
|
mdoc->parse, n->line, n->pos, |
|
"Dt ... %s %s", mdoc->meta.arch, |
|
mdoc->meta.os_e == MANDOC_OS_OPENBSD ? |
|
"(OpenBSD)" : "(NetBSD)"); |
|
} |
} |
} |
|
|
/* Check that we begin with a proper `Sh'. */ |
/* Check that we begin with a proper `Sh'. */ |
Line 1849 post_hyph(POST_ARGS) |
|
Line 1998 post_hyph(POST_ARGS) |
|
static void |
static void |
post_ns(POST_ARGS) |
post_ns(POST_ARGS) |
{ |
{ |
|
struct roff_node *n; |
|
|
if (mdoc->last->flags & NODE_LINE) |
n = mdoc->last; |
|
if (n->flags & NODE_LINE || |
|
(n->next != NULL && n->next->flags & NODE_DELIMC)) |
mandoc_msg(MANDOCERR_NS_SKIP, mdoc->parse, |
mandoc_msg(MANDOCERR_NS_SKIP, mdoc->parse, |
mdoc->last->line, mdoc->last->pos, NULL); |
n->line, n->pos, NULL); |
} |
} |
|
|
static void |
static void |
Line 2015 post_sh_authors(POST_ARGS) |
|
Line 2167 post_sh_authors(POST_ARGS) |
|
mdoc->last->line, mdoc->last->pos, NULL); |
mdoc->last->line, mdoc->last->pos, NULL); |
} |
} |
|
|
|
/* |
|
* Return an upper bound for the string distance (allowing |
|
* transpositions). Not a full Levenshtein implementation |
|
* because Levenshtein is quadratic in the string length |
|
* and this function is called for every standard name, |
|
* so the check for each custom name would be cubic. |
|
* The following crude heuristics is linear, resulting |
|
* in quadratic behaviour for checking one custom name, |
|
* which does not cause measurable slowdown. |
|
*/ |
|
static int |
|
similar(const char *s1, const char *s2) |
|
{ |
|
const int maxdist = 3; |
|
int dist = 0; |
|
|
|
while (s1[0] != '\0' && s2[0] != '\0') { |
|
if (s1[0] == s2[0]) { |
|
s1++; |
|
s2++; |
|
continue; |
|
} |
|
if (++dist > maxdist) |
|
return INT_MAX; |
|
if (s1[1] == s2[1]) { /* replacement */ |
|
s1++; |
|
s2++; |
|
} else if (s1[0] == s2[1] && s1[1] == s2[0]) { |
|
s1 += 2; /* transposition */ |
|
s2 += 2; |
|
} else if (s1[0] == s2[1]) /* insertion */ |
|
s2++; |
|
else if (s1[1] == s2[0]) /* deletion */ |
|
s1++; |
|
else |
|
return INT_MAX; |
|
} |
|
dist += strlen(s1) + strlen(s2); |
|
return dist > maxdist ? INT_MAX : dist; |
|
} |
|
|
static void |
static void |
post_sh_head(POST_ARGS) |
post_sh_head(POST_ARGS) |
{ |
{ |
struct roff_node *nch; |
struct roff_node *nch; |
const char *goodsec; |
const char *goodsec; |
|
const char *const *testsec; |
|
int dist, mindist; |
enum roff_sec sec; |
enum roff_sec sec; |
|
|
/* |
/* |
Line 2057 post_sh_head(POST_ARGS) |
|
Line 2252 post_sh_head(POST_ARGS) |
|
|
|
/* We don't care about custom sections after this. */ |
/* We don't care about custom sections after this. */ |
|
|
if (sec == SEC_CUSTOM) |
if (sec == SEC_CUSTOM) { |
|
if ((nch = mdoc->last->child) == NULL || |
|
nch->type != ROFFT_TEXT || nch->next != NULL) |
|
return; |
|
goodsec = NULL; |
|
mindist = INT_MAX; |
|
for (testsec = secnames + 1; *testsec != NULL; testsec++) { |
|
dist = similar(nch->string, *testsec); |
|
if (dist < mindist) { |
|
goodsec = *testsec; |
|
mindist = dist; |
|
} |
|
} |
|
if (goodsec != NULL) |
|
mandoc_vmsg(MANDOCERR_SEC_TYPO, mdoc->parse, |
|
nch->line, nch->pos, "Sh %s instead of %s", |
|
nch->string, goodsec); |
return; |
return; |
|
} |
|
|
/* |
/* |
* Check whether our non-custom section is being repeated or is |
* Check whether our non-custom section is being repeated or is |
Line 2258 post_dd(POST_ARGS) |
|
Line 2470 post_dd(POST_ARGS) |
|
|
|
if (n->child == NULL || n->child->string[0] == '\0') { |
if (n->child == NULL || n->child->string[0] == '\0') { |
mdoc->meta.date = mdoc->quick ? mandoc_strdup("") : |
mdoc->meta.date = mdoc->quick ? mandoc_strdup("") : |
mandoc_normdate(mdoc->parse, NULL, n->line, n->pos); |
mandoc_normdate(mdoc, NULL, n->line, n->pos); |
return; |
return; |
} |
} |
|
|
Line 2267 post_dd(POST_ARGS) |
|
Line 2479 post_dd(POST_ARGS) |
|
if (mdoc->quick) |
if (mdoc->quick) |
mdoc->meta.date = datestr; |
mdoc->meta.date = datestr; |
else { |
else { |
mdoc->meta.date = mandoc_normdate(mdoc->parse, |
mdoc->meta.date = mandoc_normdate(mdoc, |
datestr, n->line, n->pos); |
datestr, n->line, n->pos); |
free(datestr); |
free(datestr); |
} |
} |
Line 2456 post_os(POST_ARGS) |
|
Line 2668 post_os(POST_ARGS) |
|
if (mdoc->meta.os) |
if (mdoc->meta.os) |
goto out; |
goto out; |
|
|
if (mdoc->defos) { |
if (mdoc->os_s != NULL) { |
mdoc->meta.os = mandoc_strdup(mdoc->defos); |
mdoc->meta.os = mandoc_strdup(mdoc->os_s); |
goto out; |
goto out; |
} |
} |
|
|
Line 2476 post_os(POST_ARGS) |
|
Line 2688 post_os(POST_ARGS) |
|
mdoc->meta.os = mandoc_strdup(defbuf); |
mdoc->meta.os = mandoc_strdup(defbuf); |
#endif /*!OSNAME*/ |
#endif /*!OSNAME*/ |
|
|
out: mdoc->meta.os_e = strstr(mdoc->meta.os, "OpenBSD") != NULL ? |
out: |
MDOC_OS_OPENBSD : strstr(mdoc->meta.os, "NetBSD") != NULL ? |
if (mdoc->meta.os_e == MANDOC_OS_OTHER) { |
MDOC_OS_NETBSD : MDOC_OS_OTHER; |
if (strstr(mdoc->meta.os, "OpenBSD") != NULL) |
|
mdoc->meta.os_e = MANDOC_OS_OPENBSD; |
|
else if (strstr(mdoc->meta.os, "NetBSD") != NULL) |
|
mdoc->meta.os_e = MANDOC_OS_NETBSD; |
|
} |
|
|
|
/* |
|
* This is the earliest point where we can check |
|
* Mdocdate conventions because we don't know |
|
* the operating system earlier. |
|
*/ |
|
|
|
if (n->child != NULL) |
|
mandoc_vmsg(MANDOCERR_OS_ARG, mdoc->parse, |
|
n->child->line, n->child->pos, |
|
"Os %s (%s)", n->child->string, |
|
mdoc->meta.os_e == MANDOC_OS_OPENBSD ? |
|
"OpenBSD" : "NetBSD"); |
|
|
|
while (n->tok != MDOC_Dd) |
|
if ((n = n->prev) == NULL) |
|
return; |
|
if ((n = n->child) == NULL) |
|
return; |
|
if (strncmp(n->string, "$" "Mdocdate", 9)) { |
|
if (mdoc->meta.os_e == MANDOC_OS_OPENBSD) |
|
mandoc_vmsg(MANDOCERR_MDOCDATE_MISSING, |
|
mdoc->parse, n->line, n->pos, |
|
"Dd %s (OpenBSD)", n->string); |
|
} else { |
|
if (mdoc->meta.os_e == MANDOC_OS_NETBSD) |
|
mandoc_vmsg(MANDOCERR_MDOCDATE, |
|
mdoc->parse, n->line, n->pos, |
|
"Dd %s (NetBSD)", n->string); |
|
} |
} |
} |
|
|
enum roff_sec |
enum roff_sec |