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.83 and 1.96

version 1.83, 2012/07/18 16:52:03

version 1.96, 2014/07/02 11:43:20

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 32

#include "man.h"

#include "mandoc.h"

#include "mandoc_aux.h"

#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 49 static int check_eq2(CHKARGS);

Line 50 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);

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

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

static v_check posts_fi[] = { check_eq0, post_fi, 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 };

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

Line 82 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 posts_ur[] = { check_head1, check_part, NULL };

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

static const struct man_valid man_valids[MAN_MAX] = {

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

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

{ 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 */

{ NULL, NULL }, /* ll */

};

int

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

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

{

v_check *cp;

switch (n->type) {

case (MAN_TEXT):

case MAN_TEXT:

/* FALLTHROUGH */

case (MAN_ROOT):

case MAN_ROOT:

/* FALLTHROUGH */

case (MAN_EQN):

case MAN_EQN:

/* FALLTHROUGH */

case (MAN_TBL):

case MAN_TBL:

return(1);

default:

break;

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

Line 149 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):

case MAN_TEXT:

check_text(m, m->last);

check_text(man, man->last);

return(1);

case (MAN_ROOT):

case MAN_ROOT:

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

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

case (MAN_EQN):

case MAN_EQN:

/* FALLTHROUGH */

case (MAN_TBL):

case MAN_TBL:

return(1);

default:

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);

}

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_DOC_EMPTY);

return(0);

else

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

man->meta.hasbody = 1;

man_nmsg(m, n, MANDOCERR_NOTITLE);

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

man_nmsg(man, n, MANDOCERR_TH_MISSING);

* 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 218 check_text(CHKARGS)

Line 225 check_text(CHKARGS)

{

char *cp, *p;

if (MAN_LITERAL & m->flags)

if (MAN_LITERAL & man->flags)

return;

cp = n->string;

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

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

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

}

#define INEQ_DEFINE(x, ineq, name) \

Line 232 check_##name(CHKARGS) \

Line 239 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); \

}

Line 245 INEQ_DEFINE(2, >=, ge2)

Line 252 INEQ_DEFINE(2, >=, ge2)

INEQ_DEFINE(5, <=, le5)

static int

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;

Line 256 post_ft(CHKARGS)

Line 274 post_ft(CHKARGS)

ok = 0;

cp = n->child->string;

switch (*cp) {

case ('1'):

case '1':

/* FALLTHROUGH */

case ('2'):

case '2':

/* FALLTHROUGH */

case ('3'):

case '3':

/* FALLTHROUGH */

case ('4'):

case '4':

/* FALLTHROUGH */

case ('I'):

case 'I':

/* FALLTHROUGH */

case ('P'):

case 'P':

/* FALLTHROUGH */

case ('R'):

case 'R':

if ('\0' == cp[1])

ok = 1;

break;

case ('B'):

case 'B':

if ('\0' == cp[1] || ('I' == cp[1] && '\0' == cp[2]))

ok = 1;

break;

case ('C'):

case 'C':

if ('W' == cp[1] && '\0' == cp[2])

ok = 1;

break;

Line 285 post_ft(CHKARGS)

Line 303 post_ft(CHKARGS)

}

if (0 == ok) {

mandoc_vmsg

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

(MANDOCERR_BADFONT, m->parse,

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

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

*cp = '\0';

}

if (1 < n->nchild)

mandoc_vmsg

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

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

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

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

n->nchild);

return(1);

}

Line 305 pre_sec(CHKARGS)

Line 320 pre_sec(CHKARGS)

{

if (MAN_BLOCK == n->type)

m->flags &= ~MAN_LITERAL;

man->flags &= ~MAN_LITERAL;

return(1);

}

Line 313 static int

Line 328 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);

}

Line 325 check_part(CHKARGS)

Line 340 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);

}

static int

check_par(CHKARGS)

{

switch (n->type) {

case (MAN_BLOCK):

case MAN_BLOCK:

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

man_node_delete(m, n);

man_node_delete(man, n);

break;

case (MAN_BODY):

case MAN_BODY:

if (0 == n->nchild)

man_nmsg(m, n, MANDOCERR_IGNPAR);

mandoc_vmsg(MANDOCERR_PAR_SKIP,

man->parse, n->line, n->pos,

"%s empty", man_macronames[n->tok]);

break;

case (MAN_HEAD):

case MAN_HEAD:

if (n->nchild)

man_nmsg(m, n, MANDOCERR_ARGSLOST);

man_nmsg(man, n, MANDOCERR_ARGSLOST);

break;

default:

break;

Line 361 post_IP(CHKARGS)

Line 377 post_IP(CHKARGS)

{

switch (n->type) {

case (MAN_BLOCK):

case MAN_BLOCK:

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

man_node_delete(m, n);

man_node_delete(man, n);

break;

case (MAN_BODY):

case MAN_BODY:

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

man_nmsg(m, n, MANDOCERR_IGNPAR);

mandoc_vmsg(MANDOCERR_PAR_SKIP,

man->parse, n->line, n->pos,

"%s empty", man_macronames[n->tok]);

break;

default:

break;

Line 378 post_IP(CHKARGS)

Line 396 post_IP(CHKARGS)

static int

post_TH(CHKARGS)

{

struct man_node *nb;

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;

nb = n;

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

n = n->child;

if (n && n->string) {

for (p = n->string; '\0' != *p; p++) {

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

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

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

man_nmsg(m, n, MANDOCERR_UPPERCASE);

mandoc_msg(MANDOCERR_TITLE_CASE,

man->parse, n->line,

n->pos + (p - n->string),

n->string);

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 && 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->string, line, pos);

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

} else

n->line, n->pos);

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

} else {

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

man_nmsg(man, n ? n : nb, MANDOCERR_DATE_MISSING);

}

/* 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' != m->meta.msec[0] &&

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

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

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

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

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 459 static int

Line 478 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_NF_SKIP);

m->flags |= MAN_LITERAL;

man->flags |= MAN_LITERAL;

return(1);

}

Line 470 static int

Line 489 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_FI_SKIP);

m->flags &= ~MAN_LITERAL;

man->flags &= ~MAN_LITERAL;

return(1);

}

Line 510 post_UC(CHKARGS)

Line 529 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 550 post_AT(CHKARGS)

Line 567 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 565 post_vs(CHKARGS)

Line 580 post_vs(CHKARGS)

return(1);

switch (n->parent->tok) {

case (MAN_SH):

case MAN_SH:

/* FALLTHROUGH */

case (MAN_SS):

case MAN_SS:

man_nmsg(m, n, MANDOCERR_IGNPAR);

mandoc_vmsg(MANDOCERR_PAR_SKIP, man->parse, n->line, n->pos,

"%s after %s", man_macronames[n->tok],

man_macronames[n->parent->tok]);

/* FALLTHROUGH */

case (MAN_MAX):

case MAN_MAX:

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

* and would cause considerable (unfixable) warnage.

man_node_delete(m, n);

man_node_delete(man, n);

break;

default:

break;

CVSweb