[BACK]Return to man_validate.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Annotation of mandoc/man_validate.c, Revision 1.1

1.1     ! kristaps    1: /* $Id: validate.c,v 1.93 2009/03/23 14:22:11 kristaps Exp $ */
        !             2: /*
        !             3:  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
        !             4:  *
        !             5:  * Permission to use, copy, modify, and distribute this software for any
        !             6:  * purpose with or without fee is hereby granted, provided that the
        !             7:  * above copyright notice and this permission notice appear in all
        !             8:  * copies.
        !             9:  *
        !            10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
        !            11:  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
        !            12:  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
        !            13:  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
        !            14:  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
        !            15:  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
        !            16:  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
        !            17:  * PERFORMANCE OF THIS SOFTWARE.
        !            18:  */
        !            19: #include <sys/types.h>
        !            20:
        !            21: #include <assert.h>
        !            22: #include <ctype.h>
        !            23: #include <stdarg.h>
        !            24: #include <stdlib.h>
        !            25:
        !            26: #include "libman.h"
        !            27:
        !            28: /* FIXME: validate text. */
        !            29:
        !            30: #define        POSTARGS  struct man *m, const struct man_node *n
        !            31:
        !            32: typedef        int     (*v_post)(POSTARGS);
        !            33:
        !            34: struct man_valid {
        !            35:        v_post   *posts;
        !            36: };
        !            37:
        !            38: static int       count(POSTARGS);
        !            39: static int       check_eq0(POSTARGS);
        !            40: static int       check_ge1(POSTARGS);
        !            41: static int       check_ge2(POSTARGS);
        !            42: static int       check_le1(POSTARGS);
        !            43: static int       check_le2(POSTARGS);
        !            44: static int       check_le5(POSTARGS);
        !            45:
        !            46: static v_post    posts_le1[] = { check_le1, NULL };
        !            47: static v_post    posts_le2[] = { check_le2, NULL };
        !            48: static v_post    posts_ge1[] = { check_ge1, NULL };
        !            49: static v_post    posts_eq0[] = { check_eq0, NULL };
        !            50: static v_post    posts_ge2_le5[] = { check_ge2, check_le5, NULL };
        !            51:
        !            52: static const struct man_valid man_valids[MAN_MAX] = {
        !            53:        { NULL }, /* __ */
        !            54:        { posts_ge2_le5 }, /* TH */
        !            55:        { posts_ge1 }, /* SH */
        !            56:        { posts_ge1 }, /* SS */
        !            57:        { posts_le1 }, /* TP */
        !            58:        { posts_eq0 }, /* LP */
        !            59:        { posts_eq0 }, /* PP */
        !            60:        { posts_eq0 }, /* P */
        !            61:        { posts_le2 }, /* IP */
        !            62:        { posts_le1 }, /* HP */
        !            63:        { NULL }, /* SM */
        !            64:        { NULL }, /* SB */
        !            65:        { NULL }, /* BI */
        !            66:        { NULL }, /* IB */
        !            67:        { NULL }, /* BR */
        !            68:        { NULL }, /* RB */
        !            69:        { NULL }, /* R */
        !            70:        { NULL }, /* B */
        !            71:        { NULL }, /* I */
        !            72:        { NULL }, /* IR */
        !            73: };
        !            74:
        !            75:
        !            76: int
        !            77: man_valid_post(struct man *m)
        !            78: {
        !            79:        v_post          *cp;
        !            80:
        !            81:        if (MAN_VALID & m->last->flags)
        !            82:                return(1);
        !            83:
        !            84:        m->last->flags |= MAN_VALID;
        !            85:
        !            86:        switch (m->last->type) {
        !            87:        case (MAN_TEXT):
        !            88:                /* FALLTHROUGH */
        !            89:        case (MAN_ROOT):
        !            90:                return(1);
        !            91:        default:
        !            92:                break;
        !            93:        }
        !            94:
        !            95:        if (NULL == (cp = man_valids[m->last->tok].posts))
        !            96:                return(1);
        !            97:        for ( ; *cp; cp++)
        !            98:                if ( ! (*cp)(m, m->last))
        !            99:                        return(0);
        !           100:
        !           101:        return(1);
        !           102: }
        !           103:
        !           104:
        !           105: static inline int
        !           106: count(POSTARGS)
        !           107: {
        !           108:        int              i;
        !           109:
        !           110:        for (i = 0; n; n = n->next, i++)
        !           111:                /* Loop. */ ;
        !           112:        return(i);
        !           113: }
        !           114:
        !           115:
        !           116: #define        INEQ_DEFINE(x, ineq, name) \
        !           117: static int \
        !           118: check_##name(POSTARGS) \
        !           119: { \
        !           120:        int              c; \
        !           121:        if ((c = count(m, n->child)) ineq (x)) \
        !           122:                return(1); \
        !           123:        return(man_vwarn(m, n->line, n->pos, \
        !           124:                        "expected line arguments %s %d, have %d", \
        !           125:                        #ineq, (x), c)); \
        !           126: }
        !           127:
        !           128: INEQ_DEFINE(0, ==, eq0)
        !           129: INEQ_DEFINE(1, >=, ge1)
        !           130: INEQ_DEFINE(2, >=, ge2)
        !           131: INEQ_DEFINE(1, <=, le1)
        !           132: INEQ_DEFINE(2, <=, le2)
        !           133: INEQ_DEFINE(5, <=, le5)
        !           134:

CVSweb