mandoc/mdoc_validate.c - diff

Return to mdoc_validate.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_validate.c between version 1.8 and 1.42

version 1.8, 2009/06/11 10:34:31

version 1.42, 2009/08/20 13:22:48

Line 18

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <stdarg.h>

#include <stdlib.h>

#include <string.h>

#include "libmdoc.h"

#include "libmandoc.h"

/* FIXME: .Bl -diag can't have non-text children in HEAD. */

/* TODO: ignoring Pp (it's superfluous in some invocations). */

#define PRE_ARGS struct mdoc *mdoc, const struct mdoc_node *n

#define POST_ARGS struct mdoc *mdoc

enum merr {

ETOOLONG,

EESCAPE,

EPRINT,

ENODATA,

ENOPROLOGUE,

ELINE,

EATT,

ENAME,

ELISTTYPE,

EDISPTYPE,

EMULTIDISP,

EMULTILIST,

EARGREP,

EBOOL,

ENESTDISP

};

enum mwarn {

WPRINT,

WNOWIDTH,

WMISSWIDTH,

WESCAPE,

WDEPCOL,

WWRONGMSEC,

WSECOOO,

WSECREP,

WBADSTAND,

WNAMESECINC,

WNOMULTILINE,

WMULTILINE,

WLINE,

WNOLINE,

WPROLOOO,

WPROLREP,

WARGVAL,

WBADSEC,

WBADMSEC

};

typedef int (*v_pre)(PRE_ARGS);

typedef int (*v_post)(POST_ARGS);

