From 53eb6a1a58be38f2eabdbf84839d159bfc2e5fef Mon Sep 17 00:00:00 2001 From: Michal Vasko Date: Thu, 13 Jun 2024 11:38:47 +0200 Subject: [PATCH] ly common REFACTOR cast warnings --- src/context.c | 2 +- src/ly_common.h | 3 ++ src/parser_common.c | 20 +++++----- src/plugins_exts.c | 58 +++++++++++++-------------- src/printer_yang.c | 58 +++++++++++++-------------- src/schema_compile_amend.c | 4 +- src/tree_schema_free.c | 66 +++++++++++++++---------------- tests/utests/schema/test_schema.c | 4 +- 8 files changed, 108 insertions(+), 107 deletions(-) diff --git a/src/context.c b/src/context.c index 6a1703e75..912f56d87 100644 --- a/src/context.c +++ b/src/context.c @@ -721,7 +721,7 @@ ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option) ext = &mod->compiled->exts[u]; LY_ARRAY_FOR(ext->substmts, v) { if (ext->substmts[v].stmt & LY_STMT_DATA_NODE_MASK) { - LY_LIST_FOR(*(struct lysc_node **)ext->substmts[v].storage, root) { + LY_LIST_FOR(*VOIDPTR2_C(ext->substmts[v].storage), root) { lysc_tree_dfs_full(root, lysc_node_clear_priv_dfs_cb, NULL); } } diff --git a/src/ly_common.h b/src/ly_common.h index ec0d3eab6..8dc32d784 100644 --- a/src/ly_common.h +++ b/src/ly_common.h @@ -61,6 +61,9 @@ struct lysc_node; #define GETMACRO6(_1, _2, _3, _4, _5, _6, NAME, ...) NAME #define GETMACRO7(_1, _2, _3, _4, _5, _6, _7, NAME, ...) NAME +#define VOIDPTR_C(var) ((void *)(uintptr_t)(var)) +#define VOIDPTR2_C(var) ((void **)(uintptr_t)(var)) + /****************************************************************************** * Logger *****************************************************************************/ diff --git a/src/parser_common.c b/src/parser_common.c index f33b9a734..290e3a5e9 100644 --- a/src/parser_common.c +++ b/src/parser_common.c @@ -3587,7 +3587,7 @@ lys_parse_ext_instance_stmt(struct lysp_ctx *pctx, struct lysp_ext_substmt *subs LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, (void **)&pnode, NULL), cleanup); /* usually is a linked-list of all the parsed schema nodes */ - pnodes_p = (struct lysp_node **)substmt->storage; + pnodes_p = VOIDPTR_C(substmt->storage); while (*pnodes_p) { pnodes_p = &(*pnodes_p)->next; } @@ -3615,7 +3615,7 @@ lys_parse_ext_instance_stmt(struct lysp_ctx *pctx, struct lysp_ext_substmt *subs case LY_STMT_TYPEDEF: case LY_STMT_UNIQUE: /* parse, sized array */ - LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, (void **)substmt->storage, NULL), cleanup); + LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, VOIDPTR_C(substmt->storage), NULL), cleanup); break; case LY_STMT_ARGUMENT: @@ -3650,50 +3650,50 @@ lys_parse_ext_instance_stmt(struct lysp_ctx *pctx, struct lysp_ext_substmt *subs case LY_STMT_YANG_VERSION: case LY_STMT_YIN_ELEMENT: /* single item */ - if (*(void **)substmt->storage) { + if (*VOIDPTR2_C(substmt->storage)) { LOGVAL(PARSER_CTX(pctx), LY_VCODE_DUPSTMT, stmt->stmt); rc = LY_EVALID; goto cleanup; } /* parse */ - LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, (void **)substmt->storage, NULL), cleanup); + LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, VOIDPTR_C(substmt->storage), NULL), cleanup); break; case LY_STMT_CONFIG: /* single item */ - if ((*(uint16_t *)substmt->storage) & LYS_CONFIG_MASK) { + if ((*(uint16_t *)VOIDPTR2_C(substmt->storage)) & LYS_CONFIG_MASK) { LOGVAL(PARSER_CTX(pctx), LY_VCODE_DUPSTMT, stmt->stmt); rc = LY_EVALID; goto cleanup; } /* parse */ - LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, (void **)substmt->storage, NULL), cleanup); + LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, VOIDPTR_C(substmt->storage), NULL), cleanup); break; case LY_STMT_ORDERED_BY: /* single item */ - if ((*(uint16_t *)substmt->storage) & LYS_ORDBY_MASK) { + if ((*(uint16_t *)VOIDPTR2_C(substmt->storage)) & LYS_ORDBY_MASK) { LOGVAL(PARSER_CTX(pctx), LY_VCODE_DUPSTMT, stmt->stmt); rc = LY_EVALID; goto cleanup; } /* parse */ - LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, (void **)substmt->storage, NULL), cleanup); + LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, VOIDPTR_C(substmt->storage), NULL), cleanup); break; case LY_STMT_STATUS: /* single item */ - if ((*(uint16_t *)substmt->storage) & LYS_STATUS_MASK) { + if ((*(uint16_t *)VOIDPTR2_C(substmt->storage)) & LYS_STATUS_MASK) { LOGVAL(PARSER_CTX(pctx), LY_VCODE_DUPSTMT, stmt->stmt); rc = LY_EVALID; goto cleanup; } /* parse */ - LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, (void **)substmt->storage, NULL), cleanup); + LY_CHECK_GOTO(rc = lysp_stmt_parse(pctx, stmt, VOIDPTR_C(substmt->storage), NULL), cleanup); break; default: diff --git a/src/plugins_exts.c b/src/plugins_exts.c index e7626a28c..cffbe5355 100644 --- a/src/plugins_exts.c +++ b/src/plugins_exts.c @@ -101,7 +101,7 @@ lys_compile_ext_instance_stmt(struct lysc_ctx *ctx, uint64_t parsed, struct lysc ly_bool enabled; /* evaluate */ - LY_CHECK_GOTO(rc = lys_eval_iffeatures(ctx->ctx, (struct lysp_qname *)parsed, &enabled), cleanup); + LY_CHECK_GOTO(rc = lys_eval_iffeatures(ctx->ctx, VOIDPTR_C(parsed), &enabled), cleanup); if (!enabled) { /* it is disabled, remove the whole extension instance */ rc = LY_ENOT; @@ -133,7 +133,7 @@ lys_compile_ext_instance_stmt(struct lysc_ctx *ctx, uint64_t parsed, struct lysc struct lysc_node *node; lyplg_ext_get_storage(ext, LY_STMT_STATUS, sizeof flags, (const void **)&flags); - pnodes = (struct lysp_node *)parsed; + pnodes = VOIDPTR_C(parsed); /* compile nodes */ LY_LIST_FOR(pnodes, pnode) { @@ -163,7 +163,7 @@ lys_compile_ext_instance_stmt(struct lysc_ctx *ctx, uint64_t parsed, struct lysc case LY_STMT_REFERENCE: case LY_STMT_UNITS: /* just make a copy */ - LY_CHECK_GOTO(rc = lydict_insert(ctx->ctx, (const char *)parsed, 0, (const char **)substmt->storage), cleanup); + LY_CHECK_GOTO(rc = lydict_insert(ctx->ctx, VOIDPTR_C(parsed), 0, VOIDPTR_C(substmt->storage)), cleanup); break; case LY_STMT_BIT: @@ -175,8 +175,7 @@ lys_compile_ext_instance_stmt(struct lysc_ctx *ctx, uint64_t parsed, struct lysc } /* compile */ - rc = lys_compile_type_enums(ctx, (struct lysp_type_enum *)parsed, basetype, NULL, - (struct lysc_type_bitenum_item **)substmt->storage); + rc = lys_compile_type_enums(ctx, VOIDPTR_C(parsed), basetype, NULL, VOIDPTR_C(substmt->storage)); LY_CHECK_GOTO(rc, cleanup); break; @@ -195,56 +194,56 @@ lys_compile_ext_instance_stmt(struct lysc_ctx *ctx, uint64_t parsed, struct lysc /* default config */ flags = LYS_CONFIG_W; } - memcpy((void *)substmt->storage, &flags, 2); + memcpy(VOIDPTR_C(substmt->storage), &flags, 2); } /* else leave zero */ break; } case LY_STMT_MUST: { - const struct lysp_restr *restrs = (struct lysp_restr *)parsed; + const struct lysp_restr *restrs = VOIDPTR_C(parsed); /* sized array */ - COMPILE_ARRAY_GOTO(ctx, restrs, *(struct lysc_must **)substmt->storage, lys_compile_must, rc, cleanup); + COMPILE_ARRAY_GOTO(ctx, restrs, *(struct lysc_must **)VOIDPTR_C(substmt->storage), lys_compile_must, rc, cleanup); break; } case LY_STMT_WHEN: { const uint16_t flags; - const struct lysp_when *when = (struct lysp_when *)parsed; + const struct lysp_when *when = VOIDPTR_C(parsed); /* read compiled status */ lyplg_ext_get_storage(ext, LY_STMT_STATUS, sizeof flags, (const void **)&flags); /* compile */ - LY_CHECK_GOTO(rc = lys_compile_when(ctx, when, flags, NULL, NULL, NULL, (struct lysc_when **)substmt->storage), cleanup); + LY_CHECK_GOTO(rc = lys_compile_when(ctx, when, flags, NULL, NULL, NULL, VOIDPTR_C(substmt->storage)), cleanup); break; } case LY_STMT_FRACTION_DIGITS: case LY_STMT_REQUIRE_INSTANCE: /* just make a copy */ - memcpy((void *)substmt->storage, &parsed, 1); + memcpy(VOIDPTR_C(substmt->storage), &parsed, 1); break; case LY_STMT_MANDATORY: case LY_STMT_ORDERED_BY: case LY_STMT_STATUS: /* just make a copy */ - memcpy((void *)substmt->storage, &parsed, 2); + memcpy(VOIDPTR_C(substmt->storage), &parsed, 2); break; case LY_STMT_MAX_ELEMENTS: case LY_STMT_MIN_ELEMENTS: /* just make a copy */ - memcpy((void *)substmt->storage, &parsed, 4); + memcpy(VOIDPTR_C(substmt->storage), &parsed, 4); break; case LY_STMT_POSITION: case LY_STMT_VALUE: /* just make a copy */ - memcpy((void *)substmt->storage, &parsed, 8); + memcpy(VOIDPTR_C(substmt->storage), &parsed, 8); break; case LY_STMT_IDENTITY: /* compile */ - rc = lys_identity_precompile(ctx, NULL, NULL, (struct lysp_ident *)parsed, (struct lysc_ident **)substmt->storage); + rc = lys_identity_precompile(ctx, NULL, NULL, VOIDPTR_C(parsed), VOIDPTR_C(substmt->storage)); LY_CHECK_GOTO(rc, cleanup); break; @@ -253,37 +252,36 @@ lys_compile_ext_instance_stmt(struct lysc_ctx *ctx, uint64_t parsed, struct lysc /* fallthrough */ case LY_STMT_RANGE: /* compile, use uint64 default range */ - rc = lys_compile_type_range(ctx, (struct lysp_restr *)parsed, LY_TYPE_UINT64, length_restr, 0, NULL, - (struct lysc_range **)substmt->storage); + rc = lys_compile_type_range(ctx, VOIDPTR_C(parsed), LY_TYPE_UINT64, length_restr, 0, NULL, VOIDPTR_C(substmt->storage)); LY_CHECK_GOTO(rc, cleanup); break; case LY_STMT_PATTERN: /* compile */ - rc = lys_compile_type_patterns(ctx, (struct lysp_restr *)parsed, NULL, (struct lysc_pattern ***)substmt->storage); + rc = lys_compile_type_patterns(ctx, VOIDPTR_C(parsed), NULL, VOIDPTR_C(substmt->storage)); LY_CHECK_GOTO(rc, cleanup); break; case LY_STMT_TYPE: { const uint16_t flags; const char *units; - const struct lysp_type *ptype = (struct lysp_type *)parsed; + const struct lysp_type *ptype = VOIDPTR_C(parsed); /* read compiled info */ lyplg_ext_get_storage(ext, LY_STMT_STATUS, sizeof flags, (const void **)&flags); lyplg_ext_get_storage(ext, LY_STMT_UNITS, sizeof units, (const void **)&units); /* compile */ - rc = lys_compile_type(ctx, NULL, flags, ext->def->name, ptype, (struct lysc_type **)substmt->storage, &units, NULL); + rc = lys_compile_type(ctx, NULL, flags, ext->def->name, ptype, VOIDPTR_C(substmt->storage), &units, NULL); LY_CHECK_GOTO(rc, cleanup); - LY_ATOMIC_INC_BARRIER((*(struct lysc_type **)substmt->storage)->refcount); + LY_ATOMIC_INC_BARRIER((*(struct lysc_type **)VOIDPTR_C(substmt->storage))->refcount); break; } case LY_STMT_EXTENSION_INSTANCE: { - struct lysp_ext_instance *extps = (struct lysp_ext_instance *)parsed; + struct lysp_ext_instance *extps = VOIDPTR_C(parsed); /* compile sized array */ - COMPILE_EXTS_GOTO(ctx, extps, *(struct lysc_ext_instance **)substmt->storage, ext, rc, cleanup); + COMPILE_EXTS_GOTO(ctx, extps, *(struct lysc_ext_instance **)VOIDPTR_C(substmt->storage), ext, rc, cleanup); break; } case LY_STMT_AUGMENT: @@ -342,9 +340,9 @@ lyplg_ext_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext LY_ARRAY_FOR(extp->substmts, u) { stmtp = extp->substmts[u].stmt; - storagep = *(uint64_t *)extp->substmts[u].storage; + storagep = *(uint64_t *)VOIDPTR_C(extp->substmts[u].storage); - if (!storagep || ly_set_contains(&storagep_compiled, (void *)storagep, NULL)) { + if (!storagep || ly_set_contains(&storagep_compiled, VOIDPTR_C(storagep), NULL)) { /* nothing parsed or already compiled (for example, if it is a linked list of parsed nodes) */ continue; } @@ -363,7 +361,7 @@ lyplg_ext_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext } /* compiled */ - ly_set_add(&storagep_compiled, (void *)storagep, 1, NULL); + ly_set_add(&storagep_compiled, VOIDPTR_C(storagep), 1, NULL); } cleanup: @@ -439,7 +437,7 @@ lyplg_ext_sprinter_ctree_add_ext_nodes(const struct lyspr_tree_ctx *ctx, struct case LY_STMT_LEAF: case LY_STMT_LEAF_LIST: case LY_STMT_LIST: - schema = *((struct lysc_node **)ext->substmts[i].storage); + schema = *VOIDPTR2_C(ext->substmts[i].storage); if (schema) { rc = lyplg_ext_sprinter_ctree_add_nodes(ctx, schema, clb); return rc; @@ -477,7 +475,7 @@ lyplg_ext_sprinter_ptree_add_ext_nodes(const struct lyspr_tree_ctx *ctx, struct case LY_STMT_LEAF: case LY_STMT_LEAF_LIST: case LY_STMT_LIST: - schema = *((struct lysp_node **)ext->substmts[i].storage); + schema = *VOIDPTR2_C(ext->substmts[i].storage); if (schema) { rc = lyplg_ext_sprinter_ptree_add_nodes(ctx, schema, clb); return rc; @@ -622,7 +620,7 @@ lyplg_ext_get_storage(const struct lysc_ext_instance *ext, int stmt, uint32_t st /* assign */ if (s) { - memcpy(storage, (void *)s, storage_size); + memcpy(storage, VOIDPTR_C(s), storage_size); } else { memset(storage, 0, storage_size); } @@ -664,7 +662,7 @@ lyplg_ext_parsed_get_storage(const struct lysc_ext_instance *ext, int stmt, uint /* assign */ if (s) { - memcpy(storage, (void *)s, storage_size); + memcpy(storage, VOIDPTR_C(s), storage_size); } else { memset(storage, 0, storage_size); } diff --git a/src/printer_yang.c b/src/printer_yang.c index c5e4b11be..6dc06a884 100644 --- a/src/printer_yang.c +++ b/src/printer_yang.c @@ -2563,7 +2563,7 @@ lyplg_ext_print_info_extension_instance(struct lyspr_ctx *ctx, const struct lysc break; } - LY_LIST_FOR(*(const struct lysc_node **)ext->substmts[u].storage, node) { + LY_LIST_FOR(*VOIDPTR2_C(ext->substmts[u].storage), node) { ypr_open(pctx->out, flag); if (ext->substmts[u].stmt == LY_STMT_NOTIFICATION) { yprc_notification(pctx, (struct lysc_node_notif *)node); @@ -2592,32 +2592,32 @@ lyplg_ext_print_info_extension_instance(struct lyspr_ctx *ctx, const struct lysc case LY_STMT_PRESENCE: case LY_STMT_REFERENCE: case LY_STMT_UNITS: - if (*(const char **)ext->substmts[u].storage) { + if (*VOIDPTR2_C(ext->substmts[u].storage)) { ypr_open(pctx->out, flag); - ypr_substmt(pctx, ext->substmts[u].stmt, 0, *(const char **)ext->substmts[u].storage, 0, ext->exts); + ypr_substmt(pctx, ext->substmts[u].stmt, 0, *VOIDPTR2_C(ext->substmts[u].storage), 0, ext->exts); } break; case LY_STMT_BIT: case LY_STMT_ENUM: { - const struct lysc_type_bitenum_item *items = *(struct lysc_type_bitenum_item **)ext->substmts[u].storage; + const struct lysc_type_bitenum_item *items = *VOIDPTR2_C(ext->substmts[u].storage); yprc_bits_enum(pctx, items, ext->substmts[u].stmt == LY_STMT_BIT ? LY_TYPE_BITS : LY_TYPE_ENUM, flag); break; } case LY_STMT_CONFIG: - ypr_config(pctx, *(uint16_t *)ext->substmts[u].storage, ext->exts, flag); + ypr_config(pctx, *(uint16_t *)VOIDPTR2_C(ext->substmts[u].storage), ext->exts, flag); break; case LY_STMT_EXTENSION_INSTANCE: - yprc_extension_instances(pctx, LY_STMT_EXTENSION_INSTANCE, 0, - *(struct lysc_ext_instance **)ext->substmts[u].storage, flag); + yprc_extension_instances(pctx, LY_STMT_EXTENSION_INSTANCE, 0, *VOIDPTR2_C(ext->substmts[u].storage), flag); break; case LY_STMT_FRACTION_DIGITS: - if (*(uint8_t *)ext->substmts[u].storage) { - ypr_unsigned(pctx, LY_STMT_FRACTION_DIGITS, 0, ext->exts, *(uint8_t *)ext->substmts[u].storage, flag); + if (*VOIDPTR2_C(ext->substmts[u].storage)) { + ypr_unsigned(pctx, LY_STMT_FRACTION_DIGITS, 0, ext->exts, + (long unsigned int)*VOIDPTR2_C(ext->substmts[u].storage), flag); } break; case LY_STMT_IDENTITY: { - const struct lysc_ident *idents = *(struct lysc_ident **)ext->substmts[u].storage; + const struct lysc_ident *idents = *VOIDPTR2_C(ext->substmts[u].storage); LY_ARRAY_FOR(idents, v) { yprc_identity(pctx, &idents[v]); @@ -2625,15 +2625,15 @@ lyplg_ext_print_info_extension_instance(struct lyspr_ctx *ctx, const struct lysc break; } case LY_STMT_LENGTH: - if (*(struct lysc_range **)ext->substmts[u].storage) { - yprc_range(pctx, *(struct lysc_range **)ext->substmts[u].storage, LY_TYPE_STRING, flag); + if (*VOIDPTR2_C(ext->substmts[u].storage)) { + yprc_range(pctx, *VOIDPTR2_C(ext->substmts[u].storage), LY_TYPE_STRING, flag); } break; case LY_STMT_MANDATORY: - ypr_mandatory(pctx, *(uint16_t *)ext->substmts[u].storage, ext->exts, flag); + ypr_mandatory(pctx, *(uint16_t *)VOIDPTR_C(ext->substmts[u].storage), ext->exts, flag); break; case LY_STMT_MAX_ELEMENTS: { - uint32_t max = *(uint32_t *)ext->substmts[u].storage; + uint32_t max = *(uint32_t *)VOIDPTR_C(ext->substmts[u].storage); if (max) { ypr_unsigned(pctx, LY_STMT_MAX_ELEMENTS, 0, ext->exts, max, flag); @@ -2644,15 +2644,15 @@ lyplg_ext_print_info_extension_instance(struct lyspr_ctx *ctx, const struct lysc break; } case LY_STMT_MIN_ELEMENTS: - ypr_unsigned(pctx, LY_STMT_MIN_ELEMENTS, 0, ext->exts, *(uint32_t *)ext->substmts[u].storage, flag); + ypr_unsigned(pctx, LY_STMT_MIN_ELEMENTS, 0, ext->exts, *(uint32_t *)VOIDPTR_C(ext->substmts[u].storage), flag); break; case LY_STMT_ORDERED_BY: ypr_open(pctx->out, flag); ypr_substmt(pctx, LY_STMT_ORDERED_BY, 0, - (*(uint16_t *)ext->substmts[u].storage & LYS_ORDBY_USER) ? "user" : "system", 0, ext->exts); + ((*(uint16_t *)VOIDPTR_C(ext->substmts[u].storage)) & LYS_ORDBY_USER) ? "user" : "system", 0, ext->exts); break; case LY_STMT_MUST: { - const struct lysc_must *musts = *(struct lysc_must **)ext->substmts[u].storage; + const struct lysc_must *musts = *VOIDPTR2_C(ext->substmts[u].storage); LY_ARRAY_FOR(musts, v) { yprc_must(pctx, &musts[v], flag); @@ -2660,7 +2660,7 @@ lyplg_ext_print_info_extension_instance(struct lyspr_ctx *ctx, const struct lysc break; } case LY_STMT_PATTERN: { - const struct lysc_pattern *patterns = *(struct lysc_pattern **)ext->substmts[u].storage; + const struct lysc_pattern *patterns = *VOIDPTR2_C(ext->substmts[u].storage); LY_ARRAY_FOR(patterns, v) { yprc_pattern(pctx, &patterns[v], flag); @@ -2668,36 +2668,36 @@ lyplg_ext_print_info_extension_instance(struct lyspr_ctx *ctx, const struct lysc break; } case LY_STMT_POSITION: - if (*(int64_t *)ext->substmts[u].storage) { - ypr_unsigned(pctx, ext->substmts[u].stmt, 0, ext->exts, *(int64_t *)ext->substmts[u].storage, flag); + if (*VOIDPTR2_C(ext->substmts[u].storage)) { + ypr_unsigned(pctx, ext->substmts[u].stmt, 0, ext->exts, *(int64_t *)VOIDPTR_C(ext->substmts[u].storage), flag); } break; case LY_STMT_VALUE: - if (*(int64_t *)ext->substmts[u].storage) { - ypr_signed(pctx, ext->substmts[u].stmt, 0, ext->exts, *(int64_t *)ext->substmts[u].storage, flag); + if (*VOIDPTR2_C(ext->substmts[u].storage)) { + ypr_signed(pctx, ext->substmts[u].stmt, 0, ext->exts, *(int64_t *)VOIDPTR_C(ext->substmts[u].storage), flag); } break; case LY_STMT_RANGE: - if (*(struct lysc_range **)ext->substmts[u].storage) { - yprc_range(pctx, *(struct lysc_range **)ext->substmts[u].storage, LY_TYPE_UINT64, flag); + if (*VOIDPTR2_C(ext->substmts[u].storage)) { + yprc_range(pctx, *VOIDPTR2_C(ext->substmts[u].storage), LY_TYPE_UINT64, flag); } break; case LY_STMT_REQUIRE_INSTANCE: ypr_open(pctx->out, flag); - ypr_substmt(pctx, LY_STMT_REQUIRE_INSTANCE, 0, *(uint8_t *)ext->substmts[u].storage ? "true" : "false", + ypr_substmt(pctx, LY_STMT_REQUIRE_INSTANCE, 0, *(uint8_t *)VOIDPTR_C(ext->substmts[u].storage) ? "true" : "false", 0, ext->exts); break; case LY_STMT_STATUS: - ypr_status(pctx, *(uint16_t *)ext->substmts[u].storage, ext->exts, flag); + ypr_status(pctx, *(uint16_t *)VOIDPTR_C(ext->substmts[u].storage), ext->exts, flag); break; case LY_STMT_TYPE: - if (*(const struct lysc_type **)ext->substmts[u].storage) { + if (*VOIDPTR2_C(ext->substmts[u].storage)) { ypr_open(pctx->out, flag); - yprc_type(pctx, *(const struct lysc_type **)ext->substmts[u].storage); + yprc_type(pctx, *VOIDPTR2_C(ext->substmts[u].storage)); } break; case LY_STMT_WHEN: - yprc_when(pctx, *(struct lysc_when **)ext->substmts[u].storage, flag); + yprc_when(pctx, *VOIDPTR2_C(ext->substmts[u].storage), flag); break; case LY_STMT_AUGMENT: case LY_STMT_BASE: diff --git a/src/schema_compile_amend.c b/src/schema_compile_amend.c index 321ff94aa..4eac4eccc 100644 --- a/src/schema_compile_amend.c +++ b/src/schema_compile_amend.c @@ -2218,7 +2218,7 @@ lys_precompile_own_augments_mod(struct lysc_ctx *ctx, const struct lysp_module * aug_p = NULL; LY_ARRAY_FOR(pmod->exts[u].substmts, v) { if (pmod->exts[u].substmts[v].stmt == LY_STMT_AUGMENT) { - aug_p = *(struct lysp_node_augment **)pmod->exts[u].substmts[v].storage; + aug_p = *VOIDPTR2_C(pmod->exts[u].substmts[v].storage); break; } } @@ -2488,7 +2488,7 @@ lys_precompile_mod_augments_deviations(struct lysp_module *pmod, struct ly_set * aug = NULL; LY_ARRAY_FOR(pmod->exts[u].substmts, v) { if (pmod->exts[u].substmts[v].stmt == LY_STMT_AUGMENT) { - aug = *(struct lysp_node_augment **)pmod->exts[u].substmts[v].storage; + aug = *VOIDPTR2_C(pmod->exts[u].substmts[v].storage); break; } } diff --git a/src/tree_schema_free.c b/src/tree_schema_free.c index 145ae8f9e..91ba72b07 100644 --- a/src/tree_schema_free.c +++ b/src/tree_schema_free.c @@ -1383,75 +1383,75 @@ lyplg_ext_pfree_instance_substatements(const struct ly_ctx *ctx, struct lysp_ext case LY_STMT_USES: { struct lysp_node *child, *child_next; - LY_LIST_FOR_SAFE(*((struct lysp_node **)substmts[u].storage), child_next, child) { + LY_LIST_FOR_SAFE(*VOIDPTR2_C(substmts[u].storage), child_next, child) { node_free = (child->nodetype & (LYS_INPUT | LYS_OUTPUT)) ? 1 : 0; lysp_node_free(&fctx, child); if (node_free) { free(child); } } - *((struct lysc_node **)substmts[u].storage) = NULL; + *VOIDPTR2_C(substmts[u].storage) = NULL; break; } case LY_STMT_BASE: /* multiple strings */ - FREE_ARRAY(ctx, **(const char ***)substmts[u].storage, lydict_remove); + FREE_ARRAY(ctx, **(const char ***)VOIDPTR2_C(substmts[u].storage), lydict_remove); break; case LY_STMT_BIT: case LY_STMT_ENUM: /* single enum */ - lysp_type_enum_free(&fctx, *(struct lysp_type_enum **)substmts[u].storage); + lysp_type_enum_free(&fctx, *VOIDPTR2_C(substmts[u].storage)); break; case LY_STMT_DEVIATE: /* single deviate */ - lysp_deviate_free(&fctx, *(struct lysp_deviate **)substmts[u].storage); + lysp_deviate_free(&fctx, *VOIDPTR2_C(substmts[u].storage)); break; case LY_STMT_DEVIATION: /* single deviation */ - lysp_deviation_free(&fctx, *(struct lysp_deviation **)substmts[u].storage); + lysp_deviation_free(&fctx, *VOIDPTR2_C(substmts[u].storage)); break; case LY_STMT_EXTENSION: /* single extension */ - lysp_ext_free(&fctx, *(struct lysp_ext **)substmts[u].storage); + lysp_ext_free(&fctx, *VOIDPTR2_C(substmts[u].storage)); break; case LY_STMT_EXTENSION_INSTANCE: /* multiple extension instances */ - FREE_ARRAY(&fctx, *(struct lysp_ext_instance **)substmts[u].storage, lysp_ext_instance_free); + FREE_ARRAY(&fctx, *(struct lysp_ext_instance **)VOIDPTR2_C(substmts[u].storage), lysp_ext_instance_free); break; case LY_STMT_FEATURE: /* multiple features */ - FREE_ARRAY(&fctx, *(struct lysp_feature **)substmts[u].storage, lysp_feature_free); + FREE_ARRAY(&fctx, *(struct lysp_feature **)VOIDPTR2_C(substmts[u].storage), lysp_feature_free); break; case LY_STMT_IDENTITY: /* multiple identities */ - FREE_ARRAY(&fctx, *(struct lysp_ident **)substmts[u].storage, lysp_ident_free); + FREE_ARRAY(&fctx, *(struct lysp_ident **)VOIDPTR2_C(substmts[u].storage), lysp_ident_free); break; case LY_STMT_IMPORT: /* multiple imports */ - FREE_ARRAY(&fctx, *(struct lysp_import **)substmts[u].storage, lysp_import_free); + FREE_ARRAY(&fctx, *(struct lysp_import **)VOIDPTR2_C(substmts[u].storage), lysp_import_free); break; case LY_STMT_INCLUDE: /* multiple includes */ - FREE_ARRAY(&fctx, *(struct lysp_include **)substmts[u].storage, lysp_include_free); + FREE_ARRAY(&fctx, *(struct lysp_include **)VOIDPTR2_C(substmts[u].storage), lysp_include_free); break; case LY_STMT_REFINE: /* multiple refines */ - FREE_ARRAY(&fctx, *(struct lysp_refine **)substmts[u].storage, lysp_refine_free); + FREE_ARRAY(&fctx, *(struct lysp_refine **)VOIDPTR2_C(substmts[u].storage), lysp_refine_free); break; case LY_STMT_REVISION: /* multiple revisions */ - FREE_ARRAY(&fctx, *(struct lysp_revision **)substmts[u].storage, lysp_revision_free); + FREE_ARRAY(&fctx, *(struct lysp_revision **)VOIDPTR2_C(substmts[u].storage), lysp_revision_free); break; case LY_STMT_CONFIG: @@ -1485,7 +1485,7 @@ lyplg_ext_pfree_instance_substatements(const struct ly_ctx *ctx, struct lysp_ext case LY_STMT_REVISION_DATE: case LY_STMT_UNITS: /* single string */ - lydict_remove(ctx, *(const char **)substmts[u].storage); + lydict_remove(ctx, *VOIDPTR2_C(substmts[u].storage)); break; case LY_STMT_LENGTH: @@ -1493,34 +1493,34 @@ lyplg_ext_pfree_instance_substatements(const struct ly_ctx *ctx, struct lysp_ext case LY_STMT_PATTERN: case LY_STMT_RANGE: /* multiple restrictions */ - FREE_ARRAY(&fctx, *(struct lysp_restr **)substmts[u].storage, lysp_restr_free); + FREE_ARRAY(&fctx, *(struct lysp_restr **)VOIDPTR2_C(substmts[u].storage), lysp_restr_free); break; case LY_STMT_WHEN: /* multiple whens */ - FREE_ARRAY(&fctx, *(struct lysp_when **)substmts[u].storage, lysp_when_free); + FREE_ARRAY(&fctx, *(struct lysp_when **)VOIDPTR2_C(substmts[u].storage), lysp_when_free); break; case LY_STMT_PATH: /* single expression */ - lyxp_expr_free(ctx, *(struct lyxp_expr **)substmts[u].storage); + lyxp_expr_free(ctx, *VOIDPTR2_C(substmts[u].storage)); break; case LY_STMT_DEFAULT: case LY_STMT_IF_FEATURE: case LY_STMT_UNIQUE: /* multiple qnames */ - FREE_ARRAY(ctx, *(struct lysp_qname **)substmts[u].storage, lysp_qname_free); + FREE_ARRAY(ctx, *(struct lysp_qname **)VOIDPTR2_C(substmts[u].storage), lysp_qname_free); break; case LY_STMT_TYPEDEF: /* multiple typedefs */ - FREE_ARRAY(&fctx, *(struct lysp_tpdf **)substmts[u].storage, lysp_tpdf_free); + FREE_ARRAY(&fctx, *(struct lysp_tpdf **)VOIDPTR2_C(substmts[u].storage), lysp_tpdf_free); break; case LY_STMT_TYPE: { /* single type */ - struct lysp_type **type_p = (void *)substmts[u].storage; + struct lysp_type **type_p = VOIDPTR_C(substmts[u].storage); lysp_type_free(&fctx, *type_p); free(*type_p); @@ -1529,7 +1529,7 @@ lyplg_ext_pfree_instance_substatements(const struct ly_ctx *ctx, struct lysp_ext case LY_STMT_MODULE: case LY_STMT_SUBMODULE: /* single (sub)module */ - lysp_module_free(&fctx, *(struct lysp_module **)substmts[u].storage); + lysp_module_free(&fctx, *VOIDPTR2_C(substmts[u].storage)); break; default: @@ -1568,14 +1568,14 @@ lyplg_ext_cfree_instance_substatements(const struct ly_ctx *ctx, struct lysc_ext case LY_STMT_LIST: { struct lysc_node *child, *child_next; - LY_LIST_FOR_SAFE(*((struct lysc_node **)substmts[u].storage), child_next, child) { + LY_LIST_FOR_SAFE(*VOIDPTR2_C(substmts[u].storage), child_next, child) { node_free = (child->nodetype & (LYS_INPUT | LYS_OUTPUT)) ? 1 : 0; lysc_node_free_(&fctx, child); if (node_free) { free(child); } } - *((struct lysc_node **)substmts[u].storage) = NULL; + *VOIDPTR2_C(substmts[u].storage) = NULL; break; } case LY_STMT_USES: @@ -1605,7 +1605,7 @@ lyplg_ext_cfree_instance_substatements(const struct ly_ctx *ctx, struct lysc_ext case LY_STMT_REFERENCE: case LY_STMT_UNITS: { /* single item */ - const char *str = *((const char **)substmts[u].storage); + const char *str = *VOIDPTR2_C(substmts[u].storage); lydict_remove(ctx, str); break; @@ -1613,7 +1613,7 @@ lyplg_ext_cfree_instance_substatements(const struct ly_ctx *ctx, struct lysc_ext case LY_STMT_BIT: case LY_STMT_ENUM: { /* sized array */ - struct lysc_type_bitenum_item *items = *((struct lysc_type_bitenum_item **)substmts[u].storage); + struct lysc_type_bitenum_item *items = *VOIDPTR2_C(substmts[u].storage); FREE_ARRAY(&fctx, items, lysc_enum_item_free); break; @@ -1621,47 +1621,47 @@ lyplg_ext_cfree_instance_substatements(const struct ly_ctx *ctx, struct lysc_ext case LY_STMT_LENGTH: case LY_STMT_RANGE: { /* single item */ - struct lysc_range *range = *((struct lysc_range **)substmts[u].storage); + struct lysc_range *range = *VOIDPTR2_C(substmts[u].storage); lysc_range_free(&fctx, range); break; } case LY_STMT_MUST: { /* sized array */ - struct lysc_must *musts = *((struct lysc_must **)substmts[u].storage); + struct lysc_must *musts = *VOIDPTR2_C(substmts[u].storage); FREE_ARRAY(&fctx, musts, lysc_must_free); break; } case LY_STMT_WHEN: /* single item, expects a pointer */ - lysc_when_free(&fctx, (struct lysc_when **)substmts[u].storage); + lysc_when_free(&fctx, VOIDPTR_C(substmts[u].storage)); break; case LY_STMT_PATTERN: { /* sized array of pointers */ - struct lysc_pattern **patterns = *((struct lysc_pattern ***)substmts[u].storage); + struct lysc_pattern **patterns = *VOIDPTR2_C(substmts[u].storage); FREE_ARRAY(&fctx, patterns, lysc_pattern_free); break; } case LY_STMT_TYPE: { /* single item */ - struct lysc_type *type = *((struct lysc_type **)substmts[u].storage); + struct lysc_type *type = *VOIDPTR2_C(substmts[u].storage); lysc_type_free(&fctx, type); break; } case LY_STMT_IDENTITY: { /* sized array */ - struct lysc_ident *idents = *((struct lysc_ident **)substmts[u].storage); + struct lysc_ident *idents = *VOIDPTR2_C(substmts[u].storage); FREE_ARRAY(&fctx, idents, lysc_ident_free); break; } case LY_STMT_EXTENSION_INSTANCE: { /* sized array */ - struct lysc_ext_instance *exts = *((struct lysc_ext_instance **)substmts[u].storage); + struct lysc_ext_instance *exts = *VOIDPTR2_C(substmts[u].storage); FREE_ARRAY(&fctx, exts, lysc_ext_instance_free); break; diff --git a/tests/utests/schema/test_schema.c b/tests/utests/schema/test_schema.c index 2dd7f6dc5..953aad882 100644 --- a/tests/utests/schema/test_schema.c +++ b/tests/utests/schema/test_schema.c @@ -1712,7 +1712,7 @@ test_extension_compile(void **state) LY_ARRAY_NEW_GOTO(UTEST_LYCTX, ext_p.substmts, substmtp, rc, cleanup); substmtp->stmt = LY_STMT_ERROR_MESSAGE; - substmtp->storage = &ext_p.parsed; + substmtp->storage = (uintptr_t)(void *)&ext_p.parsed; /* fake parse */ lydict_insert(UTEST_LYCTX, "my error", 0, (const char **)&ext_p.parsed); @@ -1721,7 +1721,7 @@ test_extension_compile(void **state) LY_ARRAY_NEW_GOTO(UTEST_LYCTX, ext_c.substmts, substmt, rc, cleanup); substmt->stmt = LY_STMT_ERROR_MESSAGE; - substmt->storage = &ext_c.compiled; + substmt->storage = (uintptr_t)(void *)&ext_c.compiled; /* * error-message