mandoc/man_validate.c - diff

Return to man_validate.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/man_validate.c between version 1.72 and 1.88

version 1.72, 2011/07/26 14:09:01

version 1.88, 2014/01/06 22:39:25

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 35

#include "libman.h"

#include "libmandoc.h"

#define CHKARGS struct man *m, struct man_node *n

#define CHKARGS struct man *man, struct man_node *n

typedef int (*v_check)(CHKARGS);

Line 44 struct man_valid {

v_check *posts;

};

static int check_bline(CHKARGS);

static int check_eq0(CHKARGS);

static int check_ft(CHKARGS);

static int check_eq2(CHKARGS);

static int check_le1(CHKARGS);

static int check_ge2(CHKARGS);

static int check_le5(CHKARGS);

static int check_head1(CHKARGS);

static int check_par(CHKARGS);

static int check_part(CHKARGS);

static int check_root(CHKARGS);

static int check_sec(CHKARGS);

static void check_text(CHKARGS);

static int post_AT(CHKARGS);

static int post_IP(CHKARGS);

static int post_vs(CHKARGS);

static int post_fi(CHKARGS);

static int post_ft(CHKARGS);

static int post_nf(CHKARGS);

static int post_sec(CHKARGS);

static int post_TH(CHKARGS);

static int post_UC(CHKARGS);

static int pre_sec(CHKARGS);

static v_check posts_at[] = { post_AT, NULL };

static v_check posts_br[] = { post_vs, check_eq0, NULL };

static v_check posts_eq0[] = { check_eq0, NULL };

static v_check posts_eq2[] = { check_eq2, NULL };

static v_check posts_fi[] = { check_eq0, post_fi, NULL };

static v_check posts_ft[] = { check_ft, NULL };

static v_check posts_ft[] = { post_ft, NULL };

static v_check posts_ip[] = { post_IP, NULL };

static v_check posts_le1[] = { check_le1, NULL };

static v_check posts_nf[] = { check_eq0, post_nf, NULL };

static v_check posts_par[] = { check_par, NULL };

static v_check posts_part[] = { check_part, NULL };

static v_check posts_sec[] = { check_sec, NULL };

static v_check posts_sec[] = { post_sec, NULL };

static v_check posts_sp[] = { post_vs, check_le1, NULL };

static v_check posts_th[] = { check_ge2, check_le5, post_TH, NULL };

static v_check posts_uc[] = { post_UC, NULL };

static v_check pres_bline[] = { check_bline, NULL };

static v_check posts_ur[] = { check_head1, check_part, NULL };

static v_check pres_sec[] = { pre_sec, NULL };

