src: expr: add expression etype

Temporary kludge to remove all the expr->ops->type == ... patterns.
Followup patch will remove expr->ops, and make expr_ops() lookup
the correct expr_ops struct instead to reduce struct expr size.

Signed-off-by: Florian Westphal <fw@strlen.de>

diff --git a/include/expression.h b/include/expression.h
index 8a4cf5b10b8c87ed6fde3b93cf890f1100d04279..2450bc90ec99ca7e42b1d48a6ccbcedd6b9a2fe8 100644 (file)
--- a/include/expression.h
+++ b/include/expression.h
@@ -220,6 +220,7 @@ struct expr {
 
        const struct datatype   *dtype;
        enum byteorder          byteorder;
+       enum expr_types         etype:8;
        unsigned int            len;
 
        const struct expr_ops   *ops;
@@ -411,7 +412,7 @@ const char *expr_name(const struct expr *e);
 static inline void symbol_expr_set_type(struct expr *expr,
                                        const struct datatype *dtype)
 {
-       if (expr->ops->type == EXPR_SYMBOL)
+       if (expr->etype == EXPR_SYMBOL)
                expr->dtype = dtype;
 }
 

diff --git a/src/datatype.c b/src/datatype.c
index 0e74583302aad3d441882043528e56032188c3f8..ac9f2af1ad4de0a35de877163affa6cf02a734f2 100644 (file)
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -118,7 +118,7 @@ struct error_record *symbol_parse(const struct expr *sym,
 {
        const struct datatype *dtype = sym->dtype;
 
-       assert(sym->ops->type == EXPR_SYMBOL);
+       assert(sym->etype == EXPR_SYMBOL);
 
        if (dtype == NULL)
                return error(&sym->location, "No symbol type information");

diff --git a/src/evaluate.c b/src/evaluate.c
index be788daab06da334b35e71b9b6cd11f96b395b36..29c436cd3cff78d31878da0789ae42081d97653d 100644 (file)
--- a/src/evaluate.c
+++ b/src/evaluate.c
@@ -439,7 +439,7 @@ static void expr_evaluate_bits(struct eval_ctx *ctx, struct expr **exprp)
        uint8_t shift;
        mpz_t bitmask;
 
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_PAYLOAD:
                shift = expr_offset_shift(expr, expr->payload.offset,
                                          &extra_len);
@@ -651,7 +651,7 @@ static int __expr_evaluate_payload(struct eval_ctx *ctx, struct expr *expr)
        struct stmt *nstmt;
        int err;
 
-       if (expr->ops->type == EXPR_PAYLOAD && expr->payload.is_raw)
+       if (expr->etype == EXPR_PAYLOAD && expr->payload.is_raw)
                return 0;
 
        desc = ctx->pctx.protocol[base].desc;
@@ -938,7 +938,7 @@ static int expr_evaluate_unary(struct eval_ctx *ctx, struct expr **expr)
 
        assert(!expr_is_constant(arg));
        assert(expr_basetype(arg)->type == TYPE_INTEGER);
-       assert(arg->ops->type != EXPR_UNARY);
+       assert(arg->etype != EXPR_UNARY);
 
        switch (unary->op) {
        case OP_HTON:
@@ -968,8 +968,8 @@ static int constant_binop_simplify(struct eval_ctx *ctx, struct expr **expr)
        struct expr *new;
        mpz_t val, mask;
 
-       assert(left->ops->type == EXPR_VALUE);
-       assert(right->ops->type == EXPR_VALUE);
+       assert(left->etype == EXPR_VALUE);
+       assert(right->etype == EXPR_VALUE);
        assert(left->byteorder == right->byteorder);
 
        mpz_init2(val, op->len);
@@ -1198,7 +1198,7 @@ static int expr_evaluate_list(struct eval_ctx *ctx, struct expr **expr)
        list_for_each_entry_safe(i, next, &list->expressions, list) {
                if (list_member_evaluate(ctx, &i) < 0)
                        return -1;
-               if (i->ops->type != EXPR_VALUE)
+               if (i->etype != EXPR_VALUE)
                        return expr_error(ctx->msgs, i,
                                          "List member must be a constant "
                                          "value");
@@ -1228,7 +1228,7 @@ static int expr_evaluate_set_elem(struct eval_ctx *ctx, struct expr **expr)
 
        if (ctx->set &&
            !(ctx->set->flags & (NFT_SET_ANONYMOUS | NFT_SET_INTERVAL))) {
-               switch (elem->key->ops->type) {
+               switch (elem->key->etype) {
                case EXPR_PREFIX:
                        return expr_error(ctx->msgs, elem,
                                          "Set member cannot be prefix, "
@@ -1256,13 +1256,13 @@ static int expr_evaluate_set(struct eval_ctx *ctx, struct expr **expr)
                if (list_member_evaluate(ctx, &i) < 0)
                        return -1;
 
-               if (i->ops->type == EXPR_SET_ELEM &&
-                   i->key->ops->type == EXPR_SET_REF)
+               if (i->etype == EXPR_SET_ELEM &&
+                   i->key->etype == EXPR_SET_REF)
                        return expr_error(ctx->msgs, i,
                                          "Set reference cannot be part of another set");
 
-               if (i->ops->type == EXPR_SET_ELEM &&
-                   i->key->ops->type == EXPR_SET) {
+               if (i->etype == EXPR_SET_ELEM &&
+                   i->key->etype == EXPR_SET) {
                        struct expr *new = expr_clone(i->key);
 
                        set->set_flags |= i->key->set_flags;
@@ -1275,7 +1275,7 @@ static int expr_evaluate_set(struct eval_ctx *ctx, struct expr **expr)
                        return expr_error(ctx->msgs, i,
                                          "Set member is not constant");
 
-               if (i->ops->type == EXPR_SET) {
+               if (i->etype == EXPR_SET) {
                        /* Merge recursive set definitions */
                        list_splice_tail_init(&i->expressions, &i->list);
                        list_del(&i->list);
@@ -1311,7 +1311,7 @@ static int expr_evaluate_map(struct eval_ctx *ctx, struct expr **expr)
        mappings = map->mappings;
        mappings->set_flags |= NFT_SET_MAP;
 
-       switch (map->mappings->ops->type) {
+       switch (map->mappings->etype) {
        case EXPR_SET:
                key = constant_expr_alloc(&map->location,
                                 ctx->ectx.dtype,
@@ -1342,7 +1342,7 @@ static int expr_evaluate_map(struct eval_ctx *ctx, struct expr **expr)
        case EXPR_SYMBOL:
                if (expr_evaluate(ctx, &map->mappings) < 0)
                        return -1;
-               if (map->mappings->ops->type != EXPR_SET_REF ||
+               if (map->mappings->etype != EXPR_SET_REF ||
                    !(map->mappings->set->flags & NFT_SET_MAP))
                        return expr_error(ctx->msgs, map->mappings,
                                          "Expression is not a map");
@@ -1463,7 +1463,7 @@ static int binop_can_transfer(struct eval_ctx *ctx,
 {
        int err;
 
-       switch (right->ops->type) {
+       switch (right->etype) {
        case EXPR_VALUE:
                break;
        case EXPR_SET_ELEM:
@@ -1501,7 +1501,7 @@ static int binop_transfer_one(struct eval_ctx *ctx,
 {
        int err;
 
-       switch ((*right)->ops->type) {
+       switch ((*right)->etype) {
        case EXPR_MAPPING:
                return binop_transfer_one(ctx, left, &(*right)->left);
        case EXPR_VALUE:
@@ -1544,7 +1544,7 @@ static void binop_transfer_handle_lhs(struct expr **expr)
        struct expr *tmp, *left = *expr;
        unsigned int shift;
 
-       assert(left->ops->type == EXPR_BINOP);
+       assert(left->etype == EXPR_BINOP);
 
        switch (left->op) {
        case OP_RSHIFT:
@@ -1572,9 +1572,9 @@ static int __binop_transfer(struct eval_ctx *ctx,
        struct expr *i, *next;
        int err;
 
-       assert(left->ops->type == EXPR_BINOP);
+       assert(left->etype == EXPR_BINOP);
 
-       switch ((*right)->ops->type) {
+       switch ((*right)->etype) {
        case EXPR_VALUE:
                err = binop_can_transfer(ctx, left, *right);
                if (err <= 0)
@@ -1617,7 +1617,7 @@ static int binop_transfer(struct eval_ctx *ctx, struct expr **expr)
        struct expr *left = (*expr)->left;
        int ret;
 
-       if (left->ops->type != EXPR_BINOP)
+       if (left->etype != EXPR_BINOP)
                return 0;
 
        ret = __binop_transfer(ctx, left, &(*expr)->right);
@@ -1670,7 +1670,7 @@ static int expr_evaluate_relational(struct eval_ctx *ctx, struct expr **expr)
 
                /* fall through */
        case OP_NEQ:
-               switch (right->ops->type) {
+               switch (right->etype) {
                case EXPR_RANGE:
                        if (byteorder_conversion(ctx, &rel->left, BYTEORDER_BIG_ENDIAN) < 0)
                                return -1;
@@ -1705,7 +1705,7 @@ static int expr_evaluate_relational(struct eval_ctx *ctx, struct expr **expr)
        case OP_GT:
        case OP_LTE:
        case OP_GTE:
-               switch (left->ops->type) {
+               switch (left->etype) {
                case EXPR_CONCAT:
                        return expr_binary_error(ctx->msgs, left, rel,
                                        "Relational expression (%s) is undefined "
@@ -1824,7 +1824,7 @@ static int expr_evaluate(struct eval_ctx *ctx, struct expr **expr)
                erec_destroy(erec);
        }
 
-       switch ((*expr)->ops->type) {
+       switch ((*expr)->etype) {
        case EXPR_SYMBOL:
                return expr_evaluate_symbol(ctx, expr);
        case EXPR_VARIABLE:
@@ -1898,7 +1898,7 @@ static int stmt_evaluate_arg(struct eval_ctx *ctx, struct stmt *stmt,
        if (expr_evaluate(ctx, expr) < 0)
                return -1;
 
-       if ((*expr)->ops->type == EXPR_PAYLOAD &&
+       if ((*expr)->etype == EXPR_PAYLOAD &&
            (*expr)->dtype->type == TYPE_INTEGER &&
            ((*expr)->dtype->type != datatype_basetype(dtype)->type ||
             (*expr)->len != len))
@@ -1915,7 +1915,7 @@ static int stmt_evaluate_arg(struct eval_ctx *ctx, struct stmt *stmt,
                                         dtype->desc, (*expr)->dtype->desc);
 
        /* we are setting a value, we can't use a set */
-       switch ((*expr)->ops->type) {
+       switch ((*expr)->etype) {
        case EXPR_SET:
                return stmt_binary_error(ctx, *expr, stmt,
                                         "you cannot use a set here, unknown "
@@ -1938,7 +1938,7 @@ static int stmt_evaluate_verdict(struct eval_ctx *ctx, struct stmt *stmt)
        if (stmt_evaluate_arg(ctx, stmt, &verdict_type, 0, 0, &stmt->expr) < 0)
                return -1;
 
-       switch (stmt->expr->ops->type) {
+       switch (stmt->expr->etype) {
        case EXPR_VERDICT:
                if (stmt->expr->verdict != NFT_CONTINUE)
                        stmt->flags |= STMT_F_TERMINAL;
@@ -2605,7 +2605,7 @@ static int stmt_evaluate_tproxy(struct eval_ctx *ctx, struct stmt *stmt)
                                  "Conflicting network layer protocols.");
 
        if (stmt->tproxy.addr != NULL) {
-               if (stmt->tproxy.addr->ops->type == EXPR_RANGE)
+               if (stmt->tproxy.addr->etype == EXPR_RANGE)
                        return stmt_error(ctx, stmt, "Address ranges are not supported for tproxy.");
                if (ctx->pctx.family == NFPROTO_INET) {
                        switch (stmt->tproxy.family) {
@@ -2635,7 +2635,7 @@ static int stmt_evaluate_tproxy(struct eval_ctx *ctx, struct stmt *stmt)
        }
 
        if (stmt->tproxy.port != NULL) {
-               if (stmt->tproxy.port->ops->type == EXPR_RANGE)
+               if (stmt->tproxy.port->etype == EXPR_RANGE)
                        return stmt_error(ctx, stmt, "Port ranges are not supported for tproxy.");
                err = nat_evaluate_transport(ctx, stmt, &stmt->tproxy.port);
                if (err < 0)
@@ -2740,7 +2740,7 @@ static int stmt_evaluate_queue(struct eval_ctx *ctx, struct stmt *stmt)
                if (!expr_is_constant(stmt->queue.queue))
                        return expr_error(ctx->msgs, stmt->queue.queue,
                                          "queue number is not constant");
-               if (stmt->queue.queue->ops->type != EXPR_RANGE &&
+               if (stmt->queue.queue->etype != EXPR_RANGE &&
                    (stmt->queue.flags & NFT_QUEUE_FLAG_CPU_FANOUT))
                        return expr_error(ctx->msgs, stmt->queue.queue,
                                          "fanout requires a range to be "
@@ -2772,7 +2772,7 @@ static int stmt_evaluate_set(struct eval_ctx *ctx, struct stmt *stmt)
        expr_set_context(&ctx->ectx, NULL, 0);
        if (expr_evaluate(ctx, &stmt->set.set) < 0)
                return -1;
-       if (stmt->set.set->ops->type != EXPR_SET_REF)
+       if (stmt->set.set->etype != EXPR_SET_REF)
                return expr_error(ctx->msgs, stmt->set.set,
                                  "Expression does not refer to a set");
 
@@ -2804,7 +2804,7 @@ static int stmt_evaluate_map(struct eval_ctx *ctx, struct stmt *stmt)
        expr_set_context(&ctx->ectx, NULL, 0);
        if (expr_evaluate(ctx, &stmt->map.set) < 0)
                return -1;
-       if (stmt->map.set->ops->type != EXPR_SET_REF)
+       if (stmt->map.set->etype != EXPR_SET_REF)
                return expr_error(ctx->msgs, stmt->map.set,
                                  "Expression does not refer to a set");
 
@@ -2861,7 +2861,7 @@ static int stmt_evaluate_objref_map(struct eval_ctx *ctx, struct stmt *stmt)
        mappings = map->mappings;
        mappings->set_flags |= NFT_SET_OBJECT;
 
-       switch (map->mappings->ops->type) {
+       switch (map->mappings->etype) {
        case EXPR_SET:
                key = constant_expr_alloc(&stmt->location,
                                          ctx->ectx.dtype,
@@ -2887,7 +2887,7 @@ static int stmt_evaluate_objref_map(struct eval_ctx *ctx, struct stmt *stmt)
        case EXPR_SYMBOL:
                if (expr_evaluate(ctx, &map->mappings) < 0)
                        return -1;
-               if (map->mappings->ops->type != EXPR_SET_REF)
+               if (map->mappings->etype != EXPR_SET_REF)
                        return expr_error(ctx->msgs, map->mappings,
                                          "Expression is not a map");
                if (!(map->mappings->set->flags & NFT_SET_OBJECT))
@@ -2920,7 +2920,7 @@ static int stmt_evaluate_objref_map(struct eval_ctx *ctx, struct stmt *stmt)
 static int stmt_evaluate_objref(struct eval_ctx *ctx, struct stmt *stmt)
 {
        /* We need specific map evaluation for stateful objects. */
-       if (stmt->objref.expr->ops->type == EXPR_MAP)
+       if (stmt->objref.expr->etype == EXPR_MAP)
                return stmt_evaluate_objref_map(ctx, stmt);
 
        if (stmt_evaluate_arg(ctx, stmt,
@@ -3035,7 +3035,7 @@ static int set_evaluate(struct eval_ctx *ctx, struct set *set)
                                 type);
 
        if (set->key->len == 0) {
-               if (set->key->ops->type == EXPR_CONCAT &&
+               if (set->key->etype == EXPR_CONCAT &&
                    expr_evaluate_concat(ctx, &set->key, false) < 0)
                        return -1;
 
@@ -3045,7 +3045,7 @@ static int set_evaluate(struct eval_ctx *ctx, struct set *set)
                                         set->key->dtype->name, type);
        }
        if (set->flags & NFT_SET_INTERVAL &&
-           set->key->ops->type == EXPR_CONCAT)
+           set->key->etype == EXPR_CONCAT)
                return set_error(ctx, set, "concatenated types not supported in interval sets");
 
        if (set->flags & NFT_SET_MAP) {

diff --git a/src/expression.c b/src/expression.c
index 309a0f133b4550b6ca7ea9375dff7403bb4cc2d5..8a7e0e7ab66931326ac8e6b01a4efc97a87df17e 100644 (file)
--- a/src/expression.c
+++ b/src/expression.c
@@ -40,6 +40,7 @@ struct expr *expr_alloc(const struct location *loc, const struct expr_ops *ops,
        expr->location  = *loc;
        expr->ops       = ops;
        expr->dtype     = dtype;
+       expr->etype     = ops->type;
        expr->byteorder = byteorder;
        expr->len       = len;
        expr->refcnt    = 1;
@@ -97,7 +98,7 @@ bool expr_cmp(const struct expr *e1, const struct expr *e2)
        assert(e1->flags & EXPR_F_SINGLETON);
        assert(e2->flags & EXPR_F_SINGLETON);
 
-       if (e1->ops->type != e2->ops->type)
+       if (e1->etype != e2->etype)
                return false;
 
        return expr_ops(e1)->cmp(e1, e2);
@@ -373,8 +374,8 @@ struct expr *constant_expr_join(const struct expr *e1, const struct expr *e2)
        unsigned int len = (e1->len + e2->len) / BITS_PER_BYTE, tmp;
        unsigned char data[len];
 
-       assert(e1->ops->type == EXPR_VALUE);
-       assert(e2->ops->type == EXPR_VALUE);
+       assert(e1->etype == EXPR_VALUE);
+       assert(e2->etype == EXPR_VALUE);
 
        tmp = e1->len / BITS_PER_BYTE;
        mpz_export_data(data, e1->value, e1->byteorder, tmp);
@@ -391,7 +392,7 @@ struct expr *constant_expr_splice(struct expr *expr, unsigned int len)
        struct expr *slice;
        mpz_t mask;
 
-       assert(expr->ops->type == EXPR_VALUE);
+       assert(expr->etype == EXPR_VALUE);
        assert(len <= expr->len);
 
        slice = constant_expr_alloc(&expr->location, &invalid_type,
@@ -437,7 +438,7 @@ struct expr *bitmask_expr_to_binops(struct expr *expr)
        struct expr *binop, *flag;
        unsigned long n;
 
-       assert(expr->ops->type == EXPR_VALUE);
+       assert(expr->etype == EXPR_VALUE);
        assert(expr->dtype->basetype->type == TYPE_BITMASK);
 
        n = mpz_popcount(expr->value);
@@ -574,7 +575,7 @@ static void binop_arg_print(const struct expr *op, const struct expr *arg,
 {
        bool prec = false;
 
-       if (arg->ops->type == EXPR_BINOP &&
+       if (arg->etype == EXPR_BINOP &&
            expr_binop_precedence[op->op] != 0 &&
            expr_binop_precedence[op->op] < expr_binop_precedence[arg->op])
                prec = 1;
@@ -590,10 +591,10 @@ bool must_print_eq_op(const struct expr *expr)
 {
        if (expr->right->dtype->basetype != NULL &&
            expr->right->dtype->basetype->type == TYPE_BITMASK &&
-           expr->right->ops->type == EXPR_VALUE)
+           expr->right->etype == EXPR_VALUE)
                return true;
 
-       return expr->left->ops->type == EXPR_BINOP;
+       return expr->left->etype == EXPR_BINOP;
 }
 
 static void binop_expr_print(const struct expr *expr, struct output_ctx *octx)
@@ -674,7 +675,7 @@ void relational_expr_pctx_update(struct proto_ctx *ctx,
        const struct expr *left = expr->left;
        const struct expr_ops *ops;
 
-       assert(expr->ops->type == EXPR_RELATIONAL);
+       assert(expr->etype == EXPR_RELATIONAL);
        assert(expr->op == OP_EQ || expr->op == OP_IMPLICIT);
 
        ops = expr_ops(left);
@@ -982,7 +983,7 @@ struct expr *mapping_expr_alloc(const struct location *loc,
 static void map_expr_print(const struct expr *expr, struct output_ctx *octx)
 {
        expr_print(expr->map, octx);
-       if (expr->mappings->ops->type == EXPR_SET_REF &&
+       if (expr->mappings->etype == EXPR_SET_REF &&
            expr->mappings->set->datatype->type == TYPE_VERDICT)
                nft_print(octx, " vmap ");
        else
@@ -1119,7 +1120,7 @@ struct expr *set_elem_expr_alloc(const struct location *loc, struct expr *key)
 
 void range_expr_value_low(mpz_t rop, const struct expr *expr)
 {
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_VALUE:
                return mpz_set(rop, expr->value);
        case EXPR_PREFIX:
@@ -1139,7 +1140,7 @@ void range_expr_value_high(mpz_t rop, const struct expr *expr)
 {
        mpz_t tmp;
 
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_VALUE:
                return mpz_set(rop, expr->value);
        case EXPR_PREFIX:

diff --git a/src/exthdr.c b/src/exthdr.c
index cb0a58e8526a5c6f480ef71afe8d292702e5dbb3..8f803be6fc4a179d73f952b4b679d678c4f22c5e 100644 (file)
--- a/src/exthdr.c
+++ b/src/exthdr.c
@@ -162,7 +162,7 @@ void exthdr_init_raw(struct expr *expr, uint8_t type,
        const struct proto_hdr_template *tmpl = &exthdr_unknown_template;
        unsigned int i;
 
-       assert(expr->ops->type == EXPR_EXTHDR);
+       assert(expr->etype == EXPR_EXTHDR);
        if (op == NFT_EXTHDR_OP_TCPOPT)
                return tcpopt_init_raw(expr, type, offset, len, flags);
 

diff --git a/src/json.c b/src/json.c
index 2a70e42f78023f06b1c36624706426e906f7db26..dd7353e400126489477f9dd852247a5f29eb8139 100644 (file)
--- a/src/json.c
+++ b/src/json.c
@@ -607,7 +607,7 @@ json_t *map_expr_json(const struct expr *expr, struct output_ctx *octx)
 {
        const char *type = "map";
 
-       if (expr->mappings->ops->type == EXPR_SET_REF &&
+       if (expr->mappings->etype == EXPR_SET_REF &&
            expr->mappings->set->datatype->type == TYPE_VERDICT)
                type = "vmap";
 

diff --git a/src/mergesort.c b/src/mergesort.c
index f2e38bc2e48557ea15944c9bd4febb856a86562b..649b7806a7af2dadb6d8e567b00c87f736027128 100644 (file)
--- a/src/mergesort.c
+++ b/src/mergesort.c
@@ -34,7 +34,7 @@ static int concat_expr_msort_cmp(const struct expr *e1, const struct expr *e2)
 
 static int expr_msort_cmp(const struct expr *e1, const struct expr *e2)
 {
-       switch (e1->ops->type) {
+       switch (e1->etype) {
        case EXPR_SET_ELEM:
                return expr_msort_cmp(e1->key, e2->key);
        case EXPR_VALUE:

diff --git a/src/monitor.c b/src/monitor.c
index 0e735ed5b1aa7d3348407aa347418556f6c97c87..35dc4501b4c4f6a9d9ca7bc3663ece58ff7a447b 100644 (file)
--- a/src/monitor.c
+++ b/src/monitor.c
@@ -330,7 +330,7 @@ static bool netlink_event_ignore_range_event(struct nftnl_set_elem *nlse)
 
 static bool set_elem_is_open_interval(struct expr *elem)
 {
-       switch (elem->ops->type) {
+       switch (elem->etype) {
        case EXPR_SET_ELEM:
                return elem->elem_flags & SET_ELEM_F_INTERVAL_OPEN;
        case EXPR_MAPPING:

diff --git a/src/netlink.c b/src/netlink.c
index dfd563a2e94d33e8658e95359959a9c6947201be..9e0e07d4c5b088146b62d161c546d6fd5acc104e 100644 (file)
--- a/src/netlink.c
+++ b/src/netlink.c
@@ -108,7 +108,7 @@ static struct nftnl_set_elem *alloc_nftnl_setelem(const struct expr *set,
                memory_allocation_error();
 
        data = NULL;
-       if (expr->ops->type == EXPR_MAPPING) {
+       if (expr->etype == EXPR_MAPPING) {
                elem = expr->left;
                if (!(expr->flags & EXPR_F_INTERVAL_END))
                        data = expr->right;
@@ -145,7 +145,7 @@ static struct nftnl_set_elem *alloc_nftnl_setelem(const struct expr *set,
        }
        if (set->set_flags & NFT_SET_MAP && data != NULL) {
                netlink_gen_data(data, &nld);
-               switch (data->ops->type) {
+               switch (data->etype) {
                case EXPR_VERDICT:
                        nftnl_set_elem_set_u32(nlse, NFTNL_SET_ELEM_VERDICT,
                                               data->verdict);
@@ -196,7 +196,7 @@ static void netlink_gen_concat_data(const struct expr *expr,
                memset(data, 0, sizeof(data));
                offset = 0;
                list_for_each_entry(i, &expr->expressions, list) {
-                       assert(i->ops->type == EXPR_VALUE);
+                       assert(i->etype == EXPR_VALUE);
                        mpz_export_data(data + offset, i->value, i->byteorder,
                                        div_round_up(i->len, BITS_PER_BYTE));
                        offset += netlink_padded_len(i->len) / BITS_PER_BYTE;
@@ -210,7 +210,7 @@ static void netlink_gen_concat_data(const struct expr *expr,
 static void netlink_gen_constant_data(const struct expr *expr,
                                      struct nft_data_linearize *data)
 {
-       assert(expr->ops->type == EXPR_VALUE);
+       assert(expr->etype == EXPR_VALUE);
        netlink_gen_raw_data(expr->value, expr->byteorder,
                             div_round_up(expr->len, BITS_PER_BYTE), data);
 }
@@ -231,7 +231,7 @@ static void netlink_gen_verdict(const struct expr *expr,
 
 void netlink_gen_data(const struct expr *expr, struct nft_data_linearize *data)
 {
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_VALUE:
                return netlink_gen_constant_data(expr, data);
        case EXPR_CONCAT:

diff --git a/src/netlink_delinearize.c b/src/netlink_delinearize.c
index 21c6858ab4a8fc0f8f6cfd898afb79c76940f32a..d0eaf5b622037585bbccee1f2005a534d3273c14 100644 (file)
--- a/src/netlink_delinearize.c
+++ b/src/netlink_delinearize.c
@@ -1532,7 +1532,6 @@ static void payload_match_expand(struct rule_pp_ctx *ctx,
        struct stmt *nstmt;
        struct expr *nexpr = NULL;
        enum proto_bases base = left->payload.base;
-       const struct expr_ops *payload_ops = left->ops;
        bool stacked;
 
        payload_expr_expand(&list, left, &ctx->pctx);
@@ -1549,7 +1548,7 @@ static void payload_match_expand(struct rule_pp_ctx *ctx,
                nstmt = expr_stmt_alloc(&ctx->stmt->location, nexpr);
                list_add_tail(&nstmt->list, &ctx->stmt->list);
 
-               assert(left->ops == payload_ops);
+               assert(left->etype == EXPR_PAYLOAD);
                assert(left->payload.base);
                assert(base == left->payload.base);
 
@@ -1587,7 +1586,7 @@ static void payload_match_postprocess(struct rule_pp_ctx *ctx,
        switch (expr->op) {
        case OP_EQ:
        case OP_NEQ:
-               if (expr->right->ops->type == EXPR_VALUE) {
+               if (expr->right->etype == EXPR_VALUE) {
                        payload_match_expand(ctx, expr, payload);
                        break;
                }
@@ -1631,7 +1630,7 @@ static bool meta_may_dependency_kill(struct payload_dep_ctx *ctx,
 
        l3proto = mpz_get_uint16(dep->right->value);
 
-       switch (dep->left->ops->type) {
+       switch (dep->left->etype) {
        case EXPR_META:
                if (dep->left->meta.key != NFT_META_NFPROTO)
                        return true;
@@ -1679,14 +1678,14 @@ static void ct_meta_common_postprocess(struct rule_pp_ctx *ctx,
        const struct expr *left = expr->left;
        struct expr *right = expr->right;
 
-       if (right->ops->type == EXPR_SET || right->ops->type == EXPR_SET_REF)
+       if (right->etype == EXPR_SET || right->etype == EXPR_SET_REF)
                expr_set_type(right, left->dtype, left->byteorder);
 
        switch (expr->op) {
        case OP_EQ:
-               if (expr->right->ops->type == EXPR_RANGE ||
-                   expr->right->ops->type == EXPR_SET ||
-                   expr->right->ops->type == EXPR_SET_REF)
+               if (expr->right->etype == EXPR_RANGE ||
+                   expr->right->etype == EXPR_SET ||
+                   expr->right->etype == EXPR_SET_REF)
                        break;
 
                relational_expr_pctx_update(&ctx->pctx, expr);
@@ -1750,7 +1749,7 @@ static bool expr_mask_is_prefix(const struct expr *expr)
 /* Convert a series of inclusive OR expressions into a list */
 static struct expr *binop_tree_to_list(struct expr *list, struct expr *expr)
 {
-       if (expr->ops->type == EXPR_BINOP && expr->op == OP_OR) {
+       if (expr->etype == EXPR_BINOP && expr->op == OP_OR) {
                if (list == NULL)
                        list = list_expr_alloc(&expr->location);
                list = binop_tree_to_list(list, expr->left);
@@ -1772,7 +1771,7 @@ static void binop_adjust_one(const struct expr *binop, struct expr *value,
        assert(value->len >= binop->right->len);
 
        mpz_rshift_ui(value->value, shift);
-       switch (left->ops->type) {
+       switch (left->etype) {
        case EXPR_PAYLOAD:
        case EXPR_EXTHDR:
                value->len = left->len;
@@ -1788,13 +1787,13 @@ static void __binop_adjust(const struct expr *binop, struct expr *right,
 {
        struct expr *i;
 
-       switch (right->ops->type) {
+       switch (right->etype) {
        case EXPR_VALUE:
                binop_adjust_one(binop, right, shift);
                break;
        case EXPR_SET_REF:
                list_for_each_entry(i, &right->set->init->expressions, list) {
-                       switch (i->key->ops->type) {
+                       switch (i->key->etype) {
                        case EXPR_VALUE:
                                binop_adjust_one(binop, i->key, shift);
                                break;
@@ -1832,9 +1831,9 @@ static void binop_postprocess(struct rule_pp_ctx *ctx, struct expr *expr)
        struct expr *mask = binop->right;
        unsigned int shift;
 
-       if ((left->ops->type == EXPR_PAYLOAD &&
+       if ((left->etype == EXPR_PAYLOAD &&
            payload_expr_trim(left, mask, &ctx->pctx, &shift)) ||
-           (left->ops->type == EXPR_EXTHDR &&
+           (left->etype == EXPR_EXTHDR &&
             exthdr_find_template(left, mask, &shift))) {
                /* mask is implicit, binop needs to be removed.
                 *
@@ -1847,13 +1846,13 @@ static void binop_postprocess(struct rule_pp_ctx *ctx, struct expr *expr)
                 */
                binop_adjust(expr, shift);
 
-               assert(expr->left->ops->type == EXPR_BINOP);
+               assert(expr->left->etype == EXPR_BINOP);
                assert(binop->left == left);
                expr->left = expr_get(left);
                expr_free(binop);
-               if (left->ops->type == EXPR_PAYLOAD)
+               if (left->etype == EXPR_PAYLOAD)
                        payload_match_postprocess(ctx, expr, left);
-               else if (left->ops->type == EXPR_EXTHDR)
+               else if (left->etype == EXPR_EXTHDR)
                        expr_set_type(expr->right, left->dtype, left->byteorder);
        }
 }
@@ -1865,8 +1864,8 @@ static void map_binop_postprocess(struct rule_pp_ctx *ctx, struct expr *expr)
        if (binop->op != OP_AND)
                return;
 
-       if (binop->left->ops->type == EXPR_PAYLOAD &&
-           binop->right->ops->type == EXPR_VALUE)
+       if (binop->left->etype == EXPR_PAYLOAD &&
+           binop->right->etype == EXPR_VALUE)
                binop_postprocess(ctx, expr);
 }
 
@@ -1900,7 +1899,7 @@ static void relational_binop_postprocess(struct rule_pp_ctx *ctx, struct expr *e
                expr_free(value);
                expr_free(binop);
        } else if (binop->op == OP_AND &&
-                  binop->right->ops->type == EXPR_VALUE) {
+                  binop->right->etype == EXPR_VALUE) {
                /*
                 * This *might* be a payload match testing header fields that
                 * have non byte divisible offsets and/or bit lengths.
@@ -2019,9 +2018,9 @@ static void expr_postprocess(struct rule_pp_ctx *ctx, struct expr **exprp)
 
        //pr_debug("%s len %u\n", expr->ops->name, expr->len);
 
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_MAP:
-               switch (expr->map->ops->type) {
+               switch (expr->map->etype) {
                case EXPR_BINOP:
                        map_binop_postprocess(ctx, expr);
                        break;
@@ -2071,7 +2070,7 @@ static void expr_postprocess(struct rule_pp_ctx *ctx, struct expr **exprp)
                              expr->left->byteorder);
                break;
        case EXPR_RELATIONAL:
-               switch (expr->left->ops->type) {
+               switch (expr->left->etype) {
                case EXPR_PAYLOAD:
                        payload_match_postprocess(ctx, expr, expr->left);
                        return;
@@ -2083,7 +2082,7 @@ static void expr_postprocess(struct rule_pp_ctx *ctx, struct expr **exprp)
                expr_set_type(expr->right, expr->left->dtype, expr->left->byteorder);
                expr_postprocess(ctx, &expr->right);
 
-               switch (expr->left->ops->type) {
+               switch (expr->left->etype) {
                case EXPR_CT:
                        ct_match_postprocess(ctx, expr);
                        break;
@@ -2218,22 +2217,22 @@ static bool expr_may_merge_range(struct expr *expr, struct expr *prev,
 {
        struct expr *left, *prev_left;
 
-       if (prev->ops->type == EXPR_RELATIONAL &&
-           expr->ops->type == EXPR_RELATIONAL) {
+       if (prev->etype == EXPR_RELATIONAL &&
+           expr->etype == EXPR_RELATIONAL) {
                /* ct and meta needs an unary to swap byteorder, in this case
                 * we have to explore the inner branch in this tree.
                 */
-               if (expr->left->ops->type == EXPR_UNARY)
+               if (expr->left->etype == EXPR_UNARY)
                        left = expr->left->arg;
                else
                        left = expr->left;
 
-               if (prev->left->ops->type == EXPR_UNARY)
+               if (prev->left->etype == EXPR_UNARY)
                        prev_left = prev->left->arg;
                else
                        prev_left = prev->left;
 
-               if (left->ops->type == prev_left->ops->type) {
+               if (left->etype == prev_left->etype) {
                        if (expr->op == OP_LTE && prev->op == OP_GTE) {
                                *op = OP_EQ;
                                return true;
@@ -2290,7 +2289,7 @@ static void stmt_payload_binop_pp(struct rule_pp_ctx *ctx, struct expr *binop)
        struct expr *mask = binop->right;
        unsigned int shift;
 
-       assert(payload->ops->type == EXPR_PAYLOAD);
+       assert(payload->etype == EXPR_PAYLOAD);
        if (payload_expr_trim(payload, mask, &ctx->pctx, &shift)) {
                __binop_adjust(binop, mask, shift);
                payload_expr_complete(payload, &ctx->pctx);
@@ -2349,10 +2348,10 @@ static void stmt_payload_binop_postprocess(struct rule_pp_ctx *ctx)
 
        expr = stmt->payload.val;
 
-       if (expr->ops->type != EXPR_BINOP)
+       if (expr->etype != EXPR_BINOP)
                return;
 
-       switch (expr->left->ops->type) {
+       switch (expr->left->etype) {
        case EXPR_BINOP: {/* I? */
                mpz_t tmp;
 
@@ -2360,7 +2359,7 @@ static void stmt_payload_binop_postprocess(struct rule_pp_ctx *ctx)
                        return;
 
                value = expr->right;
-               if (value->ops->type != EXPR_VALUE)
+               if (value->etype != EXPR_VALUE)
                        return;
 
                binop = expr->left;
@@ -2368,14 +2367,14 @@ static void stmt_payload_binop_postprocess(struct rule_pp_ctx *ctx)
                        return;
 
                payload = binop->left;
-               if (payload->ops->type != EXPR_PAYLOAD)
+               if (payload->etype != EXPR_PAYLOAD)
                        return;
 
                if (!payload_expr_cmp(stmt->payload.expr, payload))
                        return;
 
                mask = binop->right;
-               if (mask->ops->type != EXPR_VALUE)
+               if (mask->etype != EXPR_VALUE)
                        return;
 
                mpz_init(tmp);
@@ -2403,7 +2402,7 @@ static void stmt_payload_binop_postprocess(struct rule_pp_ctx *ctx)
        }
        case EXPR_PAYLOAD: /* II? */
                value = expr->right;
-               if (value->ops->type != EXPR_VALUE)
+               if (value->etype != EXPR_VALUE)
                        return;
 
                switch (expr->op) {
@@ -2513,7 +2512,7 @@ static void rule_parse_postprocess(struct netlink_parse_ctx *ctx, struct rule *r
                        if (stmt->ct.expr != NULL) {
                                expr_postprocess(&rctx, &stmt->ct.expr);
 
-                               if (stmt->ct.expr->ops->type == EXPR_BINOP)
+                               if (stmt->ct.expr->etype == EXPR_BINOP)
                                        stmt->ct.expr = binop_tree_to_list(NULL,
                                                                           stmt->ct.expr);
                        }

diff --git a/src/netlink_linearize.c b/src/netlink_linearize.c
index 9b5fa195fdc0d5bdcdcea87c9c5d9200448bfa8b..61149bffcc83c71ff9b6a8fb22162c80c7334dcb 100644 (file)
--- a/src/netlink_linearize.c
+++ b/src/netlink_linearize.c
@@ -73,7 +73,7 @@ static void __release_register(struct netlink_linearize_ctx *ctx,
 static enum nft_registers get_register(struct netlink_linearize_ctx *ctx,
                                       const struct expr *expr)
 {
-       if (expr && expr->ops->type == EXPR_CONCAT)
+       if (expr && expr->etype == EXPR_CONCAT)
                return __get_register(ctx, expr->len);
        else
                return __get_register(ctx, NFT_REG_SIZE * BITS_PER_BYTE);
@@ -82,7 +82,7 @@ static enum nft_registers get_register(struct netlink_linearize_ctx *ctx,
 static void release_register(struct netlink_linearize_ctx *ctx,
                             const struct expr *expr)
 {
-       if (expr && expr->ops->type == EXPR_CONCAT)
+       if (expr && expr->etype == EXPR_CONCAT)
                __release_register(ctx, expr->len);
        else
                __release_register(ctx, NFT_REG_SIZE * BITS_PER_BYTE);
@@ -269,7 +269,7 @@ static void netlink_gen_map(struct netlink_linearize_ctx *ctx,
        enum nft_registers sreg;
        int regspace = 0;
 
-       assert(expr->mappings->ops->type == EXPR_SET_REF);
+       assert(expr->mappings->etype == EXPR_SET_REF);
 
        if (dreg == NFT_REG_VERDICT)
                sreg = get_register(ctx, expr->map);
@@ -277,7 +277,7 @@ static void netlink_gen_map(struct netlink_linearize_ctx *ctx,
                sreg = dreg;
 
        /* suppress assert in netlink_gen_expr */
-       if (expr->map->ops->type == EXPR_CONCAT) {
+       if (expr->map->etype == EXPR_CONCAT) {
                regspace = netlink_register_space(expr->map->len);
                ctx->reg_low += regspace;
        }
@@ -306,7 +306,7 @@ static void netlink_gen_lookup(struct netlink_linearize_ctx *ctx,
        struct nftnl_expr *nle;
        enum nft_registers sreg;
 
-       assert(expr->right->ops->type == EXPR_SET_REF);
+       assert(expr->right->etype == EXPR_SET_REF);
        assert(dreg == NFT_REG_VERDICT);
 
        sreg = get_register(ctx, expr->left);
@@ -490,7 +490,7 @@ static void netlink_gen_relational(struct netlink_linearize_ctx *ctx,
                BUG("invalid relational operation %u\n", expr->op);
        }
 
-       switch (expr->right->ops->type) {
+       switch (expr->right->etype) {
        case EXPR_RANGE:
                return netlink_gen_range(ctx, expr, dreg);
        case EXPR_SET:
@@ -562,7 +562,7 @@ static void netlink_gen_binop(struct netlink_linearize_ctx *ctx,
        mpz_init(tmp);
 
        binops[n++] = left = (void *)expr;
-       while (left->ops->type == EXPR_BINOP && left->left != NULL)
+       while (left->etype == EXPR_BINOP && left->left != NULL)
                binops[n++] = left = left->left;
        n--;
 
@@ -662,7 +662,7 @@ static void netlink_gen_immediate(struct netlink_linearize_ctx *ctx,
        nle = alloc_nft_expr("immediate");
        netlink_put_register(nle, NFTNL_EXPR_IMM_DREG, dreg);
        netlink_gen_data(expr, &nld);
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_VALUE:
                nftnl_expr_set(nle, NFTNL_EXPR_IMM_DATA, nld.value, nld.len);
                break;
@@ -700,7 +700,7 @@ static void netlink_gen_expr(struct netlink_linearize_ctx *ctx,
 {
        assert(dreg < ctx->reg_low);
 
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_VERDICT:
        case EXPR_VALUE:
                return netlink_gen_immediate(ctx, expr, dreg);
@@ -752,7 +752,7 @@ static void netlink_gen_objref_stmt(struct netlink_linearize_ctx *ctx,
        uint32_t sreg_key;
 
        nle = alloc_nft_expr("objref");
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_MAP:
                sreg_key = get_register(ctx, expr->map);
                netlink_gen_expr(ctx, expr->map, sreg_key);
@@ -772,7 +772,7 @@ static void netlink_gen_objref_stmt(struct netlink_linearize_ctx *ctx,
                                   stmt->objref.type);
                break;
        default:
-               BUG("unsupported expression %u\n", expr->ops->type);
+               BUG("unsupported expression %u\n", expr->etype);
        }
        nftnl_rule_add_expr(ctx->nlr, nle);
 }
@@ -1057,7 +1057,7 @@ static void netlink_gen_nat_stmt(struct netlink_linearize_ctx *ctx,
                amin_reg = get_register(ctx, NULL);
                registers++;
 
-               if (stmt->nat.addr->ops->type == EXPR_RANGE) {
+               if (stmt->nat.addr->etype == EXPR_RANGE) {
                        amax_reg = get_register(ctx, NULL);
                        registers++;
 
@@ -1079,7 +1079,7 @@ static void netlink_gen_nat_stmt(struct netlink_linearize_ctx *ctx,
                pmin_reg = get_register(ctx, NULL);
                registers++;
 
-               if (stmt->nat.proto->ops->type == EXPR_RANGE) {
+               if (stmt->nat.proto->etype == EXPR_RANGE) {
                        pmax_reg = get_register(ctx, NULL);
                        registers++;
 

diff --git a/src/parser_bison.y b/src/parser_bison.y
index 02a373cb2289a6076f93e1b37a4ed22a89db0ced..0f4d2df8c85f7d538f88e7681087489c88d6a58d 100644 (file)
--- a/src/parser_bison.y
+++ b/src/parser_bison.y
@@ -1807,7 +1807,7 @@ data_type_atom_expr       :       type_identifier
 data_type_expr         :       data_type_atom_expr
                        |       data_type_expr  DOT     data_type_atom_expr
                        {
-                               if ($1->ops->type != EXPR_CONCAT) {
+                               if ($1->etype != EXPR_CONCAT) {
                                        $$ = concat_expr_alloc(&@$);
                                        compound_expr_add($$, $1);
                                } else {
@@ -2741,7 +2741,7 @@ basic_stmt_expr           :       inclusive_or_stmt_expr
 concat_stmt_expr       :       basic_stmt_expr
                        |       concat_stmt_expr        DOT     primary_stmt_expr
                        {
-                               if ($$->ops->type != EXPR_CONCAT) {
+                               if ($$->etype != EXPR_CONCAT) {
                                        $$ = concat_expr_alloc(&@$);
                                        compound_expr_add($$, $1);
                                } else {
@@ -3252,7 +3252,7 @@ basic_expr                :       inclusive_or_expr
 concat_expr            :       basic_expr
                        |       concat_expr             DOT             basic_expr
                        {
-                               if ($$->ops->type != EXPR_CONCAT) {
+                               if ($$->etype != EXPR_CONCAT) {
                                        $$ = concat_expr_alloc(&@$);
                                        compound_expr_add($$, $1);
                                } else {
@@ -3650,7 +3650,7 @@ basic_rhs_expr            :       inclusive_or_rhs_expr
 concat_rhs_expr                :       basic_rhs_expr
                        |       concat_rhs_expr DOT     basic_rhs_expr
                        {
-                               if ($$->ops->type != EXPR_CONCAT) {
+                               if ($$->etype != EXPR_CONCAT) {
                                        $$ = concat_expr_alloc(&@$);
                                        compound_expr_add($$, $1);
                                } else {
@@ -4141,7 +4141,7 @@ ct_stmt                   :       CT      ct_key          SET     stmt_expr
 
 payload_stmt           :       payload_expr            SET     stmt_expr
                        {
-                               if ($1->ops->type == EXPR_EXTHDR)
+                               if ($1->etype == EXPR_EXTHDR)
                                        $$ = exthdr_stmt_alloc(&@$, $1, $3);
                                else
                                        $$ = payload_stmt_alloc(&@$, $1, $3);

diff --git a/src/parser_json.c b/src/parser_json.c
index 6268ad5b7d748dcbe2a7ff80a6844bb5edcd8651..3a9a3798aedc4b7ef29bdac1336ade209d591b31 100644 (file)
--- a/src/parser_json.c
+++ b/src/parser_json.c
@@ -993,7 +993,7 @@ static struct expr *json_parse_concat_expr(struct json_ctx *ctx,
                        expr = tmp;
                        continue;
                }
-               if (expr->ops->type != EXPR_CONCAT) {
+               if (expr->etype != EXPR_CONCAT) {
                        struct expr *concat;
 
                        concat = concat_expr_alloc(int_loc);
@@ -1093,7 +1093,7 @@ static struct expr *json_parse_set_expr(struct json_ctx *ctx,
                if (!expr)
                        return NULL;
 
-               if (expr->ops->type == EXPR_SYMBOL &&
+               if (expr->etype == EXPR_SYMBOL &&
                    expr->symtype == SYMBOL_SET)
                        return expr;
 
@@ -1116,7 +1116,7 @@ static struct expr *json_parse_set_expr(struct json_ctx *ctx,
                                expr_free(set_expr);
                                return NULL;
                        }
-                       if (expr->ops->type != EXPR_SET_ELEM)
+                       if (expr->etype != EXPR_SET_ELEM)
                                expr = set_elem_expr_alloc(int_loc, expr);
 
                        expr2 = json_parse_set_rhs_expr(ctx, jright);
@@ -1137,7 +1137,7 @@ static struct expr *json_parse_set_expr(struct json_ctx *ctx,
                                return NULL;
                        }
 
-                       if (expr->ops->type != EXPR_SET_ELEM)
+                       if (expr->etype != EXPR_SET_ELEM)
                                expr = set_elem_expr_alloc(int_loc, expr);
                }
 
@@ -1406,7 +1406,7 @@ static struct expr *json_parse_set_elem_expr_stmt(struct json_ctx *ctx, json_t *
 {
        struct expr *expr = json_parse_flagged_expr(ctx, CTX_F_SES, root);
 
-       if (expr && expr->ops->type != EXPR_SET_ELEM)
+       if (expr && expr->etype != EXPR_SET_ELEM)
                expr = set_elem_expr_alloc(int_loc, expr);
 
        return expr;
@@ -1559,7 +1559,7 @@ static struct stmt *json_parse_mangle_stmt(struct json_ctx *ctx,
                return NULL;
        }
 
-       switch (key->ops->type) {
+       switch (key->etype) {
        case EXPR_EXTHDR:
                return exthdr_stmt_alloc(int_loc, key, value);
        case EXPR_PAYLOAD:

diff --git a/src/payload.c b/src/payload.c
index 5fd2a07bf8a5bfdd8e0961ed9446777facd532ea..b459b1bfb1ac67e62892a2ceafcca89b48e0f5c5 100644 (file)
--- a/src/payload.c
+++ b/src/payload.c
@@ -406,7 +406,7 @@ bool payload_is_stacked(const struct proto_desc *desc, const struct expr *expr)
 {
        const struct proto_desc *next;
 
-       if (expr->left->ops->type != EXPR_PAYLOAD ||
+       if (expr->left->etype != EXPR_PAYLOAD ||
            !(expr->left->flags & EXPR_F_PROTOCOL) ||
            expr->op != OP_EQ)
                return false;
@@ -475,7 +475,7 @@ static bool payload_may_dependency_kill(struct payload_dep_ctx *ctx,
        case NFPROTO_BRIDGE:
        case NFPROTO_NETDEV:
        case NFPROTO_INET:
-               if (dep->left->ops->type == EXPR_PAYLOAD &&
+               if (dep->left->etype == EXPR_PAYLOAD &&
                    dep->left->payload.base == PROTO_BASE_NETWORK_HDR &&
                    (dep->left->payload.desc == &proto_ip ||
                     dep->left->payload.desc == &proto_ip6) &&
@@ -537,7 +537,7 @@ void payload_expr_complete(struct expr *expr, const struct proto_ctx *ctx)
        const struct proto_hdr_template *tmpl;
        unsigned int i;
 
-       assert(expr->ops->type == EXPR_PAYLOAD);
+       assert(expr->etype == EXPR_PAYLOAD);
 
        desc = ctx->protocol[expr->payload.base].desc;
        if (desc == NULL || desc == &proto_inet)
@@ -596,7 +596,7 @@ bool payload_expr_trim(struct expr *expr, struct expr *mask,
        const struct proto_desc *desc;
        unsigned int off, i, len = 0;
 
-       assert(expr->ops->type == EXPR_PAYLOAD);
+       assert(expr->etype == EXPR_PAYLOAD);
 
        desc = ctx->protocol[expr->payload.base].desc;
        if (desc == NULL)
@@ -659,7 +659,7 @@ void payload_expr_expand(struct list_head *list, struct expr *expr,
        struct expr *new;
        unsigned int i;
 
-       assert(expr->ops->type == EXPR_PAYLOAD);
+       assert(expr->etype == EXPR_PAYLOAD);
 
        desc = ctx->protocol[expr->payload.base].desc;
        if (desc == NULL)

diff --git a/src/rule.c b/src/rule.c
index 73b78c75a267a701190ca1238610c57de74ca464..a3b2dbdb98a3b82c72f13955b45a3baa3542a6a2 100644 (file)
--- a/src/rule.c
+++ b/src/rule.c
@@ -2613,11 +2613,11 @@ static void payload_try_merge(const struct rule *rule)
                if (stmt->ops->type != STMT_EXPRESSION)
                        goto do_merge;
 
-               if (stmt->expr->ops->type != EXPR_RELATIONAL)
+               if (stmt->expr->etype != EXPR_RELATIONAL)
                        continue;
-               if (stmt->expr->left->ops->type != EXPR_PAYLOAD)
+               if (stmt->expr->left->etype != EXPR_PAYLOAD)
                        continue;
-               if (stmt->expr->right->ops->type != EXPR_VALUE)
+               if (stmt->expr->right->etype != EXPR_VALUE)
                        continue;
                switch (stmt->expr->op) {
                case OP_EQ:

diff --git a/src/segtree.c b/src/segtree.c
index 5f25c97d85786fa8b505f81722e289f6852e4dca..e5dfd413ef837675c80cd8b2f19226ee2666a9da 100644 (file)
--- a/src/segtree.c
+++ b/src/segtree.c
@@ -497,7 +497,7 @@ static void segtree_linearize(struct list_head *list, const struct set *set,
                                nei = ei_alloc(p, q, NULL, EI_F_INTERVAL_END);
                                list_add_tail(&nei->list, list);
                        } else if (add && merge &&
-                                  ei->expr->ops->type != EXPR_MAPPING) {
+                                  ei->expr->etype != EXPR_MAPPING) {
                                /* Merge contiguous segments only in case of
                                 * new additions.
                                 */
@@ -542,7 +542,7 @@ static void set_insert_interval(struct expr *set, struct seg_tree *tree,
        expr = set_elem_expr_alloc(&internal_location, expr);
 
        if (ei->expr != NULL) {
-               if (ei->expr->ops->type == EXPR_MAPPING) {
+               if (ei->expr->etype == EXPR_MAPPING) {
                        if (ei->expr->left->comment)
                                expr->comment = xstrdup(ei->expr->left->comment);
                        if (ei->expr->left->timeout)
@@ -623,7 +623,7 @@ struct expr *get_set_intervals(const struct set *set, const struct expr *init)
        new_init = list_expr_alloc(&internal_location);
 
        list_for_each_entry(i, &init->expressions, list) {
-               switch (i->key->ops->type) {
+               switch (i->key->etype) {
                case EXPR_VALUE:
                        set_elem_add(set, new_init, i->key->value, i->flags);
                        break;
@@ -658,7 +658,7 @@ static struct expr *get_set_interval_find(const struct table *table,
        mpz_init2(high, set->key->len);
 
        list_for_each_entry(i, &set->init->expressions, list) {
-               switch (i->key->ops->type) {
+               switch (i->key->etype) {
                case EXPR_RANGE:
                        range_expr_value_low(low, i);
                        range_expr_value_high(high, i);
@@ -694,7 +694,7 @@ static struct expr *get_set_interval_end(const struct table *table,
        mpz_init2(high, set->key->len);
 
        list_for_each_entry(i, &set->init->expressions, list) {
-               switch (i->key->ops->type) {
+               switch (i->key->etype) {
                case EXPR_RANGE:
                        range_expr_value_low(low, i);
                        if (mpz_cmp(low, left->key->value) == 0) {
@@ -781,7 +781,7 @@ static bool range_is_prefix(const mpz_t range)
 
 static struct expr *expr_value(struct expr *expr)
 {
-       switch (expr->ops->type) {
+       switch (expr->etype) {
        case EXPR_MAPPING:
                return expr->left->key;
        case EXPR_SET_ELEM:
@@ -895,7 +895,7 @@ void interval_map_decompose(struct expr *set)
                        tmp = range_expr_alloc(&low->location, expr_value(low), tmp);
                        tmp = set_elem_expr_alloc(&low->location, tmp);
 
-                       if (low->ops->type == EXPR_MAPPING) {
+                       if (low->etype == EXPR_MAPPING) {
                                if (low->left->comment)
                                        tmp->comment = xstrdup(low->left->comment);
                                if (low->left->timeout)
@@ -926,7 +926,7 @@ void interval_map_decompose(struct expr *set)
 
                        prefix = set_elem_expr_alloc(&low->location, prefix);
 
-                       if (low->ops->type == EXPR_MAPPING) {
+                       if (low->etype == EXPR_MAPPING) {
                                if (low->left->comment)
                                        prefix->comment = xstrdup(low->left->comment);
                                if (low->left->timeout)
@@ -968,7 +968,7 @@ void interval_map_decompose(struct expr *set)
        } else {
                i = range_expr_alloc(&low->location, expr_value(low), i);
                i = set_elem_expr_alloc(&low->location, i);
-               if (low->ops->type == EXPR_MAPPING)
+               if (low->etype == EXPR_MAPPING)
                        i = mapping_expr_alloc(&i->location, i, low->right);
        }
 

diff --git a/src/statement.c b/src/statement.c
index 07e17461049349abae1549f48ce3c9375a93bc1e..b9324fd7b2ed42a77a1c073f14f6a75fc3d1702a 100644 (file)
--- a/src/statement.c
+++ b/src/statement.c
@@ -573,12 +573,12 @@ static void nat_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
        if (stmt->nat.addr) {
                nft_print(octx, " ");
                if (stmt->nat.proto) {
-                       if (stmt->nat.addr->ops->type == EXPR_VALUE &&
+                       if (stmt->nat.addr->etype == EXPR_VALUE &&
                            stmt->nat.addr->dtype->type == TYPE_IP6ADDR) {
                                nft_print(octx, "[");
                                expr_print(stmt->nat.addr, octx);
                                nft_print(octx, "]");
-                       } else if (stmt->nat.addr->ops->type == EXPR_RANGE &&
+                       } else if (stmt->nat.addr->etype == EXPR_RANGE &&
                                   stmt->nat.addr->left->dtype->type == TYPE_IP6ADDR) {
                                nft_print(octx, "[");
                                expr_print(stmt->nat.addr->left, octx);
@@ -794,7 +794,7 @@ static void tproxy_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
        nft_print(octx, " to");
        if (stmt->tproxy.addr) {
                nft_print(octx, " ");
-               if (stmt->tproxy.addr->ops->type == EXPR_VALUE &&
+               if (stmt->tproxy.addr->etype == EXPR_VALUE &&
                    stmt->tproxy.addr->dtype->type == TYPE_IP6ADDR) {
                        nft_print(octx, "[");
                        expr_print(stmt->tproxy.addr, octx);
@@ -803,7 +803,7 @@ static void tproxy_stmt_print(const struct stmt *stmt, struct output_ctx *octx)
                        expr_print(stmt->tproxy.addr, octx);
                }
        }
-       if (stmt->tproxy.port && stmt->tproxy.port->ops->type == EXPR_VALUE) {
+       if (stmt->tproxy.port && stmt->tproxy.port->etype == EXPR_VALUE) {
                if (!stmt->tproxy.addr)
                        nft_print(octx, " ");
                nft_print(octx, ":");

diff --git a/src/tcpopt.c b/src/tcpopt.c
index 66f021f94d63f72d9424f3e81324c2c167f3fdf5..52c8c07cdd4726600f0f5a59a44655da8c5b221e 100644 (file)
--- a/src/tcpopt.c
+++ b/src/tcpopt.c
@@ -197,7 +197,7 @@ void tcpopt_init_raw(struct expr *expr, uint8_t type, unsigned int offset,
        const struct proto_hdr_template *tmpl;
        unsigned int i, off;
 
-       assert(expr->ops->type == EXPR_EXTHDR);
+       assert(expr->etype == EXPR_EXTHDR);
 
        expr->len = len;
        expr->exthdr.flags = flags;