version 1.20, 2009/07/06 09:21:24 |
version 1.24, 2009/07/07 09:52:08 |
|
|
#define PRE_ARGS struct mdoc *mdoc, const struct mdoc_node *n |
#define PRE_ARGS struct mdoc *mdoc, const struct mdoc_node *n |
#define POST_ARGS struct mdoc *mdoc |
#define POST_ARGS struct mdoc *mdoc |
|
|
enum merr { |
|
ETOOLONG, |
|
EESCAPE, |
|
EPRINT, |
|
ENODATA, |
|
ENOPROLOGUE, |
|
ELINE, |
|
EATT, |
|
ENAME, |
|
ELISTTYPE, |
|
EDISPTYPE, |
|
EMULTIDISP, |
|
ESECNAME, |
|
EMULTILIST, |
|
EARGREP, |
|
EBOOL, |
|
ECOLMIS, |
|
ENESTDISP |
|
}; |
|
|
|
enum mwarn { |
|
WPRINT, |
|
WNOWIDTH, |
|
WMISSWIDTH, |
|
WESCAPE, |
|
WWRONGMSEC, |
|
WSECOOO, |
|
WSECREP, |
|
WBADSTAND, |
|
WNAMESECINC, |
|
WNOMULTILINE, |
|
WMULTILINE, |
|
WLINE, |
|
WNOLINE, |
|
WPROLOOO, |
|
WPROLREP, |
|
WARGVAL, |
|
WBADSEC, |
|
WBADMSEC |
|
}; |
|
|
|
typedef int (*v_pre)(PRE_ARGS); |
typedef int (*v_pre)(PRE_ARGS); |
typedef int (*v_post)(POST_ARGS); |
typedef int (*v_post)(POST_ARGS); |
|
|
|
|
v_post *post; |
v_post *post; |
}; |
}; |
|
|
static int pwarn(struct mdoc *, int, int, enum mwarn); |
|
static int perr(struct mdoc *, int, int, enum merr); |
|
static int check_parent(PRE_ARGS, int, enum mdoc_type); |
static int check_parent(PRE_ARGS, int, enum mdoc_type); |
static int check_msec(PRE_ARGS, ...); |
static int check_msec(PRE_ARGS, ...); |
static int check_sec(PRE_ARGS, ...); |
static int check_sec(PRE_ARGS, ...); |
Line 146 static int post_sh_body(POST_ARGS); |
|
Line 104 static int post_sh_body(POST_ARGS); |
|
static int post_sh_head(POST_ARGS); |
static int post_sh_head(POST_ARGS); |
static int post_st(POST_ARGS); |
static int post_st(POST_ARGS); |
|
|
#define vwarn(m, t) nwarn((m), (m)->last, (t)) |
|
#define verr(m, t) nerr((m), (m)->last, (t)) |
|
#define nwarn(m, n, t) pwarn((m), (n)->line, (n)->pos, (t)) |
|
#define nerr(m, n, t) perr((m), (n)->line, (n)->pos, (t)) |
|
|
|
static v_pre pres_an[] = { pre_an, NULL }; |
static v_pre pres_an[] = { pre_an, NULL }; |
static v_pre pres_bd[] = { pre_display, pre_bd, NULL }; |
static v_pre pres_bd[] = { pre_display, pre_bd, NULL }; |
static v_pre pres_bl[] = { pre_bl, NULL }; |
static v_pre pres_bl[] = { pre_bl, NULL }; |
Line 377 mdoc_valid_post(struct mdoc *mdoc) |
|
Line 330 mdoc_valid_post(struct mdoc *mdoc) |
|
|
|
|
|
static int |
static int |
perr(struct mdoc *m, int line, int pos, enum merr type) |
|
{ |
|
char *p; |
|
|
|
p = NULL; |
|
switch (type) { |
|
case (ETOOLONG): |
|
p = "text argument too long"; |
|
break; |
|
case (EESCAPE): |
|
p = "invalid escape sequence"; |
|
break; |
|
case (EPRINT): |
|
p = "invalid character"; |
|
break; |
|
case (ENESTDISP): |
|
p = "displays may not be nested"; |
|
break; |
|
case (EBOOL): |
|
p = "expected boolean value"; |
|
break; |
|
case (EARGREP): |
|
p = "argument repeated"; |
|
break; |
|
case (EMULTIDISP): |
|
p = "multiple display types specified"; |
|
break; |
|
case (EMULTILIST): |
|
p = "multiple list types specified"; |
|
break; |
|
case (ELISTTYPE): |
|
p = "missing list type"; |
|
break; |
|
case (EDISPTYPE): |
|
p = "missing display type"; |
|
break; |
|
case (ESECNAME): |
|
p = "the NAME section must come first"; |
|
break; |
|
case (ELINE): |
|
p = "expected line arguments"; |
|
break; |
|
case (ENOPROLOGUE): |
|
p = "document has no prologue"; |
|
break; |
|
case (ENODATA): |
|
p = "document has no data"; |
|
break; |
|
case (ECOLMIS): |
|
p = "column syntax style mismatch"; |
|
break; |
|
case (EATT): |
|
p = "expected valid AT&T symbol"; |
|
break; |
|
case (ENAME): |
|
p = "default name not yet set"; |
|
break; |
|
} |
|
assert(p); |
|
return(mdoc_perr(m, line, pos, p)); |
|
} |
|
|
|
|
|
static int |
|
pwarn(struct mdoc *m, int line, int pos, enum mwarn type) |
|
{ |
|
char *p; |
|
|
|
p = NULL; |
|
|
|
switch (type) { |
|
case (WBADMSEC): |
|
p = "inappropriate manual section"; |
|
break; |
|
case (WBADSEC): |
|
p = "inappropriate document section"; |
|
break; |
|
case (WARGVAL): |
|
p = "argument value suggested"; |
|
break; |
|
case (WPROLREP): |
|
p = "prologue macros repeated"; |
|
break; |
|
case (WPROLOOO): |
|
p = "prologue macros out-of-order"; |
|
break; |
|
case (WNOWIDTH): |
|
p = "superfluous width argument"; |
|
break; |
|
case (WMISSWIDTH): |
|
p = "missing width argument"; |
|
break; |
|
case (WPRINT): |
|
p = "invalid character"; |
|
break; |
|
case (WESCAPE): |
|
p = "invalid escape sequence"; |
|
break; |
|
case (WNOLINE): |
|
p = "suggested no line arguments"; |
|
break; |
|
case (WLINE): |
|
p = "suggested line arguments"; |
|
break; |
|
case (WMULTILINE): |
|
p = "suggested multi-line arguments"; |
|
break; |
|
case (WNOMULTILINE): |
|
p = "suggested no multi-line arguments"; |
|
break; |
|
case (WWRONGMSEC): |
|
p = "document section in wrong manual section"; |
|
break; |
|
case (WSECOOO): |
|
p = "document section out of conventional order"; |
|
break; |
|
case (WSECREP): |
|
p = "document section repeated"; |
|
break; |
|
case (WBADSTAND): |
|
p = "unknown standard"; |
|
break; |
|
case (WNAMESECINC): |
|
p = "NAME section contents incomplete/badly-ordered"; |
|
break; |
|
} |
|
|
|
assert(p); |
|
return(mdoc_pwarn(m, line, pos, p)); |
|
} |
|
|
|
|
|
static int |
|
warn_print(struct mdoc *m, int ln, int pos) |
warn_print(struct mdoc *m, int ln, int pos) |
{ |
{ |
|
|
if (MDOC_IGN_CHARS & m->pflags) |
if (MDOC_IGN_CHARS & m->pflags) |
return(pwarn(m, ln, pos, WPRINT)); |
return(mdoc_pwarn(m, ln, pos, EPRINT)); |
return(perr(m, ln, pos, EPRINT)); |
return(mdoc_perr(m, ln, pos, EPRINT)); |
} |
} |
|
|
|
|
Line 523 warn_count(struct mdoc *m, const char *k, |
|
Line 344 warn_count(struct mdoc *m, const char *k, |
|
int want, const char *v, int has) |
int want, const char *v, int has) |
{ |
{ |
|
|
return(mdoc_warn(m, "suggests %s %s %d (has %d)", |
return(mdoc_vwarn(m, m->last->line, m->last->pos, |
v, k, want, has)); |
"suggests %s %s %d (has %d)", v, k, want, has)); |
} |
} |
|
|
|
|
Line 533 err_count(struct mdoc *m, const char *k, |
|
Line 354 err_count(struct mdoc *m, const char *k, |
|
int want, const char *v, int has) |
int want, const char *v, int has) |
{ |
{ |
|
|
return(mdoc_err(m, |
return(mdoc_verr(m, m->last->line, m->last->pos, |
"requires %s %s %d (has %d)", v, k, want, has)); |
"requires %s %s %d (has %d)", v, k, want, has)); |
} |
} |
|
|
Line 607 check_stdarg(PRE_ARGS) |
|
Line 428 check_stdarg(PRE_ARGS) |
|
if (n->args && 1 == n->args->argc) |
if (n->args && 1 == n->args->argc) |
if (MDOC_Std == n->args->argv[0].arg) |
if (MDOC_Std == n->args->argv[0].arg) |
return(1); |
return(1); |
return(nwarn(mdoc, n, WARGVAL)); |
return(mdoc_nwarn(mdoc, n, EARGVAL)); |
} |
} |
|
|
|
|
Line 631 check_sec(PRE_ARGS, ...) |
|
Line 452 check_sec(PRE_ARGS, ...) |
|
} |
} |
|
|
va_end(ap); |
va_end(ap); |
return(nwarn(mdoc, n, WBADSEC)); |
return(mdoc_nwarn(mdoc, n, EBADSEC)); |
} |
} |
|
|
|
|
Line 653 check_msec(PRE_ARGS, ...) |
|
Line 474 check_msec(PRE_ARGS, ...) |
|
} |
} |
|
|
va_end(ap); |
va_end(ap); |
return(nwarn(mdoc, n, WBADMSEC)); |
return(mdoc_nwarn(mdoc, n, EBADMSEC)); |
} |
} |
|
|
|
|
Line 688 check_argv(struct mdoc *m, const struct mdoc_node *n, |
|
Line 509 check_argv(struct mdoc *m, const struct mdoc_node *n, |
|
/* `Nm' name must be set. */ |
/* `Nm' name must be set. */ |
if (v->sz || m->meta.name) |
if (v->sz || m->meta.name) |
return(1); |
return(1); |
return(nerr(m, n, ENAME)); |
return(mdoc_nerr(m, n, ENAME)); |
} |
} |
|
|
return(1); |
return(1); |
Line 719 check_text(struct mdoc *mdoc, int line, int pos, const |
|
Line 540 check_text(struct mdoc *mdoc, int line, int pos, const |
|
continue; |
continue; |
} |
} |
if ( ! (MDOC_IGN_ESCAPE & mdoc->pflags)) |
if ( ! (MDOC_IGN_ESCAPE & mdoc->pflags)) |
return(perr(mdoc, line, pos, EESCAPE)); |
return(mdoc_perr(mdoc, line, pos, EESCAPE)); |
if ( ! pwarn(mdoc, line, pos, WESCAPE)) |
if ( ! mdoc_perr(mdoc, line, pos, EESCAPE)) |
return(0); |
return(0); |
} |
} |
|
|
Line 739 check_parent(PRE_ARGS, int tok, enum mdoc_type t) |
|
Line 560 check_parent(PRE_ARGS, int tok, enum mdoc_type t) |
|
(t == n->parent->type)) |
(t == n->parent->type)) |
return(1); |
return(1); |
|
|
return(mdoc_nerr(mdoc, n, "require parent %s", |
return(mdoc_verr(mdoc, n->line, n->pos, "require parent %s", |
MDOC_ROOT == t ? "<root>" : mdoc_macronames[tok])); |
MDOC_ROOT == t ? "<root>" : mdoc_macronames[tok])); |
} |
} |
|
|
Line 763 pre_display(PRE_ARGS) |
|
Line 584 pre_display(PRE_ARGS) |
|
if (NULL == node) |
if (NULL == node) |
return(1); |
return(1); |
|
|
return(nerr(mdoc, n, ENESTDISP)); |
return(mdoc_nerr(mdoc, n, ENESTDISP)); |
} |
} |
|
|
|
|
Line 775 pre_bl(PRE_ARGS) |
|
Line 596 pre_bl(PRE_ARGS) |
|
if (MDOC_BLOCK != n->type) |
if (MDOC_BLOCK != n->type) |
return(1); |
return(1); |
if (NULL == n->args) |
if (NULL == n->args) |
return(nerr(mdoc, n, ELISTTYPE)); |
return(mdoc_nerr(mdoc, n, ELISTTYPE)); |
|
|
/* Make sure that only one type of list is specified. */ |
/* Make sure that only one type of list is specified. */ |
|
|
Line 806 pre_bl(PRE_ARGS) |
|
Line 627 pre_bl(PRE_ARGS) |
|
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case (MDOC_Column): |
case (MDOC_Column): |
if (-1 != type) |
if (-1 != type) |
return(nerr(mdoc, n, EMULTILIST)); |
return(mdoc_nerr(mdoc, n, EMULTILIST)); |
type = n->args->argv[pos].arg; |
type = n->args->argv[pos].arg; |
break; |
break; |
case (MDOC_Width): |
case (MDOC_Width): |
if (-1 != width) |
if (-1 != width) |
return(nerr(mdoc, n, EARGREP)); |
return(mdoc_nerr(mdoc, n, EARGREP)); |
width = n->args->argv[pos].arg; |
width = n->args->argv[pos].arg; |
break; |
break; |
case (MDOC_Offset): |
case (MDOC_Offset): |
if (-1 != offset) |
if (-1 != offset) |
return(nerr(mdoc, n, EARGREP)); |
return(mdoc_nerr(mdoc, n, EARGREP)); |
offset = n->args->argv[pos].arg; |
offset = n->args->argv[pos].arg; |
break; |
break; |
default: |
default: |
Line 824 pre_bl(PRE_ARGS) |
|
Line 645 pre_bl(PRE_ARGS) |
|
} |
} |
|
|
if (-1 == type) |
if (-1 == type) |
return(nerr(mdoc, n, ELISTTYPE)); |
return(mdoc_nerr(mdoc, n, ELISTTYPE)); |
|
|
/* |
/* |
* Validate the width field. Some list types don't need width |
* Validate the width field. Some list types don't need width |
Line 834 pre_bl(PRE_ARGS) |
|
Line 655 pre_bl(PRE_ARGS) |
|
|
|
switch (type) { |
switch (type) { |
case (MDOC_Tag): |
case (MDOC_Tag): |
if (-1 == width && ! nwarn(mdoc, n, WMISSWIDTH)) |
if (-1 == width && ! mdoc_nwarn(mdoc, n, EMISSWIDTH)) |
return(0); |
return(0); |
break; |
break; |
case (MDOC_Column): |
case (MDOC_Column): |
Line 844 pre_bl(PRE_ARGS) |
|
Line 665 pre_bl(PRE_ARGS) |
|
case (MDOC_Inset): |
case (MDOC_Inset): |
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case (MDOC_Item): |
case (MDOC_Item): |
if (-1 != width && ! nwarn(mdoc, n, WNOWIDTH)) |
if (-1 != width && ! mdoc_nwarn(mdoc, n, ENOWIDTH)) |
return(0); |
return(0); |
break; |
break; |
default: |
default: |
Line 863 pre_bd(PRE_ARGS) |
|
Line 684 pre_bd(PRE_ARGS) |
|
if (MDOC_BLOCK != n->type) |
if (MDOC_BLOCK != n->type) |
return(1); |
return(1); |
if (NULL == n->args) |
if (NULL == n->args) |
return(nerr(mdoc, n, EDISPTYPE)); |
return(mdoc_nerr(mdoc, n, EDISPTYPE)); |
|
|
/* Make sure that only one type of display is specified. */ |
/* Make sure that only one type of display is specified. */ |
|
|
Line 882 pre_bd(PRE_ARGS) |
|
Line 703 pre_bd(PRE_ARGS) |
|
case (MDOC_File): |
case (MDOC_File): |
if (0 == type++) |
if (0 == type++) |
break; |
break; |
return(nerr(mdoc, n, EMULTIDISP)); |
return(mdoc_nerr(mdoc, n, EMULTIDISP)); |
default: |
default: |
break; |
break; |
} |
} |
|
|
if (type) |
if (type) |
return(1); |
return(1); |
return(nerr(mdoc, n, EDISPTYPE)); |
return(mdoc_nerr(mdoc, n, EDISPTYPE)); |
} |
} |
|
|
|
|
Line 929 pre_an(PRE_ARGS) |
|
Line 750 pre_an(PRE_ARGS) |
|
|
|
if (NULL == n->args || 1 == n->args->argc) |
if (NULL == n->args || 1 == n->args->argc) |
return(1); |
return(1); |
return(mdoc_nerr(mdoc, n, "only one argument allowed")); |
return(mdoc_verr(mdoc, n->line, n->pos, |
|
"only one argument allowed")); |
} |
} |
|
|
|
|
Line 982 pre_dt(PRE_ARGS) |
|
Line 804 pre_dt(PRE_ARGS) |
|
{ |
{ |
|
|
if (0 == mdoc->meta.date || mdoc->meta.os) |
if (0 == mdoc->meta.date || mdoc->meta.os) |
if ( ! nwarn(mdoc, n, WPROLOOO)) |
if ( ! mdoc_nwarn(mdoc, n, EPROLOOO)) |
return(0); |
return(0); |
if (mdoc->meta.title) |
if (mdoc->meta.title) |
if ( ! nwarn(mdoc, n, WPROLREP)) |
if ( ! mdoc_nwarn(mdoc, n, EPROLREP)) |
return(0); |
return(0); |
return(1); |
return(1); |
} |
} |
Line 996 pre_os(PRE_ARGS) |
|
Line 818 pre_os(PRE_ARGS) |
|
{ |
{ |
|
|
if (NULL == mdoc->meta.title || 0 == mdoc->meta.date) |
if (NULL == mdoc->meta.title || 0 == mdoc->meta.date) |
if ( ! nwarn(mdoc, n, WPROLOOO)) |
if ( ! mdoc_nwarn(mdoc, n, EPROLOOO)) |
return(0); |
return(0); |
if (mdoc->meta.os) |
if (mdoc->meta.os) |
if ( ! nwarn(mdoc, n, WPROLREP)) |
if ( ! mdoc_nwarn(mdoc, n, EPROLREP)) |
return(0); |
return(0); |
return(1); |
return(1); |
} |
} |
Line 1010 pre_dd(PRE_ARGS) |
|
Line 832 pre_dd(PRE_ARGS) |
|
{ |
{ |
|
|
if (mdoc->meta.title || mdoc->meta.os) |
if (mdoc->meta.title || mdoc->meta.os) |
if ( ! nwarn(mdoc, n, WPROLOOO)) |
if ( ! mdoc_nwarn(mdoc, n, EPROLOOO)) |
return(0); |
return(0); |
if (mdoc->meta.date) |
if (mdoc->meta.date) |
if ( ! nwarn(mdoc, n, WPROLREP)) |
if ( ! mdoc_nwarn(mdoc, n, EPROLREP)) |
return(0); |
return(0); |
return(1); |
return(1); |
} |
} |
Line 1031 post_bf(POST_ARGS) |
|
Line 853 post_bf(POST_ARGS) |
|
head = mdoc->last->head; |
head = mdoc->last->head; |
|
|
if (mdoc->last->args && head->child) |
if (mdoc->last->args && head->child) |
return(mdoc_err(mdoc, "one argument expected")); |
return(mdoc_nerr(mdoc, mdoc->last, ELINE)); |
else if (mdoc->last->args) |
else if (mdoc->last->args) |
return(1); |
return(1); |
|
|
if (NULL == head->child || MDOC_TEXT != head->child->type) |
if (NULL == head->child || MDOC_TEXT != head->child->type) |
return(mdoc_err(mdoc, "text argument expected")); |
return(mdoc_nerr(mdoc, mdoc->last, ELINE)); |
|
|
p = head->child->string; |
p = head->child->string; |
|
|
Line 1047 post_bf(POST_ARGS) |
|
Line 869 post_bf(POST_ARGS) |
|
else if (0 == strcmp(p, "Sm")) |
else if (0 == strcmp(p, "Sm")) |
return(1); |
return(1); |
|
|
return(mdoc_nerr(mdoc, head->child, "invalid font mode")); |
return(mdoc_nerr(mdoc, head, EFONT)); |
} |
} |
|
|
|
|
Line 1059 post_nm(POST_ARGS) |
|
Line 881 post_nm(POST_ARGS) |
|
return(1); |
return(1); |
if (mdoc->meta.name) |
if (mdoc->meta.name) |
return(1); |
return(1); |
return(verr(mdoc, ENAME)); |
return(mdoc_nerr(mdoc, mdoc->last, ENAME)); |
} |
} |
|
|
|
|
Line 1070 post_at(POST_ARGS) |
|
Line 892 post_at(POST_ARGS) |
|
if (NULL == mdoc->last->child) |
if (NULL == mdoc->last->child) |
return(1); |
return(1); |
if (MDOC_TEXT != mdoc->last->child->type) |
if (MDOC_TEXT != mdoc->last->child->type) |
return(verr(mdoc, EATT)); |
return(mdoc_nerr(mdoc, mdoc->last, EATT)); |
if (mdoc_a2att(mdoc->last->child->string)) |
if (mdoc_a2att(mdoc->last->child->string)) |
return(1); |
return(1); |
return(verr(mdoc, EATT)); |
return(mdoc_nerr(mdoc, mdoc->last, EATT)); |
} |
} |
|
|
|
|
Line 1084 post_an(POST_ARGS) |
|
Line 906 post_an(POST_ARGS) |
|
if (mdoc->last->args) { |
if (mdoc->last->args) { |
if (NULL == mdoc->last->child) |
if (NULL == mdoc->last->child) |
return(1); |
return(1); |
return(verr(mdoc, ELINE)); |
return(mdoc_nerr(mdoc, mdoc->last, ELINE)); |
} |
} |
|
|
if (mdoc->last->child) |
if (mdoc->last->child) |
return(1); |
return(1); |
return(verr(mdoc, ELINE)); |
return(mdoc_nerr(mdoc, mdoc->last, ELINE)); |
} |
} |
|
|
|
|
Line 1099 post_args(POST_ARGS) |
|
Line 921 post_args(POST_ARGS) |
|
|
|
if (mdoc->last->args) |
if (mdoc->last->args) |
return(1); |
return(1); |
return(verr(mdoc, ELINE)); |
return(mdoc_nerr(mdoc, mdoc->last, ELINE)); |
} |
} |
|
|
|
|
Line 1114 post_it(POST_ARGS) |
|
Line 936 post_it(POST_ARGS) |
|
|
|
n = mdoc->last->parent->parent; |
n = mdoc->last->parent->parent; |
if (NULL == n->args) |
if (NULL == n->args) |
return(verr(mdoc, ELISTTYPE)); |
return(mdoc_nerr(mdoc, mdoc->last, ELISTTYPE)); |
|
|
/* Some types require block-head, some not. */ |
/* Some types require block-head, some not. */ |
|
|
Line 1152 post_it(POST_ARGS) |
|
Line 974 post_it(POST_ARGS) |
|
} |
} |
|
|
if (-1 == type) |
if (-1 == type) |
return(verr(mdoc, ELISTTYPE)); |
return(mdoc_nerr(mdoc, mdoc->last, ELISTTYPE)); |
|
|
switch (type) { |
switch (type) { |
case (MDOC_Tag): |
case (MDOC_Tag): |
if (NULL == mdoc->last->head->child) |
if (NULL == mdoc->last->head->child) |
if ( ! vwarn(mdoc, WLINE)) |
if ( ! mdoc_nwarn(mdoc, mdoc->last, ELINE)) |
return(0); |
return(0); |
break; |
break; |
case (MDOC_Hang): |
case (MDOC_Hang): |
Line 1168 post_it(POST_ARGS) |
|
Line 990 post_it(POST_ARGS) |
|
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case (MDOC_Diag): |
case (MDOC_Diag): |
if (NULL == mdoc->last->head->child) |
if (NULL == mdoc->last->head->child) |
if ( ! vwarn(mdoc, WLINE)) |
if ( ! mdoc_nwarn(mdoc, mdoc->last, ELINE)) |
return(0); |
return(0); |
if (NULL == mdoc->last->body->child) |
if (NULL == mdoc->last->body->child) |
if ( ! vwarn(mdoc, WMULTILINE)) |
if ( ! mdoc_nwarn(mdoc, mdoc->last, EMULTILINE)) |
return(0); |
return(0); |
break; |
break; |
case (MDOC_Bullet): |
case (MDOC_Bullet): |
Line 1184 post_it(POST_ARGS) |
|
Line 1006 post_it(POST_ARGS) |
|
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case (MDOC_Item): |
case (MDOC_Item): |
if (mdoc->last->head->child) |
if (mdoc->last->head->child) |
if ( ! vwarn(mdoc, WNOLINE)) |
if ( ! mdoc_nwarn(mdoc, mdoc->last, ENOLINE)) |
return(0); |
return(0); |
if (NULL == mdoc->last->body->child) |
if (NULL == mdoc->last->body->child) |
if ( ! vwarn(mdoc, WMULTILINE)) |
if ( ! mdoc_nwarn(mdoc, mdoc->last, EMULTILINE)) |
return(0); |
return(0); |
break; |
break; |
case (MDOC_Column): |
case (MDOC_Column): |
if (NULL == mdoc->last->head->child) |
if (NULL == mdoc->last->head->child) |
if ( ! vwarn(mdoc, WLINE)) |
if ( ! mdoc_nwarn(mdoc, mdoc->last, ELINE)) |
return(0); |
return(0); |
if (mdoc->last->body->child) |
if (mdoc->last->body->child) |
if ( ! vwarn(mdoc, WNOMULTILINE)) |
if ( ! mdoc_nwarn(mdoc, mdoc->last, ENOMULTILINE)) |
return(0); |
return(0); |
c = mdoc->last->child; |
c = mdoc->last->child; |
for (i = 0; c && MDOC_HEAD == c->type; c = c->next) |
for (i = 0; c && MDOC_HEAD == c->type; c = c->next) |
i++; |
i++; |
if (i == cols) |
if (i == cols) |
break; |
break; |
return(mdoc_err(mdoc, "column mismatch (have " |
return(mdoc_verr(mdoc, mdoc->last->line, mdoc->last->pos, |
"%d, want %d)", i, cols)); |
"column mismatch (have %d, want %d)", |
|
i, cols)); |
default: |
default: |
break; |
break; |
} |
} |
Line 1229 post_bl_head(POST_ARGS) |
|
Line 1052 post_bl_head(POST_ARGS) |
|
return(1); |
return(1); |
|
|
if (n->args->argv[i].sz && mdoc->last->child) |
if (n->args->argv[i].sz && mdoc->last->child) |
return(nerr(mdoc, n, ECOLMIS)); |
return(mdoc_nerr(mdoc, n, ECOLMIS)); |
|
|
return(1); |
return(1); |
} |
} |
Line 1252 post_bl(POST_ARGS) |
|
Line 1075 post_bl(POST_ARGS) |
|
if (MDOC_BLOCK == n->type) |
if (MDOC_BLOCK == n->type) |
if (MDOC_It == n->tok) |
if (MDOC_It == n->tok) |
continue; |
continue; |
return(mdoc_nerr(mdoc, n, "bad child of parent %s", |
return(mdoc_verr(mdoc, n->line, n->pos, |
|
"bad child of parent %s", |
mdoc_macronames[mdoc->last->tok])); |
mdoc_macronames[mdoc->last->tok])); |
} |
} |
|
|
Line 1278 ebool(struct mdoc *mdoc) |
|
Line 1102 ebool(struct mdoc *mdoc) |
|
|
|
if (NULL == n) |
if (NULL == n) |
return(1); |
return(1); |
return(nerr(mdoc, n, EBOOL)); |
return(mdoc_nerr(mdoc, n, EBOOL)); |
} |
} |
|
|
|
|
Line 1287 post_root(POST_ARGS) |
|
Line 1111 post_root(POST_ARGS) |
|
{ |
{ |
|
|
if (NULL == mdoc->first->child) |
if (NULL == mdoc->first->child) |
return(verr(mdoc, ENODATA)); |
return(mdoc_nerr(mdoc, mdoc->first, ENODAT)); |
if ( ! (MDOC_PBODY & mdoc->flags)) |
if ( ! (MDOC_PBODY & mdoc->flags)) |
return(verr(mdoc, ENOPROLOGUE)); |
return(mdoc_nerr(mdoc, mdoc->first, ENOPROLOGUE)); |
|
|
if (MDOC_BLOCK != mdoc->first->child->type) |
if (MDOC_BLOCK != mdoc->first->child->type) |
return(verr(mdoc, ENODATA)); |
return(mdoc_nerr(mdoc, mdoc->first, ENODAT)); |
if (MDOC_Sh != mdoc->first->child->tok) |
if (MDOC_Sh != mdoc->first->child->tok) |
return(verr(mdoc, ENODATA)); |
return(mdoc_nerr(mdoc, mdoc->first, ENODAT)); |
|
|
return(1); |
return(1); |
} |
} |
Line 1306 post_st(POST_ARGS) |
|
Line 1130 post_st(POST_ARGS) |
|
|
|
if (mdoc_a2st(mdoc->last->child->string)) |
if (mdoc_a2st(mdoc->last->child->string)) |
return(1); |
return(1); |
return(vwarn(mdoc, WBADSTAND)); |
return(mdoc_nwarn(mdoc, mdoc->last, EBADSTAND)); |
} |
} |
|
|
|
|
Line 1338 post_sh_body(POST_ARGS) |
|
Line 1162 post_sh_body(POST_ARGS) |
|
*/ |
*/ |
|
|
if (NULL == (n = mdoc->last->child)) |
if (NULL == (n = mdoc->last->child)) |
return(vwarn(mdoc, WNAMESECINC)); |
return(mdoc_nwarn(mdoc, mdoc->last, ENAMESECINC)); |
|
|
for ( ; n && n->next; n = n->next) { |
for ( ; n && n->next; n = n->next) { |
if (MDOC_ELEM == n->type && MDOC_Nm == n->tok) |
if (MDOC_ELEM == n->type && MDOC_Nm == n->tok) |
continue; |
continue; |
if (MDOC_TEXT == n->type) |
if (MDOC_TEXT == n->type) |
continue; |
continue; |
if ( ! vwarn(mdoc, WNAMESECINC)) |
if ( ! mdoc_nwarn(mdoc, mdoc->last, ENAMESECINC)) |
return(0); |
return(0); |
} |
} |
|
|
if (MDOC_ELEM == n->type && MDOC_Nd == n->tok) |
if (MDOC_ELEM == n->type && MDOC_Nd == n->tok) |
return(1); |
return(1); |
return(vwarn(mdoc, WNAMESECINC)); |
return(mdoc_nwarn(mdoc, mdoc->last, ENAMESECINC)); |
} |
} |
|
|
|
|
Line 1376 post_sh_head(POST_ARGS) |
|
Line 1200 post_sh_head(POST_ARGS) |
|
assert(MDOC_TEXT == n->type); |
assert(MDOC_TEXT == n->type); |
|
|
if (strlcat(buf, n->string, 64) >= 64) |
if (strlcat(buf, n->string, 64) >= 64) |
return(nerr(mdoc, n, ETOOLONG)); |
return(mdoc_nerr(mdoc, n, ETOOLONG)); |
if (NULL == n->next) |
if (NULL == n->next) |
continue; |
continue; |
if (strlcat(buf, " ", 64) >= 64) |
if (strlcat(buf, " ", 64) >= 64) |
return(nerr(mdoc, n, ETOOLONG)); |
return(mdoc_nerr(mdoc, n, ETOOLONG)); |
} |
} |
|
|
sec = mdoc_atosec(buf); |
sec = mdoc_atosec(buf); |
Line 1391 post_sh_head(POST_ARGS) |
|
Line 1215 post_sh_head(POST_ARGS) |
|
*/ |
*/ |
|
|
if (SEC_NAME != sec && SEC_NONE == mdoc->lastnamed) |
if (SEC_NAME != sec && SEC_NONE == mdoc->lastnamed) |
return(verr(mdoc, ESECNAME)); |
return(mdoc_nerr(mdoc, mdoc->last, ESECNAME)); |
if (SEC_CUSTOM == sec) |
if (SEC_CUSTOM == sec) |
return(1); |
return(1); |
if (sec == mdoc->lastnamed) |
if (sec == mdoc->lastnamed) |
return(vwarn(mdoc, WSECREP)); |
return(mdoc_nwarn(mdoc, mdoc->last, ESECREP)); |
if (sec < mdoc->lastnamed) |
if (sec < mdoc->lastnamed) |
return(vwarn(mdoc, WSECOOO)); |
return(mdoc_nwarn(mdoc, mdoc->last, ESECOOO)); |
|
|
/* |
/* |
* Check particular section/manual conventions. LIBRARY can |
* Check particular section/manual conventions. LIBRARY can |
Line 1412 post_sh_head(POST_ARGS) |
|
Line 1236 post_sh_head(POST_ARGS) |
|
case (3): |
case (3): |
break; |
break; |
default: |
default: |
return(vwarn(mdoc, WWRONGMSEC)); |
return(mdoc_nwarn(mdoc, mdoc->last, EWRONGMSEC)); |
} |
} |
break; |
break; |
default: |
default: |