Line 78 struct valids {

Line 41 struct valids {

v_post *post;

};

static int pwarn(struct mdoc *, int, int, enum mwarn);

static int check_parent(PRE_ARGS, int, enum mdoc_type);

static int perr(struct mdoc *, int, int, enum merr);

static int check_msec(PRE_ARGS, ...);

static int check_parent(PRE_ARGS, int, enum mdoc_type);

static int check_sec(PRE_ARGS, ...);

static int check_msec(PRE_ARGS, ...);

static int check_stdarg(PRE_ARGS);

static int check_sec(PRE_ARGS, ...);

static int check_text(struct mdoc *, int, int, const char *);

static int check_stdarg(PRE_ARGS);

static int check_argv(struct mdoc *,

static int check_text(struct mdoc *, int, int, const char *);

static int check_argv(struct mdoc *,

const struct mdoc_node *,

const struct mdoc_argv *);

static int check_args(struct mdoc *,

const struct mdoc_node *);

static int err_child_lt(struct mdoc *, const char *, int);

static int warn_child_lt(struct mdoc *, const char *, int);

static int err_child_gt(struct mdoc *, const char *, int);

static int warn_child_gt(struct mdoc *, const char *, int);

static int err_child_eq(struct mdoc *, const char *, int);

static int warn_child_eq(struct mdoc *, const char *, int);

static int count_child(struct mdoc *);

static int warn_print(struct mdoc *, int, int);

static int warn_count(struct mdoc *, const char *,

int, const char *, int);

static int err_count(struct mdoc *, const char *,

int, const char *, int);

static int pre_an(PRE_ARGS);

static int pre_bd(PRE_ARGS);

static int pre_bl(PRE_ARGS);

static int pre_cd(PRE_ARGS);

static int pre_dd(PRE_ARGS);

static int pre_display(PRE_ARGS);

static int pre_dt(PRE_ARGS);

static int pre_er(PRE_ARGS);

static int pre_ex(PRE_ARGS);

static int pre_fd(PRE_ARGS);

static int pre_it(PRE_ARGS);

static int pre_lb(PRE_ARGS);

static int pre_os(PRE_ARGS);

static int pre_prologue(PRE_ARGS);

static int pre_rv(PRE_ARGS);

static int pre_sh(PRE_ARGS);

static int pre_ss(PRE_ARGS);

static int herr_ge1(POST_ARGS);

static int hwarn_le1(POST_ARGS);

static int herr_eq0(POST_ARGS);

static int eerr_eq0(POST_ARGS);

static int eerr_le2(POST_ARGS);

static int eerr_eq1(POST_ARGS);

static int eerr_ge1(POST_ARGS);

static int ewarn_eq0(POST_ARGS);

static int ewarn_eq1(POST_ARGS);

static int bwarn_ge1(POST_ARGS);

static int hwarn_eq1(POST_ARGS);

static int ewarn_ge1(POST_ARGS);

static int ebool(POST_ARGS);

static int post_an(POST_ARGS);

static int post_args(POST_ARGS);

static int post_at(POST_ARGS);

static int post_bf(POST_ARGS);

static int post_bl(POST_ARGS);

static int post_it(POST_ARGS);

static int post_nm(POST_ARGS);

static int post_root(POST_ARGS);

static int post_sh(POST_ARGS);

static int post_sh_body(POST_ARGS);

static int post_sh_head(POST_ARGS);

static int post_st(POST_ARGS);

#define vwarn(m, t) nwarn((m), (m)->last, (t))

#ifdef __linux__

#define verr(m, t) nerr((m), (m)->last, (t))

extern size_t strlcat(char *, const char *, size_t);

#define nwarn(m, n, t) pwarn((m), (n)->line, (n)->pos, (t))

#endif

#define nerr(m, n, t) perr((m), (n)->line, (n)->pos, (t))

static v_pre pres_an[] = { pre_an, NULL };

static int berr_ge1(POST_ARGS);

static v_pre pres_bd[] = { pre_display, pre_bd, NULL };

static int bwarn_ge1(POST_ARGS);

static v_pre pres_bl[] = { pre_bl, NULL };

static int ebool(POST_ARGS);

static v_pre pres_cd[] = { pre_cd, NULL };

static int eerr_eq0(POST_ARGS);

static v_pre pres_dd[] = { pre_prologue, pre_dd, NULL };

static int eerr_eq1(POST_ARGS);

static v_pre pres_d1[] = { pre_display, NULL };

static int eerr_ge1(POST_ARGS);

static v_pre pres_dt[] = { pre_prologue, pre_dt, NULL };

static int eerr_le2(POST_ARGS);

static v_pre pres_er[] = { pre_er, NULL };

static int ewarn_ge1(POST_ARGS);

static v_pre pres_ex[] = { pre_ex, NULL };

static int herr_eq0(POST_ARGS);

static v_pre pres_fd[] = { pre_fd, NULL };

static int herr_ge1(POST_ARGS);

static v_pre pres_it[] = { pre_it, NULL };

static int hwarn_eq1(POST_ARGS);

static v_pre pres_lb[] = { pre_lb, NULL };

static int hwarn_le1(POST_ARGS);

static v_pre pres_os[] = { pre_prologue, pre_os, NULL };

static v_pre pres_rv[] = { pre_rv, NULL };

static v_pre pres_sh[] = { pre_sh, NULL };

static v_pre pres_ss[] = { pre_ss, NULL };

static v_post posts_bool[] = { eerr_eq1, ebool, NULL };

static v_post posts_bd[] = { herr_eq0, bwarn_ge1, NULL };

static v_post posts_text[] = { eerr_ge1, NULL };

static v_post posts_wtext[] = { ewarn_ge1, NULL };

static v_post posts_notext[] = { eerr_eq0, NULL };

static v_post posts_wline[] = { bwarn_ge1, herr_eq0, NULL };

static v_post posts_sh[] = { herr_ge1, bwarn_ge1, post_sh, NULL };

static v_post posts_bl[] = { herr_eq0, bwarn_ge1, post_bl, NULL };

static v_post posts_it[] = { post_it, NULL };

static v_post posts_in[] = { ewarn_eq1, NULL };

static v_post posts_ss[] = { herr_ge1, NULL };

static v_post posts_pf[] = { eerr_eq1, NULL };

static v_post posts_lb[] = { eerr_eq1, NULL };

static v_post posts_st[] = { eerr_eq1, post_st, NULL };

static v_post posts_pp[] = { ewarn_eq0, NULL };

static v_post posts_ex[] = { eerr_eq0, post_args, NULL };

static v_post posts_rv[] = { eerr_eq0, post_args, NULL };

static v_post posts_an[] = { post_an, NULL };

static v_post posts_at[] = { post_at, NULL };

static v_post posts_xr[] = { eerr_ge1, eerr_le2, NULL };

static v_post posts_nm[] = { post_nm, NULL };

static v_post posts_bf[] = { hwarn_le1, post_bf, NULL };

static v_post posts_fo[] = { hwarn_eq1, bwarn_ge1, NULL };

static int post_an(POST_ARGS);

static int post_at(POST_ARGS);

static int post_bf(POST_ARGS);

static int post_bl(POST_ARGS);

static int post_bl_head(POST_ARGS);

static int post_it(POST_ARGS);

static int post_lb(POST_ARGS);

static int post_nm(POST_ARGS);

static int post_root(POST_ARGS);

static int post_sh(POST_ARGS);

static int post_sh_body(POST_ARGS);

static int post_sh_head(POST_ARGS);

static int post_sp(POST_ARGS);

static int post_st(POST_ARGS);

static int pre_an(PRE_ARGS);

static int pre_bd(PRE_ARGS);

static int pre_bl(PRE_ARGS);

static int pre_cd(PRE_ARGS);

static int pre_dd(PRE_ARGS);

static int pre_display(PRE_ARGS);

static int pre_dt(PRE_ARGS);

static int pre_er(PRE_ARGS);

static int pre_ex(PRE_ARGS);

static int pre_fd(PRE_ARGS);

static int pre_it(PRE_ARGS);

static int pre_lb(PRE_ARGS);

static int pre_os(PRE_ARGS);

static int pre_rv(PRE_ARGS);

static int pre_sh(PRE_ARGS);

static int pre_ss(PRE_ARGS);

static v_post posts_an[] = { post_an, NULL };

static v_post posts_at[] = { post_at, NULL };

static v_post posts_bd[] = { herr_eq0, bwarn_ge1, NULL };

static v_post posts_bf[] = { hwarn_le1, post_bf, NULL };

static v_post posts_bl[] = { bwarn_ge1, post_bl, NULL };

static v_post posts_bool[] = { eerr_eq1, ebool, NULL };

static v_post posts_fo[] = { hwarn_eq1, bwarn_ge1, NULL };

static v_post posts_in[] = { eerr_eq1, NULL };

static v_post posts_it[] = { post_it, NULL };

static v_post posts_lb[] = { eerr_eq1, post_lb, NULL };

static v_post posts_nd[] = { berr_ge1, NULL };

static v_post posts_nm[] = { post_nm, NULL };

static v_post posts_notext[] = { eerr_eq0, NULL };

static v_post posts_pf[] = { eerr_eq1, NULL };

static v_post posts_sh[] = { herr_ge1, bwarn_ge1, post_sh, NULL };

static v_post posts_sp[] = { post_sp, NULL };

static v_post posts_ss[] = { herr_ge1, NULL };

static v_post posts_st[] = { eerr_eq1, post_st, NULL };

static v_post posts_text[] = { eerr_ge1, NULL };

static v_post posts_wline[] = { bwarn_ge1, herr_eq0, NULL };

static v_post posts_wtext[] = { ewarn_ge1, NULL };

static v_post posts_xr[] = { eerr_ge1, eerr_le2, NULL };

static v_pre pres_an[] = { pre_an, NULL };

static v_pre pres_bd[] = { pre_display, pre_bd, NULL };

static v_pre pres_bl[] = { pre_bl, NULL };

static v_pre pres_cd[] = { pre_cd, NULL };

static v_pre pres_d1[] = { pre_display, NULL };

static v_pre pres_dd[] = { pre_dd, NULL };

static v_pre pres_dt[] = { pre_dt, NULL };

static v_pre pres_er[] = { pre_er, NULL };

static v_pre pres_ex[] = { pre_ex, NULL };

static v_pre pres_fd[] = { pre_fd, NULL };

static v_pre pres_it[] = { pre_it, NULL };

static v_pre pres_lb[] = { pre_lb, NULL };

static v_pre pres_os[] = { pre_os, NULL };

static v_pre pres_rv[] = { pre_rv, NULL };

static v_pre pres_sh[] = { pre_sh, NULL };

static v_pre pres_ss[] = { pre_ss, NULL };

const struct valids mdoc_valids[MDOC_MAX] = {

{ NULL, NULL }, /* \" */

{ NULL, NULL }, /* Ap */

{ pres_dd, posts_text }, /* Dd */

{ pres_dt, NULL }, /* Dt */

{ pres_os, NULL }, /* Os */

{ pres_sh, posts_sh }, /* Sh */

{ pres_ss, posts_ss }, /* Ss */

{ NULL, posts_pp }, /* Pp */

{ NULL, posts_notext }, /* Pp */

{ pres_d1, posts_wline }, /* D1 */

{ pres_d1, posts_wline }, /* Dl */

{ pres_bd, posts_bd }, /* Bd */

Line 213 const struct valids mdoc_valids[MDOC_MAX] = {

Line 173 const struct valids mdoc_valids[MDOC_MAX] = {

{ NULL, NULL }, /* Dv */

{ pres_er, posts_text }, /* Er */

{ NULL, NULL }, /* Ev */

{ pres_ex, posts_ex }, /* Ex */

{ pres_ex, NULL }, /* Ex */

{ NULL, NULL }, /* Fa */

{ pres_fd, posts_wtext }, /* Fd */

{ NULL, NULL }, /* Fl */

Line 222 const struct valids mdoc_valids[MDOC_MAX] = {

Line 182 const struct valids mdoc_valids[MDOC_MAX] = {

{ NULL, posts_text }, /* Ic */

{ NULL, posts_in }, /* In */

{ NULL, NULL }, /* Li */

{ NULL, posts_wtext }, /* Nd */

{ NULL, posts_nd }, /* Nd */

{ NULL, posts_nm }, /* Nm */

{ NULL, posts_wline }, /* Op */

{ NULL, NULL }, /* Ot */

{ NULL, NULL }, /* Pa */

{ pres_rv, posts_rv }, /* Rv */

{ pres_rv, NULL }, /* Rv */

{ NULL, posts_st }, /* St */

{ NULL, NULL }, /* Va */

{ NULL, posts_text }, /* Vt */

Line 298 const struct valids mdoc_valids[MDOC_MAX] = {

Line 258 const struct valids mdoc_valids[MDOC_MAX] = {

{ NULL, NULL }, /* Fr */

{ NULL, posts_notext }, /* Ud */

{ pres_lb, posts_lb }, /* Lb */

{ NULL, NULL }, /* Ap */

{ NULL, posts_notext }, /* Lp */

{ NULL, posts_pp }, /* Lp */

{ NULL, NULL }, /* Lk */

{ NULL, posts_text }, /* Lk */

{ NULL, posts_text }, /* Mt */

{ NULL, posts_wline }, /* Brq */

{ NULL, NULL }, /* Bro */

Line 310 const struct valids mdoc_valids[MDOC_MAX] = {

Line 269 const struct valids mdoc_valids[MDOC_MAX] = {

{ NULL, NULL }, /* En */

{ NULL, NULL }, /* Dx */

{ NULL, posts_text }, /* %Q */

{ NULL, posts_notext }, /* br */

{ NULL, posts_sp }, /* sp */

};

#ifdef __linux__

extern size_t strlcat(char *, const char *, size_t);

#endif

int

mdoc_valid_pre(struct mdoc *mdoc,

mdoc_valid_pre(struct mdoc *mdoc, const struct mdoc_node *n)

const struct mdoc_node *n)

{

v_pre *p;

int line, pos;

Line 349 mdoc_valid_post(struct mdoc *mdoc)

Line 304 mdoc_valid_post(struct mdoc *mdoc)

{

v_post *p;

* This check occurs after the macro's children have been filled

* in: postfix validation. Since this happens when we're

* rewinding the scope tree, it's possible to have multiple

* invocations (as by design, for now), we set bit MDOC_VALID to

* indicate that we've validated.

if (MDOC_VALID & mdoc->last->flags)

return(1);

mdoc->last->flags |= MDOC_VALID;

Line 377 mdoc_valid_post(struct mdoc *mdoc)

Line 324 mdoc_valid_post(struct mdoc *mdoc)

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 (ELINE):

p = "expected line arguments";

break;

case (ENOPROLOGUE):

p = "document has no prologue";

break;

case (ENODATA):

p = "document has no data";

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;

enum mdoc_warn c;

c = WARN_SYNTAX;

p = NULL;

switch (type) {

case (WBADMSEC):

p = "inappropriate manual section";

c = WARN_COMPAT;

break;

case (WBADSEC):

p = "inappropriate document section";

c = WARN_COMPAT;

break;

case (WARGVAL):

p = "argument value suggested";

c = WARN_COMPAT;

break;

case (WPROLREP):

p = "prologue macros repeated";

c = WARN_COMPAT;

break;

case (WPROLOOO):

p = "prologue macros out-of-order";

c = WARN_COMPAT;

break;

case (WDEPCOL):

p = "deprecated column argument syntax";

c = WARN_COMPAT;

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

c = WARN_COMPAT;

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, c, p));

}

static int

warn_print(struct mdoc *m, int ln, int pos)

{

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 527 warn_count(struct mdoc *m, const char *k,

Line 338 warn_count(struct mdoc *m, const char *k,

int want, const char *v, int has)

{

return(mdoc_warn(m, WARN_SYNTAX,

return(mdoc_vwarn(m, m->last->line, m->last->pos,

"suggests %s %s %d (has %d)", v, k, want, has));

}

Line 537 err_count(struct mdoc *m, const char *k,

Line 348 err_count(struct mdoc *m, const char *k,

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

}

static inline int

count_child(struct mdoc *mdoc)

{

int i;

struct mdoc_node *n;

for (i = 0, n = mdoc->last->child; n; n = n->next, i++)

/* Do nothing */ ;

return(i);

}

* Build these up with macros because they're basically the same check

* for different inequalities. Yes, this could be done with functions,

Line 565 count_child(struct mdoc *mdoc)

Line 363 count_child(struct mdoc *mdoc)

static int \

lvl##_child_##name(struct mdoc *mdoc, const char *p, int sz) \

{ \

int i; \

if (mdoc->last->nchild ineq sz) \

if ((i = count_child(mdoc)) ineq sz) \

return(1); \

return(lvl##_count(mdoc, #ineq, sz, p, i)); \

return(lvl##_count(mdoc, #ineq, sz, p, mdoc->last->nchild)); \

}

#define CHECK_BODY_DEFN(name, lvl, func, num) \

Line 605 CHECK_CHILD_DEFN(err, eq, ==) /* err_child_eq() */

Line 402 CHECK_CHILD_DEFN(err, eq, ==) /* err_child_eq() */

CHECK_CHILD_DEFN(err, lt, <) /* err_child_lt() */

CHECK_CHILD_DEFN(warn, lt, <) /* warn_child_lt() */

CHECK_BODY_DEFN(ge1, warn, warn_child_gt, 0) /* bwarn_ge1() */

CHECK_ELEM_DEFN(eq1, warn, warn_child_eq, 1) /* ewarn_eq1() */

CHECK_BODY_DEFN(ge1, err, err_child_gt, 0) /* berr_ge1() */

CHECK_ELEM_DEFN(eq0, warn, warn_child_eq, 0) /* ewarn_eq0() */

CHECK_ELEM_DEFN(ge1, warn, warn_child_gt, 0) /* ewarn_gt1() */

CHECK_ELEM_DEFN(eq1, err, err_child_eq, 1) /* eerr_eq1() */

CHECK_ELEM_DEFN(le2, err, err_child_lt, 3) /* eerr_le2() */

Line 625 check_stdarg(PRE_ARGS)

Line 421 check_stdarg(PRE_ARGS)

if (n->args && 1 == n->args->argc)

if (MDOC_Std == n->args->argv[0].arg)

return(1);

return(nwarn(mdoc, n, WARGVAL));

return(mdoc_nwarn(mdoc, n, EARGVAL));

}

Line 649 check_sec(PRE_ARGS, ...)

Line 445 check_sec(PRE_ARGS, ...)

}

va_end(ap);

return(nwarn(mdoc, n, WBADSEC));

return(mdoc_nwarn(mdoc, n, EBADSEC));

}

Line 671 check_msec(PRE_ARGS, ...)

Line 467 check_msec(PRE_ARGS, ...)

}

va_end(ap);

return(nwarn(mdoc, n, WBADMSEC));

return(mdoc_nwarn(mdoc, n, EBADMSEC));

}

Line 706 check_argv(struct mdoc *m, const struct mdoc_node *n,

Line 502 check_argv(struct mdoc *m, const struct mdoc_node *n,

/* `Nm' name must be set. */

if (v->sz || m->meta.name)

return(1);

return(nerr(m, n, ENAME));

return(mdoc_nerr(m, n, ENAME));

}

return(1);

Line 716 check_argv(struct mdoc *m, const struct mdoc_node *n,

Line 512 check_argv(struct mdoc *m, const struct mdoc_node *n,

static int

check_text(struct mdoc *mdoc, int line, int pos, const char *p)

{

size_t c;

int c;

/* FIXME: indicate deprecated escapes \*(xx and \*x. */

for ( ; *p; p++, pos++) {

for ( ; *p; p++) {

if ('\t' == *p) {

if ( ! (MDOC_LITERAL & mdoc->flags))

if ( ! warn_print(mdoc, line, pos))

Line 732 check_text(struct mdoc *mdoc, int line, int pos, const

Line 526 check_text(struct mdoc *mdoc, int line, int pos, const

if ('\\' != *p)

continue;

c = mdoc_isescape(p);

c = mandoc_special(p);

if (c) {

p += (int)c - 1;

p += c - 1;

pos += c - 1;

continue;

}

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_pwarn(mdoc, line, pos, EESCAPE))

return(0);

}

Line 758 check_parent(PRE_ARGS, int tok, enum mdoc_type t)

Line 553 check_parent(PRE_ARGS, int tok, enum mdoc_type t)

(t == n->parent->type))

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

}

Line 782 pre_display(PRE_ARGS)

Line 577 pre_display(PRE_ARGS)

if (NULL == node)

return(1);

return(nerr(mdoc, n, ENESTDISP));

return(mdoc_nerr(mdoc, n, ENESTDISP));

}

Line 794 pre_bl(PRE_ARGS)

Line 589 pre_bl(PRE_ARGS)

if (MDOC_BLOCK != n->type)

return(1);

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

Line 825 pre_bl(PRE_ARGS)

Line 620 pre_bl(PRE_ARGS)

/* FALLTHROUGH */

case (MDOC_Column):

if (-1 != type)

return(nerr(mdoc, n, EMULTILIST));

return(mdoc_nerr(mdoc, n, EMULTILIST));

type = n->args->argv[pos].arg;

break;

case (MDOC_Width):

if (-1 != width)

return(nerr(mdoc, n, EARGREP));

return(mdoc_nerr(mdoc, n, EARGREP));

width = n->args->argv[pos].arg;

break;

case (MDOC_Offset):

if (-1 != offset)

return(nerr(mdoc, n, EARGREP));

return(mdoc_nerr(mdoc, n, EARGREP));

offset = n->args->argv[pos].arg;

break;

default:

Line 843 pre_bl(PRE_ARGS)

Line 638 pre_bl(PRE_ARGS)

}

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

Line 853 pre_bl(PRE_ARGS)

Line 648 pre_bl(PRE_ARGS)

switch (type) {

case (MDOC_Tag):

if (-1 == width && ! nwarn(mdoc, n, WMISSWIDTH))

if (-1 == width && ! mdoc_nwarn(mdoc, n, EMISSWIDTH))

return(0);

break;

case (MDOC_Column):

Line 863 pre_bl(PRE_ARGS)

Line 658 pre_bl(PRE_ARGS)

case (MDOC_Inset):

/* FALLTHROUGH */

case (MDOC_Item):

if (-1 != width && ! nwarn(mdoc, n, WNOWIDTH))

if (-1 != width && ! mdoc_nwarn(mdoc, n, ENOWIDTH))

return(0);

break;

default:

break;

}

* General validation of fields.

switch (type) {

case (MDOC_Column):

if (0 == n->args->argv[pos].sz)

break;

if ( ! nwarn(mdoc, n, WDEPCOL))

return(0);

break;

default:

break;

}

return(1);

}

Line 897 pre_bd(PRE_ARGS)

Line 677 pre_bd(PRE_ARGS)

if (MDOC_BLOCK != n->type)

return(1);

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

Line 916 pre_bd(PRE_ARGS)

Line 696 pre_bd(PRE_ARGS)

case (MDOC_File):

if (0 == type++)

break;

return(nerr(mdoc, n, EMULTIDISP));

return(mdoc_nerr(mdoc, n, EMULTIDISP));

default:

break;

}

if (type)

return(1);

return(nerr(mdoc, n, EDISPTYPE));

return(mdoc_nerr(mdoc, n, EDISPTYPE));

}

Line 963 pre_an(PRE_ARGS)

Line 743 pre_an(PRE_ARGS)

if (NULL == n->args || 1 == n->args->argc)

return(1);

return(mdoc_nerr(mdoc, n, "only one argument allowed"));

return(mdoc_verr(mdoc, n->line, n->pos,

"only one argument allowed"));

}

Line 1012 pre_cd(PRE_ARGS)

Line 793 pre_cd(PRE_ARGS)

static int

pre_prologue(PRE_ARGS)

{

return(check_sec(mdoc, n, SEC_PROLOGUE, SEC_CUSTOM));

}

static int

pre_dt(PRE_ARGS)

{

if (0 == mdoc->meta.date || mdoc->meta.os)

if ( ! nwarn(mdoc, n, WPROLOOO))

if ( ! mdoc_nwarn(mdoc, n, EPROLOOO))

return(0);

if (mdoc->meta.title)

if ( ! nwarn(mdoc, n, WPROLREP))

if ( ! mdoc_nwarn(mdoc, n, EPROLREP))

return(0);

return(1);

}

Line 1038 pre_os(PRE_ARGS)

Line 811 pre_os(PRE_ARGS)

{

if (NULL == mdoc->meta.title || 0 == mdoc->meta.date)

if ( ! nwarn(mdoc, n, WPROLOOO))

if ( ! mdoc_nwarn(mdoc, n, EPROLOOO))

return(0);

if (mdoc->meta.os)

if ( ! nwarn(mdoc, n, WPROLREP))

if ( ! mdoc_nwarn(mdoc, n, EPROLREP))

return(0);

return(1);

}

Line 1052 pre_dd(PRE_ARGS)

Line 825 pre_dd(PRE_ARGS)

{

if (mdoc->meta.title || mdoc->meta.os)

if ( ! nwarn(mdoc, n, WPROLOOO))

if ( ! mdoc_nwarn(mdoc, n, EPROLOOO))

return(0);

if (mdoc->meta.date)

if ( ! nwarn(mdoc, n, WPROLREP))

if ( ! mdoc_nwarn(mdoc, n, EPROLREP))

return(0);

return(1);

}

Line 1072 post_bf(POST_ARGS)

Line 845 post_bf(POST_ARGS)

head = mdoc->last->head;

if (NULL == mdoc->last->args) {

if (mdoc->last->args && head->child)

if (NULL == head->child ||

return(mdoc_nerr(mdoc, mdoc->last, ELINE));

MDOC_TEXT != head->child->type)

else if (mdoc->last->args)

return(mdoc_err(mdoc, "text argument expected"));

return(1);

p = head->child->string;

if (NULL == head->child || MDOC_TEXT != head->child->type)

if (0 == strcmp(p, "Em"))

return(mdoc_nerr(mdoc, mdoc->last, ELINE));

return(1);

else if (0 == strcmp(p, "Li"))

return(1);

else if (0 == strcmp(p, "Sm"))

return(1);

return(mdoc_nerr(mdoc, head->child, "invalid font"));

}

if (head->child)

p = head->child->string;

return(mdoc_err(mdoc, "one argument expected"));

return(1);

if (0 == strcmp(p, "Em"))

return(1);

else if (0 == strcmp(p, "Li"))

return(1);

else if (0 == strcmp(p, "Sy"))

return(1);

return(mdoc_nerr(mdoc, head, EFONT));

}

static int

post_lb(POST_ARGS)

{

if (mdoc_a2lib(mdoc->last->child->string))

return(1);

return(mdoc_nwarn(mdoc, mdoc->last, ELIB));

}

static int

post_nm(POST_ARGS)

{

Line 1102 post_nm(POST_ARGS)

Line 884 post_nm(POST_ARGS)

return(1);

if (mdoc->meta.name)

return(1);

return(verr(mdoc, ENAME));

return(mdoc_nerr(mdoc, mdoc->last, ENAME));

}

Line 1113 post_at(POST_ARGS)

Line 895 post_at(POST_ARGS)

if (NULL == mdoc->last->child)

return(1);

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

return(1);

return(verr(mdoc, EATT));

return(mdoc_nerr(mdoc, mdoc->last, EATT));

}

Line 1127 post_an(POST_ARGS)

Line 909 post_an(POST_ARGS)

if (mdoc->last->args) {

if (NULL == mdoc->last->child)

return(1);

return(verr(mdoc, ELINE));

return(mdoc_nerr(mdoc, mdoc->last, ENOLINE));

}

if (mdoc->last->child)

return(1);

return(verr(mdoc, ELINE));

return(mdoc_nerr(mdoc, mdoc->last, ELINE));

}

static int

post_args(POST_ARGS)

{

if (mdoc->last->args)

return(1);

return(verr(mdoc, ELINE));

}

static int

post_it(POST_ARGS)

{

int type, i, cols;

Line 1157 post_it(POST_ARGS)

Line 929 post_it(POST_ARGS)

n = mdoc->last->parent->parent;

if (NULL == n->args)

return(verr(mdoc, ELISTTYPE));

return(mdoc_nerr(mdoc, mdoc->last, ELISTTYPE));

/* Some types require block-head, some not. */

Line 1195 post_it(POST_ARGS)

Line 967 post_it(POST_ARGS)

}

if (-1 == type)

return(verr(mdoc, ELISTTYPE));

return(mdoc_nerr(mdoc, mdoc->last, ELISTTYPE));

switch (type) {

case (MDOC_Tag):

if (NULL == mdoc->last->head->child)

if ( ! vwarn(mdoc, WLINE))

if ( ! mdoc_nwarn(mdoc, mdoc->last, ELINE))

return(0);

break;

case (MDOC_Hang):

Line 1211 post_it(POST_ARGS)

Line 983 post_it(POST_ARGS)

/* FALLTHROUGH */

case (MDOC_Diag):

if (NULL == mdoc->last->head->child)

if ( ! vwarn(mdoc, WLINE))

if ( ! mdoc_nwarn(mdoc, mdoc->last, ELINE))

return(0);

if (NULL == mdoc->last->body->child)

if ( ! vwarn(mdoc, WMULTILINE))

if ( ! mdoc_nwarn(mdoc, mdoc->last, EMULTILINE))

return(0);

break;

case (MDOC_Bullet):

Line 1227 post_it(POST_ARGS)

Line 999 post_it(POST_ARGS)

/* FALLTHROUGH */

case (MDOC_Item):

if (mdoc->last->head->child)

if ( ! vwarn(mdoc, WNOLINE))

if ( ! mdoc_nwarn(mdoc, mdoc->last, ENOLINE))

return(0);

if (NULL == mdoc->last->body->child)

if ( ! vwarn(mdoc, WMULTILINE))

if ( ! mdoc_nwarn(mdoc, mdoc->last, EMULTILINE))

return(0);

break;

case (MDOC_Column):

if (NULL == mdoc->last->head->child)

if ( ! vwarn(mdoc, WLINE))

if ( ! mdoc_nwarn(mdoc, mdoc->last, ELINE))

return(0);

if (mdoc->last->body->child)

if ( ! vwarn(mdoc, WNOMULTILINE))

if ( ! mdoc_nwarn(mdoc, mdoc->last, ENOMULTILINE))

return(0);

c = mdoc->last->child;

for (i = 0; c && MDOC_HEAD == c->type; c = c->next)

i++;

if (i == cols)

if (i < cols || i == (cols + 1)) {

if ( ! mdoc_vwarn(mdoc, mdoc->last->line,

mdoc->last->pos, "column "

"mismatch: have %d, want %d",

i, cols))

return(0);

break;

return(mdoc_err(mdoc, "column mismatch (have "

} else if (i == cols)

"%d, want %d)", i, cols));

break;

return(mdoc_verr(mdoc, mdoc->last->line,

mdoc->last->pos, "column mismatch: "

"have %d, want %d", i, cols));

default:

break;

}

Line 1256 post_it(POST_ARGS)

Line 1038 post_it(POST_ARGS)

static int

post_bl_head(POST_ARGS)

{

int i;

const struct mdoc_node *n;

n = mdoc->last->parent;

assert(n->args);

for (i = 0; i < (int)n->args->argc; i++)

if (n->args->argv[i].arg == MDOC_Column)

break;

if (i == (int)n->args->argc)

return(1);

if (n->args->argv[i].sz && mdoc->last->child)

return(mdoc_nerr(mdoc, n, ECOLMIS));

return(1);

}

static int

post_bl(POST_ARGS)

{

struct mdoc_node *n;

if (MDOC_HEAD == mdoc->last->type)

return(post_bl_head(mdoc));

if (MDOC_BODY != mdoc->last->type)

return(1);

if (NULL == mdoc->last->child)

Line 1270 post_bl(POST_ARGS)

Line 1077 post_bl(POST_ARGS)

if (MDOC_BLOCK == n->type)

if (MDOC_It == n->tok)

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

}

Line 1296 ebool(struct mdoc *mdoc)

Line 1104 ebool(struct mdoc *mdoc)

if (NULL == n)

return(1);

return(nerr(mdoc, n, EBOOL));

return(mdoc_nerr(mdoc, n, EBOOL));

}

Line 1305 post_root(POST_ARGS)

Line 1113 post_root(POST_ARGS)

{

if (NULL == mdoc->first->child)

return(verr(mdoc, ENODATA));

return(mdoc_nerr(mdoc, mdoc->first, ENODAT));

if (SEC_PROLOGUE == mdoc->lastnamed)

if ( ! (MDOC_PBODY & mdoc->flags))

return(verr(mdoc, ENOPROLOGUE));

return(mdoc_nerr(mdoc, mdoc->first, ENOPROLOGUE));

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)

return(verr(mdoc, ENODATA));

return(mdoc_nerr(mdoc, mdoc->first, ENODAT));

return(1);

}

static int

post_sp(POST_ARGS)

{

long lval;

char *ep, *buf;

if (NULL == mdoc->last->child)

return(1);

else if ( ! eerr_eq1(mdoc))

return(0);

assert(MDOC_TEXT == mdoc->last->child->type);

buf = mdoc->last->child->string;

assert(buf);

/* From OpenBSD's strtol(3). */

errno = 0;

lval = strtol(buf, &ep, 10);

if (buf[0] == '\0' || *ep != '\0')

return(mdoc_nerr(mdoc, mdoc->last->child, ENUMFMT));

if ((errno == ERANGE && (lval == LONG_MAX || lval == LONG_MIN)) ||

(lval > INT_MAX || lval < 0))

return(mdoc_nerr(mdoc, mdoc->last->child, ENUMFMT));

return(1);

}

static int

post_st(POST_ARGS)

{

if (mdoc_a2st(mdoc->last->child->string))

return(1);

return(vwarn(mdoc, WBADSTAND));

return(mdoc_nerr(mdoc, mdoc->last, EBADSTAND));

}

Line 1346 post_sh_body(POST_ARGS)

Line 1185 post_sh_body(POST_ARGS)

{

struct mdoc_node *n;

if (SEC_NAME != mdoc->lastnamed)

if (SEC_NAME != mdoc->lastsec)

return(1);

Line 1356 post_sh_body(POST_ARGS)

Line 1195 post_sh_body(POST_ARGS)

if (NULL == (n = mdoc->last->child))

return(vwarn(mdoc, WNAMESECINC));

return(mdoc_nwarn(mdoc, mdoc->last, ENAMESECINC));

for ( ; n && n->next; n = n->next) {

if (MDOC_ELEM == n->type && MDOC_Nm == n->tok)

continue;

if (MDOC_TEXT == n->type)

continue;

if ( ! vwarn(mdoc, WNAMESECINC))

if ( ! mdoc_nwarn(mdoc, mdoc->last, ENAMESECINC))

return(0);

}

if (MDOC_ELEM == n->type && MDOC_Nd == n->tok)

assert(n);

if (MDOC_BLOCK == n->type && MDOC_Nd == n->tok)

return(1);

return(vwarn(mdoc, WNAMESECINC));

return(mdoc_nwarn(mdoc, mdoc->last, ENAMESECINC));

}

Line 1387 post_sh_head(POST_ARGS)

Line 1227 post_sh_head(POST_ARGS)

* certain manual sections.

assert(MDOC_Sh == mdoc->last->tok);

/* This is just concat() inlined, which is irritating. */

buf[0] = 0;

for (n = mdoc->last->child; n; n = n->next) {

/* XXX - copied from compact(). */

assert(MDOC_TEXT == n->type);

if (strlcat(buf, n->string, 64) >= 64)

return(nerr(mdoc, n, ETOOLONG));

return(mdoc_nerr(mdoc, n, ETOOLONG));

if (NULL == n->next)

continue;

if (strlcat(buf, " ", 64) >= 64)

return(nerr(mdoc, n, ETOOLONG));

return(mdoc_nerr(mdoc, n, ETOOLONG));

}

sec = mdoc_atosec(buf);

/* The NAME section should always be first. */

* Check: NAME should always be first, CUSTOM has no roles,

* non-CUSTOM has a conventional order to be followed.

if (SEC_BODY == mdoc->lastnamed && SEC_NAME != sec)

if (SEC_NAME != sec && SEC_NONE == mdoc->lastnamed)

return(vwarn(mdoc, WSECOOO));

return(mdoc_nerr(mdoc, mdoc->last, ESECNAME));

if (SEC_CUSTOM == sec)

return(1);

/* Check for repeated or out-of-order sections. */

if (sec == mdoc->lastnamed)

return(vwarn(mdoc, WSECREP));

if ( ! mdoc_nwarn(mdoc, mdoc->last, ESECREP))

return(0);

if (sec < mdoc->lastnamed)

return(vwarn(mdoc, WSECOOO));

if ( ! mdoc_nwarn(mdoc, mdoc->last, ESECOOO))

return(0);

/* Check particular section/manual section conventions. */

* Check particular section/manual conventions. LIBRARY can

* only occur in msec 2, 3 (TODO: are there more of these?).

switch (sec) {

case (SEC_LIBRARY):

Line 1428 post_sh_head(POST_ARGS)

Line 1272 post_sh_head(POST_ARGS)

case (3):

break;

default:

return(vwarn(mdoc, WWRONGMSEC));

return(mdoc_nwarn(mdoc, mdoc->last, EWRONGMSEC));

}

break;

default:

CVSweb