static const struct man_valid man_valids[MAN_MAX] = {

{ NULL, posts_br }, /* br */

{ pres_bline, posts_th }, /* TH */

{ NULL, posts_th }, /* TH */

{ pres_bline, posts_sec }, /* SH */

{ pres_sec, posts_sec }, /* SH */

{ pres_bline, posts_sec }, /* SS */

{ pres_sec, posts_sec }, /* SS */

{ pres_bline, NULL }, /* TP */

{ NULL, NULL }, /* TP */

{ pres_bline, posts_par }, /* LP */

{ NULL, posts_par }, /* LP */

{ pres_bline, posts_par }, /* PP */

{ NULL, posts_par }, /* PP */

{ pres_bline, posts_par }, /* P */

{ NULL, posts_par }, /* P */

{ pres_bline, NULL }, /* IP */

{ NULL, posts_ip }, /* IP */

{ pres_bline, NULL }, /* HP */

{ NULL, NULL }, /* HP */

{ NULL, NULL }, /* SM */

{ NULL, NULL }, /* SB */

{ NULL, NULL }, /* BI */

Line 99 static const struct man_valid man_valids[MAN_MAX] = {

Line 106 static const struct man_valid man_valids[MAN_MAX] = {

{ NULL, NULL }, /* I */

{ NULL, NULL }, /* IR */

{ NULL, NULL }, /* RI */

{ NULL, posts_eq0 }, /* na */ /* FIXME: should warn only. */

{ NULL, posts_eq0 }, /* na */

{ NULL, posts_sp }, /* sp */ /* FIXME: should warn only. */

{ NULL, posts_sp }, /* sp */

{ pres_bline, posts_nf }, /* nf */

{ NULL, posts_nf }, /* nf */

{ pres_bline, posts_fi }, /* fi */

{ NULL, posts_fi }, /* fi */

{ NULL, NULL }, /* RE */

{ NULL, posts_part }, /* RS */

{ NULL, NULL }, /* DT */

{ NULL, posts_uc }, /* UC */

{ NULL, NULL }, /* PD */

{ NULL, posts_le1 }, /* PD */

{ NULL, posts_at }, /* AT */

{ NULL, NULL }, /* in */

{ NULL, posts_ft }, /* ft */

{ NULL, posts_eq2 }, /* OP */

{ NULL, posts_nf }, /* EX */

{ NULL, posts_fi }, /* EE */

{ NULL, posts_ur }, /* UR */

{ NULL, NULL }, /* UE */

};

int

man_valid_pre(struct man *m, struct man_node *n)

man_valid_pre(struct man *man, struct man_node *n)

{

v_check *cp;

Line 135 man_valid_pre(struct man *m, struct man_node *n)

Line 147 man_valid_pre(struct man *m, struct man_node *n)

if (NULL == (cp = man_valids[n->tok].pres))

return(1);

for ( ; *cp; cp++)

if ( ! (*cp)(m, n))

if ( ! (*cp)(man, n))

return(0);

return(1);

}

int

man_valid_post(struct man *m)

man_valid_post(struct man *man)

{

v_check *cp;

if (MAN_VALID & m->last->flags)

if (MAN_VALID & man->last->flags)

return(1);

m->last->flags |= MAN_VALID;

man->last->flags |= MAN_VALID;

switch (m->last->type) {

switch (man->last->type) {

case (MAN_TEXT):

check_text(m, m->last);

check_text(man, man->last);

return(1);

case (MAN_ROOT):

return(check_root(m, m->last));

return(check_root(man, man->last));

case (MAN_EQN):

/* FALLTHROUGH */

case (MAN_TBL):

Line 164 man_valid_post(struct man *m)

Line 176 man_valid_post(struct man *m)

break;

}

if (NULL == (cp = man_valids[m->last->tok].posts))

if (NULL == (cp = man_valids[man->last->tok].posts))

return(1);

for ( ; *cp; cp++)

if ( ! (*cp)(m, m->last))

if ( ! (*cp)(man, man->last))

return(0);

return(1);

Line 178 static int

Line 190 static int

check_root(CHKARGS)

{

if (MAN_BLINE & m->flags)

if (MAN_BLINE & man->flags)

man_nmsg(m, n, MANDOCERR_SCOPEEXIT);

man_nmsg(man, n, MANDOCERR_SCOPEEXIT);

else if (MAN_ELINE & m->flags)

else if (MAN_ELINE & man->flags)

man_nmsg(m, n, MANDOCERR_SCOPEEXIT);

man_nmsg(man, n, MANDOCERR_SCOPEEXIT);

m->flags &= ~MAN_BLINE;

man->flags &= ~MAN_BLINE;

m->flags &= ~MAN_ELINE;

man->flags &= ~MAN_ELINE;

if (NULL == m->first->child) {

if (NULL == man->first->child) {

man_nmsg(m, n, MANDOCERR_NODOCBODY);

man_nmsg(man, n, MANDOCERR_NODOCBODY);

return(0);

} else if (NULL == m->meta.title) {

} else if (NULL == man->meta.title) {

man_nmsg(m, n, MANDOCERR_NOTITLE);

man_nmsg(man, n, MANDOCERR_NOTITLE);

* If a title hasn't been set, do so now (by

* implication, date and section also aren't set).

m->meta.title = mandoc_strdup("unknown");

man->meta.title = mandoc_strdup("unknown");

m->meta.msec = mandoc_strdup("1");

man->meta.msec = mandoc_strdup("1");

m->meta.date = mandoc_normdate

man->meta.date = man->quick ? mandoc_strdup("") :

(m->parse, NULL, n->line, n->pos);

mandoc_normdate(man->parse, NULL, n->line, n->pos);

}

return(1);

Line 211 check_text(CHKARGS)

Line 223 check_text(CHKARGS)

{

char *cp, *p;

cp = p = n->string;

if (MAN_LITERAL & man->flags)

for (cp = p; NULL != (p = strchr(p, '\t')); p++) {

return;

if (MAN_LITERAL & m->flags)

continue;

cp = n->string;

man_pmsg(m, n->line, (int)(p - cp), MANDOCERR_BADTAB);

for (p = cp; NULL != (p = strchr(p, '\t')); p++)

}

man_pmsg(man, n->line, (int)(p - cp), MANDOCERR_BADTAB);

}

#define INEQ_DEFINE(x, ineq, name) \

Line 225 check_##name(CHKARGS) \

Line 237 check_##name(CHKARGS) \

{ \

if (n->nchild ineq (x)) \

return(1); \

mandoc_vmsg(MANDOCERR_ARGCOUNT, m->parse, n->line, n->pos, \

mandoc_vmsg(MANDOCERR_ARGCOUNT, man->parse, n->line, n->pos, \

"line arguments %s %d (have %d)", \

#ineq, (x), n->nchild); \

return(1); \

}

INEQ_DEFINE(0, ==, eq0)

INEQ_DEFINE(2, ==, eq2)

INEQ_DEFINE(1, <=, le1)

INEQ_DEFINE(2, >=, ge2)

INEQ_DEFINE(5, <=, le5)

static int

check_ft(CHKARGS)

check_head1(CHKARGS)

{

if (MAN_HEAD == n->type && 1 != n->nchild)

mandoc_vmsg(MANDOCERR_ARGCOUNT, man->parse, n->line,

n->pos, "line arguments eq 1 (have %d)", n->nchild);

return(1);

}

static int

post_ft(CHKARGS)

{

char *cp;

int ok;

Line 278 check_ft(CHKARGS)

Line 302 check_ft(CHKARGS)

if (0 == ok) {

mandoc_vmsg

(MANDOCERR_BADFONT, m->parse,

(MANDOCERR_BADFONT, man->parse,

n->line, n->pos, "%s", cp);

*cp = '\0';

}

if (1 < n->nchild)

mandoc_vmsg

(MANDOCERR_ARGCOUNT, m->parse, n->line,

(MANDOCERR_ARGCOUNT, man->parse, n->line,

n->pos, "want one child (have %d)",

n->nchild);

Line 293 check_ft(CHKARGS)

Line 317 check_ft(CHKARGS)

}

static int

check_sec(CHKARGS)

pre_sec(CHKARGS)

{

if (MAN_BLOCK == n->type)

man->flags &= ~MAN_LITERAL;

return(1);

}

static int

post_sec(CHKARGS)

{

if ( ! (MAN_HEAD == n->type && 0 == n->nchild))

return(1);

man_nmsg(m, n, MANDOCERR_SYNTARGCOUNT);

man_nmsg(man, n, MANDOCERR_SYNTARGCOUNT);

return(0);

}

static int

check_part(CHKARGS)

{

if (MAN_BODY == n->type && 0 == n->nchild)

mandoc_msg(MANDOCERR_ARGCWARN, m->parse, n->line,

mandoc_msg(MANDOCERR_ARGCWARN, man->parse, n->line,

n->pos, "want children (have none)");

return(1);

Line 323 check_par(CHKARGS)

Line 355 check_par(CHKARGS)

switch (n->type) {

case (MAN_BLOCK):

if (0 == n->body->nchild)

man_node_delete(m, n);

man_node_delete(man, n);

break;

case (MAN_BODY):

if (0 == n->nchild)

man_nmsg(m, n, MANDOCERR_IGNPAR);

man_nmsg(man, n, MANDOCERR_IGNPAR);

break;

case (MAN_HEAD):

if (n->nchild)

man_nmsg(m, n, MANDOCERR_ARGSLOST);

man_nmsg(man, n, MANDOCERR_ARGSLOST);

break;

default:

break;

Line 340 check_par(CHKARGS)

Line 372 check_par(CHKARGS)

return(1);

}

static int

check_bline(CHKARGS)

post_IP(CHKARGS)

{

assert( ! (MAN_ELINE & m->flags));

switch (n->type) {

if (MAN_BLINE & m->flags) {

case (MAN_BLOCK):

man_nmsg(m, n, MANDOCERR_SYNTLINESCOPE);

if (0 == n->head->nchild && 0 == n->body->nchild)

return(0);

man_node_delete(man, n);

break;

case (MAN_BODY):

if (0 == n->parent->head->nchild && 0 == n->nchild)

man_nmsg(man, n, MANDOCERR_IGNPAR);

break;

default:

break;

}

return(1);

}

Line 358 static int

Line 395 static int

post_TH(CHKARGS)

{

const char *p;

int line, pos;

if (m->meta.title)

free(man->meta.title);

free(m->meta.title);

free(man->meta.vol);

if (m->meta.vol)

free(man->meta.source);

free(m->meta.vol);

free(man->meta.msec);

if (m->meta.source)

free(man->meta.date);

free(m->meta.source);

if (m->meta.msec)

free(m->meta.msec);

if (m->meta.date)

free(m->meta.date);

line = n->line;

man->meta.title = man->meta.vol = man->meta.date =

pos = n->pos;

man->meta.msec = man->meta.source = NULL;

m->meta.title = m->meta.vol = m->meta.date =

m->meta.msec = m->meta.source = NULL;

/* ->TITLE<- MSEC DATE SOURCE VOL */

Line 384 post_TH(CHKARGS)

Line 413 post_TH(CHKARGS)

/* Only warn about this once... */

if (isalpha((unsigned char)*p) &&

! isupper((unsigned char)*p)) {

man_nmsg(m, n, MANDOCERR_UPPERCASE);

man_nmsg(man, n, MANDOCERR_UPPERCASE);

break;

}

m->meta.title = mandoc_strdup(n->string);

man->meta.title = mandoc_strdup(n->string);

} else

m->meta.title = mandoc_strdup("");

man->meta.title = mandoc_strdup("");

/* TITLE ->MSEC<- DATE SOURCE VOL */

if (n)

n = n->next;

if (n && n->string)

m->meta.msec = mandoc_strdup(n->string);

man->meta.msec = mandoc_strdup(n->string);

else

m->meta.msec = mandoc_strdup("");

man->meta.msec = mandoc_strdup("");

/* TITLE MSEC ->DATE<- SOURCE VOL */

if (n)

n = n->next;

if (n)

if (n && n->string && '\0' != n->string[0]) {

pos = n->pos;

man->meta.date = man->quick ?

m->meta.date = mandoc_normdate

mandoc_strdup(n->string) :

(m->parse, n ? n->string : NULL, line, pos);

mandoc_normdate(man->parse, n->string,

n->line, n->pos);

} else

man->meta.date = mandoc_strdup("");

/* TITLE MSEC DATE ->SOURCE<- VOL */

if (n && (n = n->next))

m->meta.source = mandoc_strdup(n->string);

man->meta.source = mandoc_strdup(n->string);

/* TITLE MSEC DATE SOURCE ->VOL<- */

/* If missing, use the default VOL name for MSEC. */

if (n && (n = n->next))

m->meta.vol = mandoc_strdup(n->string);

man->meta.vol = mandoc_strdup(n->string);

else if ('\0' != man->meta.msec[0] &&

(NULL != (p = mandoc_a2msec(man->meta.msec))))

man->meta.vol = mandoc_strdup(p);

* Remove the `TH' node after we've processed it for our

* meta-data.

man_node_delete(m, m->last);

man_node_delete(man, man->last);

return(1);

}

Line 432 static int

Line 468 static int

post_nf(CHKARGS)

{

if (MAN_LITERAL & m->flags)

if (MAN_LITERAL & man->flags)

man_nmsg(m, n, MANDOCERR_SCOPEREP);

man_nmsg(man, n, MANDOCERR_SCOPEREP);

m->flags |= MAN_LITERAL;

man->flags |= MAN_LITERAL;

return(1);

}

Line 443 static int

Line 479 static int

post_fi(CHKARGS)

{

if ( ! (MAN_LITERAL & m->flags))

if ( ! (MAN_LITERAL & man->flags))

man_nmsg(m, n, MANDOCERR_WNOSCOPE);

man_nmsg(man, n, MANDOCERR_WNOSCOPE);

m->flags &= ~MAN_LITERAL;

man->flags &= ~MAN_LITERAL;

return(1);

}

Line 464 post_UC(CHKARGS)

Line 500 post_UC(CHKARGS)

const char *p, *s;

n = n->child;

n = m->last->child;

if (NULL == n || MAN_TEXT != n->type)

p = bsd_versions[0];

Line 484 post_UC(CHKARGS)

Line 519 post_UC(CHKARGS)

p = bsd_versions[0];

}

if (m->meta.source)

free(man->meta.source);

free(m->meta.source);

man->meta.source = mandoc_strdup(p);

m->meta.source = mandoc_strdup(p);

return(1);

}

Line 524 post_AT(CHKARGS)

Line 557 post_AT(CHKARGS)

p = unix_versions[0];

}

if (m->meta.source)

free(man->meta.source);

free(m->meta.source);

man->meta.source = mandoc_strdup(p);

m->meta.source = mandoc_strdup(p);

return(1);

}

Line 535 static int

Line 566 static int

post_vs(CHKARGS)

{

if (NULL != n->prev)

* Don't warn about this because it occurs in pod2man and would

return(1);

* cause considerable (unfixable) warnage.

switch (n->parent->tok) {

if (NULL == n->prev && MAN_ROOT == n->parent->type)

case (MAN_SH):

man_node_delete(m, n);

/* FALLTHROUGH */

case (MAN_SS):

man_nmsg(man, n, MANDOCERR_IGNPAR);

/* FALLTHROUGH */

case (MAN_MAX):

* Don't warn about this because it occurs in pod2man

* and would cause considerable (unfixable) warnage.

man_node_delete(man, n);

break;

default:

break;

}

return(1);

}

CVSweb