Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1 | /** |
| 2 | * @file schema_compile.c |
| 3 | * @author Radek Krejci <rkrejci@cesnet.cz> |
Michal Vasko | 19a0902 | 2021-06-15 11:54:08 +0200 | [diff] [blame] | 4 | * @author Michal Vasko <mvasko@cesnet.cz> |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 5 | * @brief Schema compilation. |
| 6 | * |
Michal Vasko | 19a0902 | 2021-06-15 11:54:08 +0200 | [diff] [blame] | 7 | * Copyright (c) 2015 - 2021 CESNET, z.s.p.o. |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 8 | * |
| 9 | * This source code is licensed under BSD 3-Clause License (the "License"). |
| 10 | * You may not use this file except in compliance with the License. |
| 11 | * You may obtain a copy of the License at |
| 12 | * |
| 13 | * https://opensource.org/licenses/BSD-3-Clause |
| 14 | */ |
| 15 | |
| 16 | #define _GNU_SOURCE |
| 17 | |
| 18 | #include "schema_compile.h" |
| 19 | |
| 20 | #include <assert.h> |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 21 | #include <stddef.h> |
| 22 | #include <stdint.h> |
| 23 | #include <stdio.h> |
| 24 | #include <stdlib.h> |
| 25 | #include <string.h> |
| 26 | |
| 27 | #include "common.h" |
| 28 | #include "compat.h" |
| 29 | #include "context.h" |
| 30 | #include "dict.h" |
Michal Vasko | afac782 | 2020-10-20 14:22:26 +0200 | [diff] [blame] | 31 | #include "in.h" |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 32 | #include "log.h" |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 33 | #include "parser_schema.h" |
| 34 | #include "path.h" |
Radek Krejci | 0aa1f70 | 2021-04-01 16:16:19 +0200 | [diff] [blame] | 35 | #include "plugins.h" |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 36 | #include "plugins_exts.h" |
Radek Krejci | 7711410 | 2021-03-10 15:21:57 +0100 | [diff] [blame] | 37 | #include "plugins_exts_compile.h" |
Radek Krejci | 3e6632f | 2021-03-22 22:08:21 +0100 | [diff] [blame] | 38 | #include "plugins_internal.h" |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 39 | #include "plugins_types.h" |
| 40 | #include "schema_compile_amend.h" |
| 41 | #include "schema_compile_node.h" |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 42 | #include "schema_features.h" |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 43 | #include "set.h" |
| 44 | #include "tree.h" |
| 45 | #include "tree_data.h" |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 46 | #include "tree_schema.h" |
| 47 | #include "tree_schema_internal.h" |
| 48 | #include "xpath.h" |
| 49 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 50 | /** |
| 51 | * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition. |
| 52 | */ |
| 53 | static LY_ERR |
| 54 | lys_compile_extension(struct lysc_ctx *ctx, const struct lys_module *ext_mod, struct lysp_ext *ext_p, struct lysc_ext **ext) |
| 55 | { |
| 56 | LY_ERR ret = LY_SUCCESS; |
| 57 | |
Radek Krejci | 720d261 | 2021-03-03 19:44:22 +0100 | [diff] [blame] | 58 | if (ext_p->compiled && (ext_p->compiled->refcount == 1)) { |
| 59 | /* context recompilation - all the extension instances were previously freed (the last link to the compiled extension |
| 60 | * remains from the parsed extension definition) and now we are recompiling them again, to have the up-to-date |
| 61 | * extension definition, we have to recompile it as well now */ |
| 62 | lysc_extension_free(ctx->ctx, &ext_p->compiled); |
| 63 | } |
| 64 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 65 | if (!ext_p->compiled) { |
| 66 | lysc_update_path(ctx, NULL, "{extension}"); |
| 67 | lysc_update_path(ctx, NULL, ext_p->name); |
| 68 | |
| 69 | /* compile the extension definition */ |
| 70 | ext_p->compiled = calloc(1, sizeof **ext); |
| 71 | ext_p->compiled->refcount = 1; |
| 72 | DUP_STRING_GOTO(ctx->ctx, ext_p->name, ext_p->compiled->name, ret, done); |
Radek Krejci | 9f87b0c | 2021-03-05 14:45:26 +0100 | [diff] [blame] | 73 | DUP_STRING_GOTO(ctx->ctx, ext_p->argname, ext_p->compiled->argname, ret, done); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 74 | ext_p->compiled->module = (struct lys_module *)ext_mod; |
Radek Krejci | ab43086 | 2021-03-02 20:13:40 +0100 | [diff] [blame] | 75 | COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext_p->compiled->exts, *ext, ret, done); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 76 | |
| 77 | lysc_update_path(ctx, NULL, NULL); |
| 78 | lysc_update_path(ctx, NULL, NULL); |
| 79 | |
| 80 | /* find extension definition plugin */ |
Radek Krejci | 3e6632f | 2021-03-22 22:08:21 +0100 | [diff] [blame] | 81 | ext_p->compiled->plugin = lyplg_find(LYPLG_EXTENSION, ext_p->compiled->module->name, |
| 82 | ext_p->compiled->module->revision, ext_p->compiled->name); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | *ext = lysc_ext_dup(ext_p->compiled); |
| 86 | |
| 87 | done: |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 88 | if (ret) { |
| 89 | lysc_update_path(ctx, NULL, NULL); |
| 90 | lysc_update_path(ctx, NULL, NULL); |
| 91 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 92 | return ret; |
| 93 | } |
| 94 | |
| 95 | LY_ERR |
| 96 | lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent, |
Radek Krejci | ab43086 | 2021-03-02 20:13:40 +0100 | [diff] [blame] | 97 | const struct lys_module *ext_mod) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 98 | { |
Radek Krejci | 85ac831 | 2021-03-03 20:21:33 +0100 | [diff] [blame] | 99 | LY_ERR ret = LY_SUCCESS; |
| 100 | struct lysp_ext *ext_def; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 101 | |
Radek Krejci | ab43086 | 2021-03-02 20:13:40 +0100 | [diff] [blame] | 102 | ext->parent_stmt = ext_p->parent_stmt; |
| 103 | ext->parent_stmt_index = ext_p->parent_stmt_index; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 104 | ext->module = ctx->cur_mod; |
| 105 | ext->parent = parent; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 106 | |
Radek Krejci | ab43086 | 2021-03-02 20:13:40 +0100 | [diff] [blame] | 107 | lysc_update_path(ctx, LY_STMT_IS_NODE(ext->parent_stmt) ? ((struct lysc_node *)ext->parent)->module : NULL, "{extension}"); |
Michal Vasko | fc2cd07 | 2021-02-24 13:17:17 +0100 | [diff] [blame] | 108 | lysc_update_path(ctx, NULL, ext_p->name); |
| 109 | |
Radek Krejci | 85ac831 | 2021-03-03 20:21:33 +0100 | [diff] [blame] | 110 | LY_CHECK_GOTO(ret = lysp_ext_find_definition(ctx->ctx, ext_p, &ext_mod, &ext_def), cleanup); |
| 111 | LY_CHECK_GOTO(ret = lys_compile_extension(ctx, ext_mod, ext_def, &ext->def), cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 112 | |
Radek Krejci | 9f87b0c | 2021-03-05 14:45:26 +0100 | [diff] [blame] | 113 | if (ext_def->argname) { |
Radek Krejci | 85ac831 | 2021-03-03 20:21:33 +0100 | [diff] [blame] | 114 | LY_CHECK_GOTO(ret = lysp_ext_instance_resolve_argument(ctx->ctx, ext_p, ext_def), cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 115 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 116 | |
Radek Krejci | 85ac831 | 2021-03-03 20:21:33 +0100 | [diff] [blame] | 117 | DUP_STRING(ctx->ctx, ext_p->argument, ext->argument, ret); |
| 118 | LY_CHECK_RET(ret); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 119 | |
| 120 | if (ext->def->plugin && ext->def->plugin->compile) { |
| 121 | if (ext->argument) { |
Radek Krejci | a601699 | 2021-03-03 10:13:41 +0100 | [diff] [blame] | 122 | lysc_update_path(ctx, ext->module, ext->argument); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 123 | } |
Michal Vasko | fc2cd07 | 2021-02-24 13:17:17 +0100 | [diff] [blame] | 124 | ret = ext->def->plugin->compile(ctx, ext_p, ext); |
Radek Krejci | cc21a4f | 2021-02-09 15:23:31 +0100 | [diff] [blame] | 125 | if (ret == LY_ENOT) { |
| 126 | lysc_ext_instance_free(ctx->ctx, ext); |
| 127 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 128 | if (ext->argument) { |
| 129 | lysc_update_path(ctx, NULL, NULL); |
| 130 | } |
Michal Vasko | fc2cd07 | 2021-02-24 13:17:17 +0100 | [diff] [blame] | 131 | LY_CHECK_GOTO(ret, cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 132 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 133 | |
| 134 | cleanup: |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 135 | lysc_update_path(ctx, NULL, NULL); |
Michal Vasko | fc2cd07 | 2021-02-24 13:17:17 +0100 | [diff] [blame] | 136 | lysc_update_path(ctx, NULL, NULL); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 137 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 138 | return ret; |
| 139 | } |
| 140 | |
| 141 | struct lysc_ext * |
| 142 | lysc_ext_dup(struct lysc_ext *orig) |
| 143 | { |
| 144 | ++orig->refcount; |
| 145 | return orig; |
| 146 | } |
| 147 | |
Jan Kundrát | c6e39de | 2021-12-09 16:01:19 +0100 | [diff] [blame] | 148 | LIBYANG_API_DEF LY_ERR |
Michal Vasko | d57b664 | 2022-02-02 09:11:53 +0100 | [diff] [blame] | 149 | lysc_ext_substmt(const struct lysc_ext_instance *ext, enum ly_stmt substmt, void **instance_p, |
| 150 | enum ly_stmt_cardinality *cardinality_p) |
Radek Krejci | 1b2eef8 | 2021-02-17 11:17:27 +0100 | [diff] [blame] | 151 | { |
| 152 | LY_ARRAY_COUNT_TYPE u; |
| 153 | |
Michal Vasko | b670ff5 | 2022-02-15 10:46:08 +0100 | [diff] [blame] | 154 | if (instance_p) { |
| 155 | *instance_p = NULL; |
| 156 | } |
| 157 | if (cardinality_p) { |
| 158 | *cardinality_p = 0; |
| 159 | } |
| 160 | |
Radek Krejci | 1b2eef8 | 2021-02-17 11:17:27 +0100 | [diff] [blame] | 161 | LY_ARRAY_FOR(ext->substmts, u) { |
Radek Krejci | 61837f7 | 2021-03-02 19:53:59 +0100 | [diff] [blame] | 162 | if (LY_STMT_IS_DATA_NODE(substmt)) { |
| 163 | if (!LY_STMT_IS_DATA_NODE(ext->substmts[u].stmt)) { |
Radek Krejci | 1b2eef8 | 2021-02-17 11:17:27 +0100 | [diff] [blame] | 164 | continue; |
| 165 | } |
| 166 | } else if (LY_STMT_IS_OP(substmt)) { |
| 167 | if (!LY_STMT_IS_OP(ext->substmts[u].stmt)) { |
| 168 | continue; |
| 169 | } |
| 170 | } else if (ext->substmts[u].stmt != substmt) { |
| 171 | continue; |
| 172 | } |
| 173 | |
| 174 | /* match */ |
| 175 | if (cardinality_p) { |
| 176 | *cardinality_p = ext->substmts[u].cardinality; |
| 177 | } |
| 178 | if (instance_p) { |
| 179 | *instance_p = ext->substmts[u].storage; |
| 180 | } |
| 181 | return LY_SUCCESS; |
| 182 | } |
| 183 | |
| 184 | return LY_ENOT; |
| 185 | } |
| 186 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 187 | static void |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 188 | lysc_unres_must_free(struct lysc_unres_must *m) |
| 189 | { |
| 190 | LY_ARRAY_FREE(m->local_mods); |
| 191 | free(m); |
| 192 | } |
| 193 | |
| 194 | static void |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 195 | lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r) |
| 196 | { |
| 197 | assert(!r->dflt || !r->dflts); |
| 198 | if (r->dflt) { |
| 199 | lysp_qname_free((struct ly_ctx *)ctx, r->dflt); |
| 200 | free(r->dflt); |
| 201 | } else { |
| 202 | FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free); |
| 203 | } |
| 204 | free(r); |
| 205 | } |
| 206 | |
| 207 | void |
Radek Krejci | a601699 | 2021-03-03 10:13:41 +0100 | [diff] [blame] | 208 | lysc_update_path(struct lysc_ctx *ctx, struct lys_module *parent_module, const char *name) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 209 | { |
| 210 | int len; |
| 211 | uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */ |
| 212 | |
| 213 | if (!name) { |
| 214 | /* removing last path segment */ |
| 215 | if (ctx->path[ctx->path_len - 1] == '}') { |
| 216 | for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {} |
| 217 | if (ctx->path[ctx->path_len] == '=') { |
| 218 | ctx->path[ctx->path_len++] = '}'; |
| 219 | } else { |
| 220 | /* not a top-level special tag, remove also preceiding '/' */ |
| 221 | goto remove_nodelevel; |
| 222 | } |
| 223 | } else { |
| 224 | remove_nodelevel: |
| 225 | for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {} |
| 226 | if (ctx->path_len == 0) { |
| 227 | /* top-level (last segment) */ |
| 228 | ctx->path_len = 1; |
| 229 | } |
| 230 | } |
| 231 | /* set new terminating NULL-byte */ |
| 232 | ctx->path[ctx->path_len] = '\0'; |
| 233 | } else { |
| 234 | if (ctx->path_len > 1) { |
Radek Krejci | a601699 | 2021-03-03 10:13:41 +0100 | [diff] [blame] | 235 | if (!parent_module && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 236 | /* extension of the special tag */ |
| 237 | nextlevel = 2; |
| 238 | --ctx->path_len; |
| 239 | } else { |
| 240 | /* there is already some path, so add next level */ |
| 241 | nextlevel = 1; |
| 242 | } |
| 243 | } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */ |
| 244 | |
| 245 | if (nextlevel != 2) { |
Radek Krejci | a601699 | 2021-03-03 10:13:41 +0100 | [diff] [blame] | 246 | if ((parent_module && (parent_module == ctx->cur_mod)) || (!parent_module && (ctx->path_len > 1) && (name[0] == '{'))) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 247 | /* module not changed, print the name unprefixed */ |
| 248 | len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name); |
| 249 | } else { |
| 250 | len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name); |
| 251 | } |
| 252 | } else { |
| 253 | len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name); |
| 254 | } |
| 255 | if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) { |
| 256 | /* output truncated */ |
| 257 | ctx->path_len = LYSC_CTX_BUFSIZE - 1; |
| 258 | } else { |
| 259 | ctx->path_len += len; |
| 260 | } |
| 261 | } |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 262 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 263 | LOG_LOCBACK(0, 0, 1, 0); |
| 264 | LOG_LOCSET(NULL, NULL, ctx->path, NULL); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 265 | } |
| 266 | |
aPiecek | 6b3d542 | 2021-07-30 15:55:43 +0200 | [diff] [blame] | 267 | /** |
| 268 | * @brief Compile information from the identity statement |
| 269 | * |
| 270 | * The backlinks to the identities derived from this one are supposed to be filled later via ::lys_compile_identity_bases(). |
| 271 | * |
| 272 | * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p parsed_mod. |
| 273 | * @param[in] ctx libyang context. |
| 274 | * @param[in] parsed_mod Module with the identities. |
| 275 | * @param[in] identities_p Array of the parsed identity definitions to precompile. |
| 276 | * @param[in,out] identities Pointer to the storage of the (pre)compiled identities array where the new identities are |
| 277 | * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed identities are going |
| 278 | * to be processed. |
| 279 | * @return LY_ERR value. |
| 280 | */ |
| 281 | static LY_ERR |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 282 | lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod, |
| 283 | struct lysp_ident *identities_p, struct lysc_ident **identities) |
| 284 | { |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 285 | LY_ARRAY_COUNT_TYPE u; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 286 | struct lysc_ctx context = {0}; |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 287 | struct lysc_ident *ident; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 288 | LY_ERR ret = LY_SUCCESS; |
| 289 | |
| 290 | assert(ctx_sc || ctx); |
| 291 | |
| 292 | if (!ctx_sc) { |
| 293 | context.ctx = ctx; |
Radek Krejci | 3aac9a7 | 2020-12-01 12:24:26 +0100 | [diff] [blame] | 294 | context.cur_mod = parsed_mod ? parsed_mod->mod : NULL; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 295 | context.pmod = parsed_mod; |
| 296 | context.path_len = 1; |
| 297 | context.path[0] = '/'; |
| 298 | ctx_sc = &context; |
| 299 | } |
| 300 | |
| 301 | if (!identities_p) { |
| 302 | return LY_SUCCESS; |
| 303 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 304 | |
| 305 | lysc_update_path(ctx_sc, NULL, "{identity}"); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 306 | LY_ARRAY_FOR(identities_p, u) { |
| 307 | lysc_update_path(ctx_sc, NULL, identities_p[u].name); |
| 308 | |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 309 | /* add new compiled identity */ |
| 310 | LY_ARRAY_NEW_RET(ctx_sc->ctx, *identities, ident, LY_EMEM); |
| 311 | |
| 312 | DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done); |
| 313 | DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done); |
| 314 | DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done); |
| 315 | ident->module = ctx_sc->cur_mod; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 316 | /* backlinks (derived) can be added no sooner than when all the identities in the current module are present */ |
Radek Krejci | ab43086 | 2021-03-02 20:13:40 +0100 | [diff] [blame] | 317 | COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, ret, done); |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 318 | ident->flags = identities_p[u].flags; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 319 | |
| 320 | lysc_update_path(ctx_sc, NULL, NULL); |
| 321 | } |
| 322 | lysc_update_path(ctx_sc, NULL, NULL); |
| 323 | done: |
| 324 | return ret; |
| 325 | } |
| 326 | |
| 327 | /** |
| 328 | * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement). |
| 329 | * |
| 330 | * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages. |
| 331 | * |
| 332 | * @param[in] ctx Compile context for logging. |
| 333 | * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed). |
| 334 | * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident) |
| 335 | * @return LY_SUCCESS if everything is ok. |
| 336 | * @return LY_EVALID if the identity is derived from itself. |
| 337 | */ |
| 338 | static LY_ERR |
| 339 | lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived) |
| 340 | { |
| 341 | LY_ERR ret = LY_SUCCESS; |
| 342 | LY_ARRAY_COUNT_TYPE u, v; |
| 343 | struct ly_set recursion = {0}; |
| 344 | struct lysc_ident *drv; |
| 345 | |
| 346 | if (!derived) { |
| 347 | return LY_SUCCESS; |
| 348 | } |
| 349 | |
| 350 | for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) { |
| 351 | if (ident == derived[u]) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 352 | LOGVAL(ctx->ctx, LYVE_REFERENCE, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 353 | "Identity \"%s\" is indirectly derived from itself.", ident->name); |
| 354 | ret = LY_EVALID; |
| 355 | goto cleanup; |
| 356 | } |
| 357 | ret = ly_set_add(&recursion, derived[u], 0, NULL); |
| 358 | LY_CHECK_GOTO(ret, cleanup); |
| 359 | } |
| 360 | |
| 361 | for (v = 0; v < recursion.count; ++v) { |
| 362 | drv = recursion.objs[v]; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 363 | for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) { |
| 364 | if (ident == drv->derived[u]) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 365 | LOGVAL(ctx->ctx, LYVE_REFERENCE, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 366 | "Identity \"%s\" is indirectly derived from itself.", ident->name); |
| 367 | ret = LY_EVALID; |
| 368 | goto cleanup; |
| 369 | } |
| 370 | ret = ly_set_add(&recursion, drv->derived[u], 0, NULL); |
| 371 | LY_CHECK_GOTO(ret, cleanup); |
| 372 | } |
| 373 | } |
| 374 | |
| 375 | cleanup: |
| 376 | ly_set_erase(&recursion, NULL); |
| 377 | return ret; |
| 378 | } |
| 379 | |
| 380 | LY_ERR |
| 381 | lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p, |
aPiecek | f4a0a19 | 2021-08-03 15:14:17 +0200 | [diff] [blame] | 382 | struct lysc_ident *ident, struct lysc_ident ***bases) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 383 | { |
| 384 | LY_ARRAY_COUNT_TYPE u, v; |
| 385 | const char *s, *name; |
| 386 | const struct lys_module *mod; |
| 387 | struct lysc_ident **idref; |
| 388 | |
aPiecek | f4a0a19 | 2021-08-03 15:14:17 +0200 | [diff] [blame] | 389 | assert(ident || bases); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 390 | |
| 391 | if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 392 | LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 393 | "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type"); |
| 394 | return LY_EVALID; |
| 395 | } |
| 396 | |
| 397 | LY_ARRAY_FOR(bases_p, u) { |
| 398 | s = strchr(bases_p[u], ':'); |
| 399 | if (s) { |
| 400 | /* prefixed identity */ |
| 401 | name = &s[1]; |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 402 | mod = ly_resolve_prefix(ctx->ctx, bases_p[u], s - bases_p[u], LY_VALUE_SCHEMA, (void *)base_pmod); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 403 | } else { |
| 404 | name = bases_p[u]; |
| 405 | mod = base_pmod->mod; |
| 406 | } |
| 407 | if (!mod) { |
| 408 | if (ident) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 409 | LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 410 | "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name); |
| 411 | } else { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 412 | LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 413 | "Invalid prefix used for base (%s) of identityref.", bases_p[u]); |
| 414 | } |
| 415 | return LY_EVALID; |
| 416 | } |
| 417 | |
| 418 | idref = NULL; |
| 419 | LY_ARRAY_FOR(mod->identities, v) { |
| 420 | if (!strcmp(name, mod->identities[v].name)) { |
| 421 | if (ident) { |
| 422 | if (ident == &mod->identities[v]) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 423 | LOGVAL(ctx->ctx, LYVE_REFERENCE, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 424 | "Identity \"%s\" is derived from itself.", ident->name); |
| 425 | return LY_EVALID; |
| 426 | } |
| 427 | LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived)); |
| 428 | /* we have match! store the backlink */ |
| 429 | LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM); |
| 430 | *idref = ident; |
| 431 | } else { |
| 432 | /* we have match! store the found identity */ |
| 433 | LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM); |
| 434 | *idref = &mod->identities[v]; |
| 435 | } |
| 436 | break; |
| 437 | } |
| 438 | } |
aPiecek | f4a0a19 | 2021-08-03 15:14:17 +0200 | [diff] [blame] | 439 | if (!idref) { |
Radek Krejci | 10443f4 | 2021-03-28 17:40:35 +0200 | [diff] [blame] | 440 | if (ident) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 441 | LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 442 | "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name); |
| 443 | } else { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 444 | LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 445 | "Unable to find base (%s) of identityref.", bases_p[u]); |
| 446 | } |
| 447 | return LY_EVALID; |
| 448 | } |
| 449 | } |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 450 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 451 | return LY_SUCCESS; |
| 452 | } |
| 453 | |
| 454 | /** |
| 455 | * @brief For the given array of identities, set the backlinks from all their base identities. |
| 456 | * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes. |
| 457 | * @param[in] idents_p Array of identities definitions from the parsed schema structure. |
aPiecek | f4a0a19 | 2021-08-03 15:14:17 +0200 | [diff] [blame] | 458 | * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set. |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 459 | * @return LY_ERR value - LY_SUCCESS or LY_EVALID. |
| 460 | */ |
| 461 | static LY_ERR |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 462 | lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident **idents) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 463 | { |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 464 | LY_ARRAY_COUNT_TYPE u, v; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 465 | |
| 466 | lysc_update_path(ctx, NULL, "{identity}"); |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 467 | |
aPiecek | f3e2db8 | 2021-08-05 10:18:43 +0200 | [diff] [blame] | 468 | for (u = 0; u < LY_ARRAY_COUNT(*idents); ++u) { |
aPiecek | f4a0a19 | 2021-08-03 15:14:17 +0200 | [diff] [blame] | 469 | /* find matching parsed identity */ |
aPiecek | f3e2db8 | 2021-08-05 10:18:43 +0200 | [diff] [blame] | 470 | for (v = 0; v < LY_ARRAY_COUNT(idents_p); ++v) { |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 471 | if (idents_p[v].name == (*idents)[u].name) { |
| 472 | break; |
| 473 | } |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 474 | } |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 475 | |
Michal Vasko | dc6f84c | 2021-06-15 14:50:27 +0200 | [diff] [blame] | 476 | if ((v == LY_ARRAY_COUNT(idents_p)) || !idents_p[v].bases) { |
| 477 | /* identity not found (it may be from a submodule) or identity without bases */ |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 478 | continue; |
| 479 | } |
Michal Vasko | dc6f84c | 2021-06-15 14:50:27 +0200 | [diff] [blame] | 480 | |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 481 | lysc_update_path(ctx, NULL, (*idents)[u].name); |
aPiecek | f4a0a19 | 2021-08-03 15:14:17 +0200 | [diff] [blame] | 482 | LY_CHECK_RET(lys_compile_identity_bases(ctx, ctx->pmod, idents_p[v].bases, &(*idents)[u], NULL)); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 483 | lysc_update_path(ctx, NULL, NULL); |
| 484 | } |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 485 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 486 | lysc_update_path(ctx, NULL, NULL); |
| 487 | return LY_SUCCESS; |
| 488 | } |
| 489 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 490 | static void * |
| 491 | lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts) |
| 492 | { |
| 493 | for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) { |
| 494 | if (substmts[u].stmt == stmt) { |
| 495 | return substmts[u].storage; |
| 496 | } |
| 497 | } |
| 498 | return NULL; |
| 499 | } |
| 500 | |
| 501 | LY_ERR |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 502 | lys_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 503 | { |
aPiecek | 1c4da36 | 2021-04-29 14:26:34 +0200 | [diff] [blame] | 504 | LY_ERR ret = LY_SUCCESS, r; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 505 | LY_ARRAY_COUNT_TYPE u; |
| 506 | struct lysp_stmt *stmt; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 507 | void *parsed = NULL, **compiled = NULL; |
| 508 | |
| 509 | /* check for invalid substatements */ |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 510 | for (stmt = ext_p->child; stmt; stmt = stmt->next) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 511 | if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) { |
| 512 | continue; |
| 513 | } |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 514 | LY_ARRAY_FOR(ext->substmts, u) { |
| 515 | if (ext->substmts[u].stmt == stmt->kw) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 516 | break; |
| 517 | } |
| 518 | } |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 519 | if (u == LY_ARRAY_COUNT(ext->substmts)) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 520 | LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s%s%s\" extension instance.", |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 521 | stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : ""); |
aPiecek | 1c4da36 | 2021-04-29 14:26:34 +0200 | [diff] [blame] | 522 | ret = LY_EVALID; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 523 | goto cleanup; |
| 524 | } |
| 525 | } |
| 526 | |
| 527 | /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */ |
| 528 | |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 529 | /* note into the compile context that we are processing extension now */ |
| 530 | ctx->ext = ext; |
| 531 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 532 | /* keep order of the processing the same as the order in the defined substmts, |
| 533 | * the order is important for some of the statements depending on others (e.g. type needs status and units) */ |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 534 | |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 535 | LY_ARRAY_FOR(ext->substmts, u) { |
| 536 | uint64_t stmt_counter = 0; |
| 537 | |
| 538 | for (stmt = ext_p->child; stmt; stmt = stmt->next) { |
| 539 | if (ext->substmts[u].stmt != stmt->kw) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 540 | continue; |
| 541 | } |
| 542 | |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 543 | parsed = NULL; |
| 544 | stmt_counter++; |
| 545 | if (ext->substmts[u].storage) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 546 | switch (stmt->kw) { |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 547 | case LY_STMT_ACTION: |
| 548 | case LY_STMT_ANYDATA: |
| 549 | case LY_STMT_ANYXML: |
| 550 | case LY_STMT_CONTAINER: |
| 551 | case LY_STMT_CHOICE: |
| 552 | case LY_STMT_LEAF: |
| 553 | case LY_STMT_LEAF_LIST: |
| 554 | case LY_STMT_LIST: |
| 555 | case LY_STMT_NOTIFICATION: |
| 556 | case LY_STMT_RPC: |
| 557 | case LY_STMT_USES: |
aPiecek | 60d9d67 | 2021-04-27 15:49:57 +0200 | [diff] [blame] | 558 | if (!ext_p->parsed) { |
| 559 | struct lysp_ext_instance *unconst_ext_p; |
| 560 | r = lysp_stmt_parse(ctx, stmt, &parsed, NULL); |
| 561 | LY_CHECK_ERR_GOTO(r, ret = r, cleanup); |
| 562 | unconst_ext_p = (struct lysp_ext_instance *)ext_p; |
| 563 | unconst_ext_p->parsed = parsed; |
| 564 | } else { |
Michal Vasko | a9309bb | 2021-07-09 09:31:55 +0200 | [diff] [blame] | 565 | struct lysp_node *node, *last_node = NULL; |
aPiecek | 60d9d67 | 2021-04-27 15:49:57 +0200 | [diff] [blame] | 566 | /* get last parsed node */ |
| 567 | LY_LIST_FOR(ext_p->parsed, node) { |
| 568 | last_node = node; |
| 569 | } |
| 570 | /* create and link sibling */ |
| 571 | r = lysp_stmt_parse(ctx, stmt, &parsed, NULL); |
| 572 | LY_CHECK_ERR_GOTO(r, ret = r, cleanup); |
| 573 | last_node->next = parsed; |
| 574 | } |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 575 | |
| 576 | /* set storage as an alternative document root in the compile context */ |
| 577 | r = lys_compile_node(ctx, parsed, NULL, 0, NULL); |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 578 | LY_CHECK_ERR_GOTO(r, ret = r, cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 579 | break; |
Radek Krejci | 1b2eef8 | 2021-02-17 11:17:27 +0100 | [diff] [blame] | 580 | case LY_STMT_DESCRIPTION: |
| 581 | case LY_STMT_REFERENCE: |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 582 | case LY_STMT_UNITS: { |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 583 | const char **str_p; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 584 | |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 585 | if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 586 | /* single item */ |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 587 | if (*((const char **)ext->substmts[u].storage)) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 588 | LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt); |
aPiecek | 1c4da36 | 2021-04-29 14:26:34 +0200 | [diff] [blame] | 589 | ret = LY_EVALID; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 590 | goto cleanup; |
| 591 | } |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 592 | str_p = (const char **)ext->substmts[u].storage; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 593 | } else { |
| 594 | /* sized array */ |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 595 | const char ***strings_array = (const char ***)ext->substmts[u].storage; |
| 596 | LY_ARRAY_NEW_GOTO(ctx->ctx, *strings_array, str_p, ret, cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 597 | } |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 598 | r = lydict_insert(ctx->ctx, stmt->arg, 0, str_p); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 599 | LY_CHECK_ERR_GOTO(r, ret = r, cleanup); |
| 600 | break; |
| 601 | } |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 602 | case LY_STMT_IF_FEATURE: { |
| 603 | ly_bool enabled; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 604 | |
Radek Krejci | 76c8c4e | 2021-02-17 10:16:48 +0100 | [diff] [blame] | 605 | r = lysp_stmt_parse(ctx, stmt, &parsed, NULL); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 606 | LY_CHECK_ERR_GOTO(r, ret = r, cleanup); |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 607 | |
| 608 | r = lys_eval_iffeatures(ctx->ctx, parsed, &enabled); |
| 609 | FREE_ARRAY(ctx->ctx, (struct lysp_qname *)parsed, lysp_qname_free); |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 610 | LY_CHECK_ERR_GOTO(r, ret = r, cleanup); |
| 611 | if (!enabled) { |
| 612 | /* it is disabled, remove the whole extension instance */ |
| 613 | return LY_ENOT; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 614 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 615 | break; |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 616 | } |
| 617 | case LY_STMT_STATUS: |
| 618 | assert(ext->substmts[u].cardinality < LY_STMT_CARD_SOME); |
| 619 | LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, &ext->substmts[u].storage, /* TODO */ NULL), ret = r, cleanup); |
| 620 | break; |
| 621 | case LY_STMT_TYPE: { |
| 622 | uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, ext->substmts); |
| 623 | const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, ext->substmts); |
| 624 | |
| 625 | if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) { |
| 626 | /* single item */ |
| 627 | if (*(struct lysc_type **)ext->substmts[u].storage) { |
| 628 | LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt); |
aPiecek | 1c4da36 | 2021-04-29 14:26:34 +0200 | [diff] [blame] | 629 | ret = LY_EVALID; |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 630 | goto cleanup; |
| 631 | } |
| 632 | compiled = ext->substmts[u].storage; |
| 633 | } else { |
| 634 | /* sized array */ |
| 635 | struct lysc_type ***types = (struct lysc_type ***)ext->substmts[u].storage, **type = NULL; |
| 636 | LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup); |
| 637 | compiled = (void *)type; |
| 638 | } |
| 639 | |
| 640 | r = lysp_stmt_parse(ctx, stmt, &parsed, NULL); |
| 641 | LY_CHECK_ERR_GOTO(r, ret = r, cleanup); |
| 642 | r = lys_compile_type(ctx, NULL, flags ? *flags : 0, ext_p->name, parsed, (struct lysc_type **)compiled, |
| 643 | units && !*units ? units : NULL, NULL); |
| 644 | lysp_type_free(ctx->ctx, parsed); |
| 645 | free(parsed); |
| 646 | LY_CHECK_ERR_GOTO(r, ret = r, cleanup); |
| 647 | break; |
| 648 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 649 | /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc), |
| 650 | * also note that in many statements their extensions are not taken into account */ |
| 651 | default: |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 652 | LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Statement \"%s\" is not supported as an extension (found in \"%s%s%s\") substatement.", |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 653 | stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : ""); |
aPiecek | 1c4da36 | 2021-04-29 14:26:34 +0200 | [diff] [blame] | 654 | ret = LY_EVALID; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 655 | goto cleanup; |
| 656 | } |
| 657 | } |
| 658 | } |
| 659 | |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 660 | if (((ext->substmts[u].cardinality == LY_STMT_CARD_MAND) || (ext->substmts[u].cardinality == LY_STMT_CARD_SOME)) && !stmt_counter) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 661 | LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".", |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 662 | ly_stmt2str(ext->substmts[u].stmt), ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : ""); |
aPiecek | 1c4da36 | 2021-04-29 14:26:34 +0200 | [diff] [blame] | 663 | ret = LY_EVALID; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 664 | goto cleanup; |
| 665 | } |
| 666 | } |
| 667 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 668 | cleanup: |
Radek Krejci | 6b88a46 | 2021-02-17 12:39:34 +0100 | [diff] [blame] | 669 | ctx->ext = NULL; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 670 | return ret; |
| 671 | } |
| 672 | |
| 673 | /** |
| 674 | * @brief Check when for cyclic dependencies. |
| 675 | * |
| 676 | * @param[in] set Set with all the referenced nodes. |
| 677 | * @param[in] node Node whose "when" referenced nodes are in @p set. |
| 678 | * @return LY_ERR value |
| 679 | */ |
| 680 | static LY_ERR |
| 681 | lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node) |
| 682 | { |
| 683 | struct lyxp_set tmp_set; |
| 684 | struct lyxp_set_scnode *xp_scnode; |
| 685 | uint32_t i, j; |
| 686 | LY_ARRAY_COUNT_TYPE u; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 687 | LY_ERR ret = LY_SUCCESS; |
| 688 | |
| 689 | memset(&tmp_set, 0, sizeof tmp_set); |
| 690 | |
| 691 | /* prepare in_ctx of the set */ |
| 692 | for (i = 0; i < set->used; ++i) { |
| 693 | xp_scnode = &set->val.scnodes[i]; |
| 694 | |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 695 | if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 696 | /* check node when, skip the context node (it was just checked) */ |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 697 | xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 698 | } |
| 699 | } |
| 700 | |
| 701 | for (i = 0; i < set->used; ++i) { |
| 702 | xp_scnode = &set->val.scnodes[i]; |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 703 | if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 704 | /* already checked */ |
| 705 | continue; |
| 706 | } |
| 707 | |
Michal Vasko | 1a09b21 | 2021-05-06 13:00:10 +0200 | [diff] [blame] | 708 | if ((xp_scnode->type != LYXP_NODE_ELEM) || !lysc_node_when(xp_scnode->scnode)) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 709 | /* no when to check */ |
Michal Vasko | 1a09b21 | 2021-05-06 13:00:10 +0200 | [diff] [blame] | 710 | xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_NODE; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 711 | continue; |
| 712 | } |
| 713 | |
| 714 | node = xp_scnode->scnode; |
| 715 | do { |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 716 | struct lysc_when **when_list, *when; |
| 717 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 718 | LOG_LOCSET(node, NULL, NULL, NULL); |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 719 | when_list = lysc_node_when(node); |
| 720 | LY_ARRAY_FOR(when_list, u) { |
| 721 | when = when_list[u]; |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 722 | ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes, |
Michal Vasko | 400e967 | 2021-01-11 13:39:17 +0100 | [diff] [blame] | 723 | when->context, &tmp_set, LYXP_SCNODE_SCHEMA); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 724 | if (ret != LY_SUCCESS) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 725 | LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr); |
Michal Vasko | 34f88eb | 2022-02-18 09:18:21 +0100 | [diff] [blame] | 726 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 727 | goto cleanup; |
| 728 | } |
| 729 | |
| 730 | for (j = 0; j < tmp_set.used; ++j) { |
| 731 | /* skip roots'n'stuff */ |
| 732 | if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) { |
| 733 | /* try to find this node in our set */ |
| 734 | uint32_t idx; |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 735 | if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) && |
| 736 | (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) { |
Michal Vasko | 2c4d915 | 2021-07-20 09:17:28 +0200 | [diff] [blame] | 737 | LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition cyclic dependency on the node \"%s\".", |
| 738 | tmp_set.val.scnodes[j].scnode->name); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 739 | ret = LY_EVALID; |
Michal Vasko | 34f88eb | 2022-02-18 09:18:21 +0100 | [diff] [blame] | 740 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 741 | goto cleanup; |
| 742 | } |
| 743 | |
| 744 | /* needs to be checked, if in both sets, will be ignored */ |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 745 | tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 746 | } else { |
| 747 | /* no when, nothing to check */ |
Michal Vasko | 1a09b21 | 2021-05-06 13:00:10 +0200 | [diff] [blame] | 748 | tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_NODE; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 749 | } |
| 750 | } |
| 751 | |
| 752 | /* merge this set into the global when set */ |
| 753 | lyxp_set_scnode_merge(set, &tmp_set); |
| 754 | } |
| 755 | |
| 756 | /* check when of non-data parents as well */ |
| 757 | node = node->parent; |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 758 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 759 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 760 | } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE))); |
| 761 | |
| 762 | /* this node when was checked (xp_scnode could have been reallocd) */ |
Michal Vasko | 60edc2f | 2021-07-20 09:18:02 +0200 | [diff] [blame] | 763 | set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 764 | } |
| 765 | |
| 766 | cleanup: |
| 767 | lyxp_set_free_content(&tmp_set); |
| 768 | return ret; |
| 769 | } |
| 770 | |
| 771 | LY_ERR |
| 772 | lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2, |
| 773 | const char *name2) |
| 774 | { |
| 775 | uint16_t flg1, flg2; |
| 776 | |
| 777 | flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR; |
| 778 | flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR; |
| 779 | |
| 780 | if ((flg1 < flg2) && (mod1 == mod2)) { |
| 781 | if (ctx) { |
Michal Vasko | 23864e0 | 2021-06-24 09:23:58 +0200 | [diff] [blame] | 782 | LOGVAL(ctx->ctx, LYVE_REFERENCE, "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".", |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 783 | flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1, |
| 784 | flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2); |
| 785 | } |
| 786 | return LY_EVALID; |
| 787 | } |
| 788 | |
| 789 | return LY_SUCCESS; |
| 790 | } |
| 791 | |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 792 | LY_ERR |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 793 | lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_VALUE_FORMAT format, |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 794 | void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p) |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 795 | { |
| 796 | uint32_t i; |
Michal Vasko | c56d637 | 2021-10-19 12:29:00 +0200 | [diff] [blame] | 797 | const char *ptr, *start, **imp_f, *all_f[] = {"*", NULL}; |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 798 | const struct lys_module *mod; |
| 799 | |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 800 | assert(implement || mod_p); |
| 801 | |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 802 | for (i = 0; i < expr->used; ++i) { |
| 803 | if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) { |
| 804 | /* token cannot have a prefix */ |
| 805 | continue; |
| 806 | } |
| 807 | |
| 808 | start = expr->expr + expr->tok_pos[i]; |
| 809 | if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) { |
| 810 | /* token without a prefix */ |
| 811 | continue; |
| 812 | } |
| 813 | |
| 814 | if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) { |
| 815 | /* unknown prefix, do not care right now */ |
| 816 | continue; |
| 817 | } |
| 818 | |
Michal Vasko | 0c29672 | 2021-07-14 08:53:16 +0200 | [diff] [blame] | 819 | /* unimplemented module found */ |
| 820 | if (!mod->implemented && !implement) { |
| 821 | /* should not be implemented now */ |
| 822 | *mod_p = mod; |
| 823 | break; |
| 824 | } |
| 825 | |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 826 | if (!mod->implemented) { |
Michal Vasko | 0c29672 | 2021-07-14 08:53:16 +0200 | [diff] [blame] | 827 | /* implement if not implemented */ |
Michal Vasko | c56d637 | 2021-10-19 12:29:00 +0200 | [diff] [blame] | 828 | imp_f = (ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL; |
| 829 | LY_CHECK_RET(lys_implement((struct lys_module *)mod, imp_f, unres)); |
Michal Vasko | 0c29672 | 2021-07-14 08:53:16 +0200 | [diff] [blame] | 830 | } |
| 831 | if (!mod->compiled) { |
| 832 | /* compile if not implemented before or only marked for compilation */ |
| 833 | LY_CHECK_RET(lys_compile((struct lys_module *)mod, &unres->ds_unres)); |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 834 | } |
| 835 | } |
| 836 | |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 837 | return LY_SUCCESS; |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 838 | } |
| 839 | |
| 840 | /** |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 841 | * @brief Check when expressions of a node on a complete compiled schema tree. |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 842 | * |
| 843 | * @param[in] ctx Compile context. |
| 844 | * @param[in] node Node to check. |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 845 | * @param[in,out] unres Global unres structure. |
Michal Vasko | 40c158c | 2021-04-28 17:01:03 +0200 | [diff] [blame] | 846 | * @return LY_ERECOMPILE |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 847 | * @return LY_ERR value |
| 848 | */ |
| 849 | static LY_ERR |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 850 | lys_compile_unres_when(struct lysc_ctx *ctx, const struct lysc_node *node, struct lys_glob_unres *unres) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 851 | { |
| 852 | struct lyxp_set tmp_set; |
| 853 | uint32_t i, opts; |
| 854 | LY_ARRAY_COUNT_TYPE u; |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 855 | struct lysc_when **whens = NULL; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 856 | LY_ERR ret = LY_SUCCESS; |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 857 | const struct lys_module *mod; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 858 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 859 | LOG_LOCSET(node, NULL, NULL, NULL); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 860 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 861 | memset(&tmp_set, 0, sizeof tmp_set); |
Michal Vasko | d1e53b9 | 2021-01-28 13:11:06 +0100 | [diff] [blame] | 862 | opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 863 | |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 864 | whens = lysc_node_when(node); |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 865 | LY_ARRAY_FOR(whens, u) { |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 866 | /* first check whether all the referenced modules are implemented */ |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 867 | mod = NULL; |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 868 | ret = lys_compile_expr_implement(ctx->ctx, whens[u]->cond, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes, |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 869 | ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod); |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 870 | if (ret) { |
| 871 | goto cleanup; |
| 872 | } else if (mod) { |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 873 | LOGWRN(ctx->ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.", |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 874 | whens[u]->cond->expr, mod->name); |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 875 | continue; |
| 876 | } |
| 877 | |
| 878 | /* check "when" */ |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 879 | ret = lyxp_atomize(ctx->ctx, whens[u]->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes, |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 880 | whens[u]->context, &tmp_set, opts); |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 881 | if (ret) { |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 882 | LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", whens[u]->cond->expr); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 883 | goto cleanup; |
| 884 | } |
| 885 | |
| 886 | ctx->path[0] = '\0'; |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 887 | lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 888 | for (i = 0; i < tmp_set.used; ++i) { |
| 889 | /* skip roots'n'stuff */ |
Michal Vasko | 6b8c510 | 2021-10-19 11:29:32 +0200 | [diff] [blame] | 890 | if ((tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && |
| 891 | (tmp_set.val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START_USED)) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 892 | struct lysc_node *schema = tmp_set.val.scnodes[i].scnode; |
| 893 | |
| 894 | /* XPath expression cannot reference "lower" status than the node that has the definition */ |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 895 | ret = lysc_check_status(ctx, whens[u]->flags, node->module, node->name, schema->flags, schema->module, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 896 | schema->name); |
| 897 | LY_CHECK_GOTO(ret, cleanup); |
| 898 | |
Michal Vasko | 1a09b21 | 2021-05-06 13:00:10 +0200 | [diff] [blame] | 899 | /* check dummy node children/value accessing */ |
| 900 | if (lysc_data_parent(schema) == node) { |
| 901 | LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node children."); |
| 902 | ret = LY_EVALID; |
| 903 | goto cleanup; |
| 904 | } else if ((schema == node) && (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) { |
| 905 | LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node value."); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 906 | ret = LY_EVALID; |
| 907 | goto cleanup; |
| 908 | } |
| 909 | } |
| 910 | } |
| 911 | |
| 912 | /* check cyclic dependencies */ |
| 913 | ret = lys_compile_unres_when_cyclic(&tmp_set, node); |
| 914 | LY_CHECK_GOTO(ret, cleanup); |
| 915 | |
| 916 | lyxp_set_free_content(&tmp_set); |
| 917 | } |
| 918 | |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 919 | cleanup: |
| 920 | lyxp_set_free_content(&tmp_set); |
| 921 | LOG_LOCBACK(1, 0, 0, 0); |
| 922 | return ret; |
| 923 | } |
| 924 | |
| 925 | /** |
| 926 | * @brief Check must expressions of a node on a complete compiled schema tree. |
| 927 | * |
| 928 | * @param[in] ctx Compile context. |
| 929 | * @param[in] node Node to check. |
| 930 | * @param[in] local_mods Sized array of local modules for musts of @p node at the same index. |
| 931 | * @param[in,out] unres Global unres structure. |
| 932 | * @return LY_ERECOMPILE |
| 933 | * @return LY_ERR value |
| 934 | */ |
| 935 | static LY_ERR |
| 936 | lys_compile_unres_must(struct lysc_ctx *ctx, const struct lysc_node *node, const struct lysp_module **local_mods, |
| 937 | struct lys_glob_unres *unres) |
| 938 | { |
| 939 | struct lyxp_set tmp_set; |
| 940 | uint32_t i, opts; |
| 941 | LY_ARRAY_COUNT_TYPE u; |
| 942 | struct lysc_must *musts = NULL; |
| 943 | LY_ERR ret = LY_SUCCESS; |
| 944 | const struct lys_module *mod; |
| 945 | uint16_t flg; |
| 946 | |
| 947 | LOG_LOCSET(node, NULL, NULL, NULL); |
| 948 | |
| 949 | memset(&tmp_set, 0, sizeof tmp_set); |
| 950 | opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0); |
| 951 | |
| 952 | musts = lysc_node_musts(node); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 953 | LY_ARRAY_FOR(musts, u) { |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 954 | /* first check whether all the referenced modules are implemented */ |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 955 | mod = NULL; |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 956 | ret = lys_compile_expr_implement(ctx->ctx, musts[u].cond, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes, |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 957 | ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod); |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 958 | if (ret) { |
| 959 | goto cleanup; |
| 960 | } else if (mod) { |
Michal Vasko | cfaff23 | 2020-10-20 09:35:14 +0200 | [diff] [blame] | 961 | LOGWRN(ctx->ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.", |
| 962 | musts[u].cond->expr, mod->name); |
| 963 | continue; |
| 964 | } |
| 965 | |
| 966 | /* check "must" */ |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 967 | ret = lyxp_atomize(ctx->ctx, musts[u].cond, node->module, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes, node, |
Michal Vasko | 400e967 | 2021-01-11 13:39:17 +0100 | [diff] [blame] | 968 | &tmp_set, opts); |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 969 | if (ret) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 970 | LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 971 | goto cleanup; |
| 972 | } |
| 973 | |
| 974 | ctx->path[0] = '\0'; |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 975 | lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 976 | for (i = 0; i < tmp_set.used; ++i) { |
| 977 | /* skip roots'n'stuff */ |
| 978 | if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) { |
| 979 | /* XPath expression cannot reference "lower" status than the node that has the definition */ |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 980 | if (local_mods[u]->mod == node->module) { |
| 981 | /* use flags of the context node since the definition is local */ |
| 982 | flg = node->flags; |
| 983 | } else { |
| 984 | /* definition is foreign (deviation, refine), always current */ |
| 985 | flg = LYS_STATUS_CURR; |
| 986 | } |
| 987 | ret = lysc_check_status(ctx, flg, local_mods[u]->mod, node->name, tmp_set.val.scnodes[i].scnode->flags, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 988 | tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name); |
| 989 | LY_CHECK_GOTO(ret, cleanup); |
| 990 | } |
| 991 | } |
| 992 | |
| 993 | lyxp_set_free_content(&tmp_set); |
| 994 | } |
| 995 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 996 | cleanup: |
| 997 | lyxp_set_free_content(&tmp_set); |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 998 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 999 | return ret; |
| 1000 | } |
| 1001 | |
| 1002 | /** |
Michal Vasko | f4fa90d | 2021-11-11 15:05:19 +0100 | [diff] [blame] | 1003 | * @brief Remove all disabled bits/enums from a sized array. |
| 1004 | * |
| 1005 | * @param[in] ctx Context with the dictionary. |
| 1006 | * @param[in] items Sized array of bits/enums. |
| 1007 | */ |
| 1008 | static void |
| 1009 | lys_compile_unres_disabled_bitenum_remove(struct ly_ctx *ctx, struct lysc_type_bitenum_item *items) |
| 1010 | { |
| 1011 | LY_ARRAY_COUNT_TYPE u = 0, last_u; |
| 1012 | |
| 1013 | while (u < LY_ARRAY_COUNT(items)) { |
| 1014 | if (items[u].flags & LYS_DISABLED) { |
| 1015 | /* free the disabled item */ |
| 1016 | lysc_enum_item_free(ctx, &items[u]); |
| 1017 | |
| 1018 | /* replace it with the following items */ |
| 1019 | last_u = LY_ARRAY_COUNT(items) - 1; |
| 1020 | if (u < last_u) { |
| 1021 | memmove(items + u, items + u + 1, (last_u - u) * sizeof *items); |
| 1022 | } |
| 1023 | |
| 1024 | /* one item less */ |
| 1025 | LY_ARRAY_DECREMENT(items); |
| 1026 | continue; |
| 1027 | } |
| 1028 | |
| 1029 | ++u; |
| 1030 | } |
| 1031 | } |
| 1032 | |
| 1033 | /** |
| 1034 | * @brief Find and remove all disabled bits/enums in a leaf/leaf-list type. |
| 1035 | * |
| 1036 | * @param[in] ctx Compile context. |
| 1037 | * @param[in] leaf Leaf/leaf-list to check. |
| 1038 | * @return LY_ERR value |
| 1039 | */ |
| 1040 | static LY_ERR |
| 1041 | lys_compile_unres_disabled_bitenum(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf) |
| 1042 | { |
| 1043 | struct lysc_type **t; |
| 1044 | LY_ARRAY_COUNT_TYPE u, count; |
| 1045 | struct lysc_type_enum *ent; |
| 1046 | |
| 1047 | if (leaf->type->basetype == LY_TYPE_UNION) { |
| 1048 | t = ((struct lysc_type_union *)leaf->type)->types; |
| 1049 | count = LY_ARRAY_COUNT(t); |
| 1050 | } else { |
| 1051 | t = &leaf->type; |
| 1052 | count = 1; |
| 1053 | } |
| 1054 | for (u = 0; u < count; ++u) { |
| 1055 | if ((t[u]->basetype == LY_TYPE_BITS) || (t[u]->basetype == LY_TYPE_ENUM)) { |
| 1056 | /* remove all disabled items */ |
| 1057 | ent = (struct lysc_type_enum *)(t[u]); |
| 1058 | lys_compile_unres_disabled_bitenum_remove(ctx->ctx, ent->enums); |
| 1059 | |
| 1060 | if (!LY_ARRAY_COUNT(ent->enums)) { |
| 1061 | LOGVAL(ctx->ctx, LYVE_SEMANTICS, "%s type of node \"%s\" without any (or all disabled) valid values.", |
| 1062 | (ent->basetype == LY_TYPE_BITS) ? "Bits" : "Enumeration", leaf->name); |
| 1063 | return LY_EVALID; |
| 1064 | } |
| 1065 | } |
| 1066 | } |
| 1067 | |
| 1068 | return LY_SUCCESS; |
| 1069 | } |
| 1070 | |
| 1071 | /** |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1072 | * @brief Check leafref for its target existence on a complete compiled schema tree. |
| 1073 | * |
| 1074 | * @param[in] ctx Compile context. |
| 1075 | * @param[in] node Context node for the leafref. |
| 1076 | * @param[in] lref Leafref to check/resolve. |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1077 | * @param[in] local_mod Local module for the leafref type. |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1078 | * @param[in,out] unres Global unres structure. |
Michal Vasko | 40c158c | 2021-04-28 17:01:03 +0200 | [diff] [blame] | 1079 | * @return LY_ERECOMPILE if context recompilation is needed, |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1080 | * @return LY_ERR value. |
| 1081 | */ |
| 1082 | static LY_ERR |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1083 | lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref, |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1084 | const struct lysp_module *local_mod, struct lys_glob_unres *unres) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1085 | { |
Michal Vasko | d1e53b9 | 2021-01-28 13:11:06 +0100 | [diff] [blame] | 1086 | const struct lysc_node *target = NULL; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1087 | struct ly_path *p; |
| 1088 | struct lysc_type *type; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1089 | uint16_t flg; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1090 | |
| 1091 | assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST)); |
| 1092 | |
Michal Vasko | 24fc4d1 | 2021-07-12 14:41:20 +0200 | [diff] [blame] | 1093 | /* first implement all the modules in the path */ |
| 1094 | LY_CHECK_RET(lys_compile_expr_implement(ctx->ctx, lref->path, LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, 1, unres, NULL)); |
| 1095 | |
Michal Vasko | ed725d7 | 2021-06-23 12:03:45 +0200 | [diff] [blame] | 1096 | /* try to find the target, current module is that of the context node (RFC 7950 6.4.1 second bullet) */ |
| 1097 | LY_CHECK_RET(ly_path_compile_leafref(ctx->ctx, node, NULL, lref->path, |
Michal Vasko | d1e53b9 | 2021-01-28 13:11:06 +0100 | [diff] [blame] | 1098 | (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, |
Michal Vasko | 24fc4d1 | 2021-07-12 14:41:20 +0200 | [diff] [blame] | 1099 | LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p)); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1100 | |
| 1101 | /* get the target node */ |
| 1102 | target = p[LY_ARRAY_COUNT(p) - 1].node; |
| 1103 | ly_path_free(node->module->ctx, p); |
| 1104 | |
| 1105 | if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1106 | LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target node is %s instead of leaf or leaf-list.", |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1107 | lref->path->expr, lys_nodetype2str(target->nodetype)); |
| 1108 | return LY_EVALID; |
| 1109 | } |
| 1110 | |
| 1111 | /* check status */ |
| 1112 | ctx->path[0] = '\0'; |
| 1113 | lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE); |
| 1114 | ctx->path_len = strlen(ctx->path); |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1115 | if (node->module == local_mod->mod) { |
| 1116 | /* use flags of the context node since the definition is local */ |
| 1117 | flg = node->flags; |
| 1118 | } else { |
| 1119 | /* definition is foreign (deviation), always current */ |
| 1120 | flg = LYS_STATUS_CURR; |
| 1121 | } |
| 1122 | if (lysc_check_status(ctx, flg, local_mod->mod, node->name, target->flags, target->module, target->name)) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1123 | return LY_EVALID; |
| 1124 | } |
| 1125 | ctx->path_len = 1; |
| 1126 | ctx->path[1] = '\0'; |
| 1127 | |
| 1128 | /* check config */ |
| 1129 | if (lref->require_instance) { |
Michal Vasko | d1e53b9 | 2021-01-28 13:11:06 +0100 | [diff] [blame] | 1130 | if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1131 | LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed" |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1132 | " to represent configuration data (as the leafref does), but it does not.", lref->path->expr); |
| 1133 | return LY_EVALID; |
| 1134 | } |
| 1135 | } |
| 1136 | |
| 1137 | /* store the target's type and check for circular chain of leafrefs */ |
| 1138 | lref->realtype = ((struct lysc_node_leaf *)target)->type; |
| 1139 | for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) { |
| 1140 | if (type == (struct lysc_type *)lref) { |
| 1141 | /* circular chain detected */ |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1142 | LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.", |
| 1143 | lref->path->expr); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1144 | return LY_EVALID; |
| 1145 | } |
| 1146 | } |
| 1147 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1148 | return LY_SUCCESS; |
| 1149 | } |
| 1150 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1151 | /** |
| 1152 | * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree. |
| 1153 | * |
| 1154 | * @param[in] ctx Compile context. |
| 1155 | * @param[in] node Leaf or leaf-list to compile the default value(s) for. |
| 1156 | * @param[in] type Type of the default value. |
| 1157 | * @param[in] dflt Default value. |
| 1158 | * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes. |
| 1159 | * @param[in,out] storage Storage for the compiled default value. |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1160 | * @param[in,out] unres Global unres structure for newly implemented modules. |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1161 | * @return LY_ERR value. |
| 1162 | */ |
| 1163 | static LY_ERR |
| 1164 | lys_compile_unres_dflt(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc_type *type, const char *dflt, |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1165 | const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1166 | { |
| 1167 | LY_ERR ret; |
Michal Vasko | 25d6ad0 | 2020-10-22 12:20:22 +0200 | [diff] [blame] | 1168 | uint32_t options; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1169 | struct ly_err_item *err = NULL; |
| 1170 | |
Radek Krejci | 0b01330 | 2021-03-29 15:22:32 +0200 | [diff] [blame] | 1171 | options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0; |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 1172 | ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod, |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1173 | LYD_HINT_SCHEMA, node, storage, unres, &err); |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1174 | if (ret == LY_ERECOMPILE) { |
| 1175 | /* fine, but we need to recompile */ |
| 1176 | return LY_ERECOMPILE; |
| 1177 | } else if (ret == LY_EINCOMPLETE) { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1178 | /* we have no data so we will not be resolving it */ |
| 1179 | ret = LY_SUCCESS; |
| 1180 | } |
| 1181 | |
| 1182 | if (ret) { |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 1183 | LOG_LOCSET(node, NULL, NULL, NULL); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1184 | if (err) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1185 | LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1186 | ly_err_free(err); |
| 1187 | } else { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1188 | LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type."); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1189 | } |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 1190 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1191 | return ret; |
| 1192 | } |
| 1193 | |
Michal Vasko | 04338d9 | 2021-09-01 07:58:14 +0200 | [diff] [blame] | 1194 | LY_ATOMIC_INC_BARRIER(((struct lysc_type *)storage->realtype)->refcount); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1195 | return LY_SUCCESS; |
| 1196 | } |
| 1197 | |
| 1198 | /** |
| 1199 | * @brief Compile default value of a leaf expecting a complete compiled schema tree. |
| 1200 | * |
| 1201 | * @param[in] ctx Compile context. |
| 1202 | * @param[in] leaf Leaf that the default value is for. |
| 1203 | * @param[in] dflt Default value to compile. |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1204 | * @param[in,out] unres Global unres structure for newly implemented modules. |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1205 | * @return LY_ERR value. |
| 1206 | */ |
| 1207 | static LY_ERR |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1208 | lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt, |
| 1209 | struct lys_glob_unres *unres) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1210 | { |
| 1211 | LY_ERR ret; |
| 1212 | |
| 1213 | assert(!leaf->dflt); |
| 1214 | |
| 1215 | if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) { |
| 1216 | /* ignore default values for keys and mandatory leaves */ |
| 1217 | return LY_SUCCESS; |
| 1218 | } |
| 1219 | |
| 1220 | /* allocate the default value */ |
| 1221 | leaf->dflt = calloc(1, sizeof *leaf->dflt); |
| 1222 | LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM); |
| 1223 | |
| 1224 | /* store the default value */ |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 1225 | ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1226 | if (ret) { |
| 1227 | free(leaf->dflt); |
| 1228 | leaf->dflt = NULL; |
| 1229 | } |
| 1230 | |
| 1231 | return ret; |
| 1232 | } |
| 1233 | |
| 1234 | /** |
| 1235 | * @brief Compile default values of a leaf-list expecting a complete compiled schema tree. |
| 1236 | * |
| 1237 | * @param[in] ctx Compile context. |
| 1238 | * @param[in] llist Leaf-list that the default value(s) are for. |
| 1239 | * @param[in] dflt Default value to compile, in case of a single value. |
| 1240 | * @param[in] dflts Sized array of default values, in case of more values. |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1241 | * @param[in,out] unres Global unres structure for newly implemented modules. |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1242 | * @return LY_ERR value. |
| 1243 | */ |
| 1244 | static LY_ERR |
| 1245 | lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt, |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1246 | struct lysp_qname *dflts, struct lys_glob_unres *unres) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1247 | { |
| 1248 | LY_ERR ret; |
| 1249 | LY_ARRAY_COUNT_TYPE orig_count, u, v; |
| 1250 | |
| 1251 | assert(dflt || dflts); |
| 1252 | |
Radek Krejci | c7d13e3 | 2020-12-09 12:32:24 +0100 | [diff] [blame] | 1253 | /* in case there were already some defaults and we are adding new by deviations */ |
| 1254 | orig_count = LY_ARRAY_COUNT(llist->dflts); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1255 | |
| 1256 | /* allocate new items */ |
Radek Krejci | c7d13e3 | 2020-12-09 12:32:24 +0100 | [diff] [blame] | 1257 | LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, orig_count + (dflts ? LY_ARRAY_COUNT(dflts) : 1), LY_EMEM); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1258 | |
| 1259 | /* fill each new default value */ |
| 1260 | if (dflts) { |
| 1261 | LY_ARRAY_FOR(dflts, u) { |
| 1262 | llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts); |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 1263 | ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod, |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1264 | llist->dflts[orig_count + u], unres); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1265 | LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret); |
| 1266 | LY_ARRAY_INCREMENT(llist->dflts); |
| 1267 | } |
| 1268 | } else { |
| 1269 | llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts); |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 1270 | ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod, |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1271 | llist->dflts[orig_count], unres); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1272 | LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret); |
| 1273 | LY_ARRAY_INCREMENT(llist->dflts); |
| 1274 | } |
| 1275 | |
| 1276 | /* check default value uniqueness */ |
| 1277 | if (llist->flags & LYS_CONFIG_W) { |
| 1278 | /* configuration data values must be unique - so check the default values */ |
| 1279 | for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) { |
| 1280 | for (v = 0; v < u; ++v) { |
| 1281 | if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) { |
Radek Krejci | a601699 | 2021-03-03 10:13:41 +0100 | [diff] [blame] | 1282 | lysc_update_path(ctx, llist->parent ? llist->parent->module : NULL, llist->name); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1283 | LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".", |
Radek Krejci | 6d5ba0c | 2021-04-26 07:49:59 +0200 | [diff] [blame] | 1284 | llist->dflts[u]->realtype->plugin->print(ctx->ctx, llist->dflts[u], LY_VALUE_CANON, NULL, NULL, NULL)); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1285 | lysc_update_path(ctx, NULL, NULL); |
| 1286 | return LY_EVALID; |
| 1287 | } |
| 1288 | } |
| 1289 | } |
| 1290 | } |
| 1291 | |
| 1292 | return LY_SUCCESS; |
| 1293 | } |
| 1294 | |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1295 | /** |
aPiecek | 732cd14 | 2021-07-07 16:29:59 +0200 | [diff] [blame] | 1296 | * @brief Iteratively get all leafrefs from @p node |
| 1297 | * if the node is of type union, otherwise just return the leafref. |
| 1298 | * |
| 1299 | * @param[in] node Node that may contain the leafref. |
| 1300 | * @param[in,out] index Value that is passed between function calls. |
| 1301 | * For each new node, initialize value of the @p index to 0, otherwise |
| 1302 | * do not modify the value between calls. |
| 1303 | * @return Pointer to the leafref or next leafref, otherwise NULL. |
| 1304 | */ |
| 1305 | static struct lysc_type_leafref * |
| 1306 | lys_type_leafref_next(const struct lysc_node *node, uint64_t *index) |
| 1307 | { |
| 1308 | struct lysc_type_leafref *ret = NULL; |
| 1309 | struct lysc_type_union *uni; |
| 1310 | struct lysc_type *leaf_type; |
| 1311 | |
| 1312 | assert(node->nodetype & LYD_NODE_TERM); |
| 1313 | |
| 1314 | leaf_type = ((struct lysc_node_leaf *)node)->type; |
| 1315 | if (leaf_type->basetype == LY_TYPE_UNION) { |
| 1316 | uni = (struct lysc_type_union *)leaf_type; |
| 1317 | |
| 1318 | /* find next union leafref */ |
| 1319 | while (*index < LY_ARRAY_COUNT(uni->types)) { |
| 1320 | if (uni->types[*index]->basetype == LY_TYPE_LEAFREF) { |
| 1321 | ret = (struct lysc_type_leafref *)uni->types[*index]; |
| 1322 | ++(*index); |
| 1323 | break; |
| 1324 | } |
| 1325 | |
| 1326 | ++(*index); |
| 1327 | } |
| 1328 | } else { |
| 1329 | /* return just the single leafref */ |
| 1330 | if (*index == 0) { |
| 1331 | ++(*index); |
| 1332 | assert(leaf_type->basetype == LY_TYPE_LEAFREF); |
| 1333 | ret = (struct lysc_type_leafref *)leaf_type; |
| 1334 | } |
| 1335 | } |
| 1336 | |
| 1337 | return ret; |
| 1338 | } |
| 1339 | |
| 1340 | /** |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1341 | * @brief Finish dependency set compilation by resolving all the unres sets. |
| 1342 | * |
| 1343 | * @param[in] ctx libyang context. |
| 1344 | * @param[in] unres Global unres structure with the sets to resolve. |
| 1345 | * @return LY_SUCCESS on success. |
| 1346 | * @return LY_ERECOMPILE if the dep set needs to be recompiled. |
| 1347 | * @return LY_ERR value on error. |
| 1348 | */ |
| 1349 | static LY_ERR |
| 1350 | lys_compile_unres_depset(struct ly_ctx *ctx, struct lys_glob_unres *unres) |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1351 | { |
aPiecek | 732cd14 | 2021-07-07 16:29:59 +0200 | [diff] [blame] | 1352 | LY_ERR ret = LY_SUCCESS; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1353 | struct lysc_node *node; |
aPiecek | 732cd14 | 2021-07-07 16:29:59 +0200 | [diff] [blame] | 1354 | struct lysc_type *typeiter; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1355 | struct lysc_type_leafref *lref; |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1356 | struct lysc_ctx cctx; |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1357 | struct lys_depset_unres *ds_unres; |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1358 | struct ly_path *path; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1359 | LY_ARRAY_COUNT_TYPE v; |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1360 | struct lysc_unres_leafref *l; |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1361 | uint32_t i, processed_leafrefs = 0; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1362 | |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1363 | ds_unres = &unres->ds_unres; |
| 1364 | |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1365 | /* fake compile context */ |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1366 | resolve_all: |
| 1367 | memset(&cctx, 0, sizeof cctx); |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1368 | cctx.ctx = ctx; |
| 1369 | cctx.path_len = 1; |
| 1370 | cctx.path[0] = '/'; |
| 1371 | |
| 1372 | /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which |
| 1373 | * can be also leafref, in case it is already resolved, go through the chain and check that it does not |
aPiecek | c6526b4 | 2021-07-12 15:21:39 +0200 | [diff] [blame] | 1374 | * point to the starting leafref type). The second round stores the first non-leafref type for later data validation. |
| 1375 | * Also do the same check for set of the disabled leafrefs, but without the second round. */ |
| 1376 | while (ds_unres->disabled_leafrefs.count) { |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1377 | /* remember index, it can change before we get to free this item */ |
| 1378 | i = ds_unres->disabled_leafrefs.count - 1; |
| 1379 | l = ds_unres->disabled_leafrefs.objs[i]; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1380 | cctx.cur_mod = l->node->module; |
| 1381 | cctx.pmod = l->node->module->parsed; |
aPiecek | c6526b4 | 2021-07-12 15:21:39 +0200 | [diff] [blame] | 1382 | |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1383 | LOG_LOCSET(l->node, NULL, NULL, NULL); |
aPiecek | c6526b4 | 2021-07-12 15:21:39 +0200 | [diff] [blame] | 1384 | v = 0; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1385 | while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) { |
| 1386 | ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod, unres); |
aPiecek | c6526b4 | 2021-07-12 15:21:39 +0200 | [diff] [blame] | 1387 | } |
aPiecek | c6526b4 | 2021-07-12 15:21:39 +0200 | [diff] [blame] | 1388 | LOG_LOCBACK(1, 0, 0, 0); |
| 1389 | LY_CHECK_RET(ret); |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1390 | |
| 1391 | ly_set_rm_index(&ds_unres->disabled_leafrefs, i, free); |
aPiecek | c6526b4 | 2021-07-12 15:21:39 +0200 | [diff] [blame] | 1392 | } |
Michal Vasko | a23e1d9 | 2021-07-13 12:04:16 +0200 | [diff] [blame] | 1393 | |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1394 | for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) { |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1395 | l = ds_unres->leafrefs.objs[i]; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1396 | cctx.cur_mod = l->node->module; |
| 1397 | cctx.pmod = l->node->module->parsed; |
| 1398 | LOG_LOCSET(l->node, NULL, NULL, NULL); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1399 | |
aPiecek | 732cd14 | 2021-07-07 16:29:59 +0200 | [diff] [blame] | 1400 | v = 0; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1401 | while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) { |
| 1402 | ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod, unres); |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1403 | } |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1404 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 1405 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 7213ac5 | 2021-06-15 11:52:13 +0200 | [diff] [blame] | 1406 | LY_CHECK_RET(ret); |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1407 | } |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1408 | for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) { |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1409 | l = ds_unres->leafrefs.objs[i]; |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1410 | |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1411 | /* store pointer to the real type */ |
aPiecek | 732cd14 | 2021-07-07 16:29:59 +0200 | [diff] [blame] | 1412 | v = 0; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1413 | while ((lref = lys_type_leafref_next(l->node, &v))) { |
aPiecek | 732cd14 | 2021-07-07 16:29:59 +0200 | [diff] [blame] | 1414 | for (typeiter = lref->realtype; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1415 | typeiter->basetype == LY_TYPE_LEAFREF; |
| 1416 | typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {} |
aPiecek | 732cd14 | 2021-07-07 16:29:59 +0200 | [diff] [blame] | 1417 | lref->realtype = typeiter; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1418 | } |
| 1419 | |
Michal Vasko | a23e1d9 | 2021-07-13 12:04:16 +0200 | [diff] [blame] | 1420 | /* If 'goto' will be used on the 'resolve_all' label, then |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1421 | * the current leafref will not be processed again. |
| 1422 | */ |
| 1423 | processed_leafrefs++; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1424 | } |
| 1425 | |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1426 | /* check when */ |
| 1427 | while (ds_unres->whens.count) { |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1428 | i = ds_unres->whens.count - 1; |
| 1429 | node = ds_unres->whens.objs[i]; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1430 | cctx.cur_mod = node->module; |
| 1431 | cctx.pmod = node->module->parsed; |
| 1432 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 1433 | LOG_LOCSET(node, NULL, NULL, NULL); |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1434 | ret = lys_compile_unres_when(&cctx, node, unres); |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 1435 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 7213ac5 | 2021-06-15 11:52:13 +0200 | [diff] [blame] | 1436 | LY_CHECK_RET(ret); |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1437 | |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1438 | ly_set_rm_index(&ds_unres->whens, i, NULL); |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1439 | } |
| 1440 | |
| 1441 | /* check must */ |
| 1442 | while (ds_unres->musts.count) { |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1443 | i = ds_unres->musts.count - 1; |
| 1444 | struct lysc_unres_must *m = ds_unres->musts.objs[i]; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1445 | cctx.cur_mod = m->node->module; |
| 1446 | cctx.pmod = m->node->module->parsed; |
| 1447 | |
| 1448 | LOG_LOCSET(m->node, NULL, NULL, NULL); |
| 1449 | ret = lys_compile_unres_must(&cctx, m->node, m->local_mods, unres); |
| 1450 | LOG_LOCBACK(1, 0, 0, 0); |
| 1451 | LY_CHECK_RET(ret); |
| 1452 | |
| 1453 | lysc_unres_must_free(m); |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1454 | ly_set_rm_index(&ds_unres->musts, i, NULL); |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1455 | } |
| 1456 | |
Michal Vasko | f4fa90d | 2021-11-11 15:05:19 +0100 | [diff] [blame] | 1457 | /* remove disabled enums/bits */ |
Michal Vasko | cc2d75e | 2021-11-22 15:58:26 +0100 | [diff] [blame] | 1458 | while (ds_unres->disabled_bitenums.count) { |
| 1459 | i = ds_unres->disabled_bitenums.count - 1; |
Michal Vasko | f4fa90d | 2021-11-11 15:05:19 +0100 | [diff] [blame] | 1460 | node = ds_unres->disabled_bitenums.objs[i]; |
| 1461 | cctx.cur_mod = node->module; |
| 1462 | cctx.pmod = node->module->parsed; |
| 1463 | |
| 1464 | LOG_LOCSET(node, NULL, NULL, NULL); |
| 1465 | ret = lys_compile_unres_disabled_bitenum(&cctx, (struct lysc_node_leaf *)node); |
| 1466 | LOG_LOCBACK(1, 0, 0, 0); |
| 1467 | LY_CHECK_RET(ret); |
| 1468 | |
| 1469 | ly_set_rm_index(&ds_unres->disabled_bitenums, i, NULL); |
| 1470 | } |
| 1471 | |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1472 | /* finish incomplete default values compilation */ |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1473 | while (ds_unres->dflts.count) { |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1474 | i = ds_unres->dflts.count - 1; |
| 1475 | struct lysc_unres_dflt *r = ds_unres->dflts.objs[i]; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1476 | cctx.cur_mod = r->leaf->module; |
| 1477 | cctx.pmod = r->leaf->module->parsed; |
| 1478 | |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 1479 | LOG_LOCSET(&r->leaf->node, NULL, NULL, NULL); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1480 | if (r->leaf->nodetype == LYS_LEAF) { |
| 1481 | ret = lys_compile_unres_leaf_dlft(&cctx, r->leaf, r->dflt, unres); |
| 1482 | } else { |
| 1483 | ret = lys_compile_unres_llist_dflts(&cctx, r->llist, r->dflt, r->dflts, unres); |
| 1484 | } |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 1485 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 7213ac5 | 2021-06-15 11:52:13 +0200 | [diff] [blame] | 1486 | LY_CHECK_RET(ret); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1487 | |
| 1488 | lysc_unres_dflt_free(ctx, r); |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1489 | ly_set_rm_index(&ds_unres->dflts, i, NULL); |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1490 | } |
| 1491 | |
Michal Vasko | 40c158c | 2021-04-28 17:01:03 +0200 | [diff] [blame] | 1492 | /* some unres items may have been added */ |
aPiecek | c6526b4 | 2021-07-12 15:21:39 +0200 | [diff] [blame] | 1493 | if ((processed_leafrefs != ds_unres->leafrefs.count) || ds_unres->disabled_leafrefs.count || |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1494 | ds_unres->whens.count || ds_unres->musts.count || ds_unres->dflts.count) { |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1495 | goto resolve_all; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1496 | } |
| 1497 | |
Michal Vasko | 30ab8e7 | 2021-04-19 12:47:52 +0200 | [diff] [blame] | 1498 | /* finally, remove all disabled nodes */ |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1499 | for (i = 0; i < ds_unres->disabled.count; ++i) { |
| 1500 | node = ds_unres->disabled.snodes[i]; |
Michal Vasko | 30ab8e7 | 2021-04-19 12:47:52 +0200 | [diff] [blame] | 1501 | if (node->flags & LYS_KEY) { |
| 1502 | LOG_LOCSET(node, NULL, NULL, NULL); |
Michal Vasko | e02e740 | 2021-07-23 08:29:28 +0200 | [diff] [blame] | 1503 | LOGVAL(ctx, LYVE_REFERENCE, "Key \"%s\" is disabled.", node->name); |
Michal Vasko | 30ab8e7 | 2021-04-19 12:47:52 +0200 | [diff] [blame] | 1504 | LOG_LOCBACK(1, 0, 0, 0); |
| 1505 | return LY_EVALID; |
| 1506 | } |
| 1507 | |
| 1508 | lysc_node_free(ctx, node, 1); |
| 1509 | } |
| 1510 | |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1511 | /* also check if the leafref target has not been disabled */ |
| 1512 | for (i = 0; i < ds_unres->leafrefs.count; ++i) { |
Michal Vasko | a91d87e | 2021-10-19 11:58:57 +0200 | [diff] [blame] | 1513 | l = ds_unres->leafrefs.objs[i]; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1514 | cctx.cur_mod = l->node->module; |
| 1515 | cctx.pmod = l->node->module->parsed; |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1516 | |
| 1517 | v = 0; |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1518 | while ((lref = lys_type_leafref_next(l->node, &v))) { |
| 1519 | ret = ly_path_compile_leafref(cctx.ctx, l->node, NULL, lref->path, |
| 1520 | (l->node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1521 | LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &path); |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1522 | ly_path_free(l->node->module->ctx, path); |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1523 | |
| 1524 | assert(ret != LY_ERECOMPILE); |
| 1525 | if (ret) { |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1526 | LOG_LOCSET(l->node, NULL, NULL, NULL); |
Michal Vasko | e02e740 | 2021-07-23 08:29:28 +0200 | [diff] [blame] | 1527 | LOGVAL(ctx, LYVE_REFERENCE, "Target of leafref \"%s\" cannot be referenced because it is disabled.", |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1528 | l->node->name); |
aPiecek | d7bd52d | 2021-07-08 08:59:59 +0200 | [diff] [blame] | 1529 | LOG_LOCBACK(1, 0, 0, 0); |
| 1530 | return LY_EVALID; |
| 1531 | } |
| 1532 | } |
| 1533 | } |
| 1534 | |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1535 | return LY_SUCCESS; |
| 1536 | } |
| 1537 | |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1538 | /** |
| 1539 | * @brief Erase dep set unres. |
| 1540 | * |
| 1541 | * @param[in] ctx libyang context. |
| 1542 | * @param[in] unres Global unres structure with the sets to resolve. |
| 1543 | */ |
| 1544 | static void |
| 1545 | lys_compile_unres_depset_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres) |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1546 | { |
| 1547 | uint32_t i; |
| 1548 | |
Michal Vasko | c130e16 | 2021-10-19 11:30:00 +0200 | [diff] [blame] | 1549 | ly_set_erase(&unres->ds_unres.whens, NULL); |
| 1550 | for (i = 0; i < unres->ds_unres.musts.count; ++i) { |
| 1551 | lysc_unres_must_free(unres->ds_unres.musts.objs[i]); |
| 1552 | } |
| 1553 | ly_set_erase(&unres->ds_unres.musts, NULL); |
| 1554 | ly_set_erase(&unres->ds_unres.leafrefs, free); |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1555 | for (i = 0; i < unres->ds_unres.dflts.count; ++i) { |
| 1556 | lysc_unres_dflt_free(ctx, unres->ds_unres.dflts.objs[i]); |
Michal Vasko | df6319c | 2021-06-10 14:41:05 +0200 | [diff] [blame] | 1557 | } |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1558 | ly_set_erase(&unres->ds_unres.dflts, NULL); |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1559 | ly_set_erase(&unres->ds_unres.disabled, NULL); |
Michal Vasko | f4fa90d | 2021-11-11 15:05:19 +0100 | [diff] [blame] | 1560 | ly_set_erase(&unres->ds_unres.disabled_leafrefs, free); |
| 1561 | ly_set_erase(&unres->ds_unres.disabled_bitenums, NULL); |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1562 | } |
| 1563 | |
Michal Vasko | 709f9a5 | 2021-07-21 10:51:59 +0200 | [diff] [blame] | 1564 | /** |
| 1565 | * @brief Compile all flagged modules in a dependency set, recursively if recompilation is needed. |
| 1566 | * |
| 1567 | * @param[in] ctx libyang context. |
| 1568 | * @param[in] dep_set Dependency set to compile. |
| 1569 | * @param[in,out] unres Global unres to use. |
| 1570 | * @return LY_ERR value. |
| 1571 | */ |
| 1572 | static LY_ERR |
| 1573 | lys_compile_depset_r(struct ly_ctx *ctx, struct ly_set *dep_set, struct lys_glob_unres *unres) |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1574 | { |
| 1575 | LY_ERR ret = LY_SUCCESS; |
| 1576 | struct lys_module *mod; |
| 1577 | uint32_t i; |
| 1578 | |
| 1579 | for (i = 0; i < dep_set->count; ++i) { |
| 1580 | mod = dep_set->objs[i]; |
| 1581 | if (!mod->to_compile) { |
| 1582 | /* skip */ |
| 1583 | continue; |
| 1584 | } |
| 1585 | assert(mod->implemented); |
| 1586 | |
| 1587 | /* free the compiled module, if any */ |
| 1588 | lysc_module_free(mod->compiled); |
| 1589 | mod->compiled = NULL; |
| 1590 | |
| 1591 | /* (re)compile the module */ |
| 1592 | LY_CHECK_GOTO(ret = lys_compile(mod, &unres->ds_unres), cleanup); |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1593 | } |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1594 | |
| 1595 | /* resolve dep set unres */ |
| 1596 | ret = lys_compile_unres_depset(ctx, unres); |
| 1597 | if (ret == LY_ERECOMPILE) { |
| 1598 | /* new module is implemented, discard current dep set unres and recompile the whole dep set */ |
| 1599 | lys_compile_unres_depset_erase(ctx, unres); |
Michal Vasko | 709f9a5 | 2021-07-21 10:51:59 +0200 | [diff] [blame] | 1600 | return lys_compile_depset_r(ctx, dep_set, unres); |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1601 | } else if (ret) { |
| 1602 | /* error */ |
| 1603 | goto cleanup; |
| 1604 | } |
| 1605 | |
| 1606 | /* success, unset the flags of all the modules in the dep set */ |
| 1607 | for (i = 0; i < dep_set->count; ++i) { |
| 1608 | mod = dep_set->objs[i]; |
| 1609 | mod->to_compile = 0; |
| 1610 | } |
| 1611 | |
| 1612 | cleanup: |
| 1613 | lys_compile_unres_depset_erase(ctx, unres); |
| 1614 | return ret; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1615 | } |
| 1616 | |
Michal Vasko | 45092a9 | 2022-02-08 15:07:44 +0100 | [diff] [blame] | 1617 | /** |
| 1618 | * @brief Check if-feature of all features of all modules in a dep set. |
| 1619 | * |
| 1620 | * @param[in] dep_set Dep set to check. |
| 1621 | * @return LY_ERR value. |
| 1622 | */ |
| 1623 | static LY_ERR |
| 1624 | lys_compile_depset_check_features(struct ly_set *dep_set) |
| 1625 | { |
| 1626 | struct lys_module *mod; |
| 1627 | uint32_t i; |
| 1628 | |
| 1629 | for (i = 0; i < dep_set->count; ++i) { |
| 1630 | mod = dep_set->objs[i]; |
| 1631 | if (!mod->to_compile) { |
| 1632 | /* skip */ |
| 1633 | continue; |
| 1634 | } |
| 1635 | |
| 1636 | /* check features of this module */ |
| 1637 | LY_CHECK_RET(lys_check_features(mod->parsed)); |
| 1638 | } |
| 1639 | |
| 1640 | return LY_SUCCESS; |
| 1641 | } |
| 1642 | |
Michal Vasko | 709f9a5 | 2021-07-21 10:51:59 +0200 | [diff] [blame] | 1643 | LY_ERR |
| 1644 | lys_compile_depset_all(struct ly_ctx *ctx, struct lys_glob_unres *unres) |
| 1645 | { |
| 1646 | uint32_t i; |
| 1647 | |
| 1648 | for (i = 0; i < unres->dep_sets.count; ++i) { |
Michal Vasko | 45092a9 | 2022-02-08 15:07:44 +0100 | [diff] [blame] | 1649 | LY_CHECK_RET(lys_compile_depset_check_features(unres->dep_sets.objs[i])); |
Michal Vasko | 709f9a5 | 2021-07-21 10:51:59 +0200 | [diff] [blame] | 1650 | LY_CHECK_RET(lys_compile_depset_r(ctx, unres->dep_sets.objs[i], unres)); |
| 1651 | } |
| 1652 | |
| 1653 | return LY_SUCCESS; |
| 1654 | } |
| 1655 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1656 | /** |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1657 | * @brief Finish compilation of all the module unres sets in a compile context. |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1658 | * |
| 1659 | * @param[in] ctx Compile context with unres sets. |
| 1660 | * @return LY_ERR value. |
| 1661 | */ |
| 1662 | static LY_ERR |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1663 | lys_compile_unres_mod(struct lysc_ctx *ctx) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1664 | { |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1665 | struct lysc_augment *aug; |
| 1666 | struct lysc_deviation *dev; |
Michal Vasko | 1ade6f1 | 2021-04-19 11:32:45 +0200 | [diff] [blame] | 1667 | struct lys_module *orig_mod = ctx->cur_mod; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1668 | uint32_t i; |
| 1669 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1670 | /* check that all augments were applied */ |
| 1671 | for (i = 0; i < ctx->augs.count; ++i) { |
| 1672 | aug = ctx->augs.objs[i]; |
Michal Vasko | 1ade6f1 | 2021-04-19 11:32:45 +0200 | [diff] [blame] | 1673 | ctx->cur_mod = aug->aug_pmod->mod; |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1674 | lysc_update_path(ctx, NULL, "{augment}"); |
| 1675 | lysc_update_path(ctx, NULL, aug->nodeid->expr); |
| 1676 | LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment target node \"%s\" from module \"%s\" was not found.", |
Michal Vasko | 28fe5f6 | 2021-03-03 16:37:39 +0100 | [diff] [blame] | 1677 | aug->nodeid->expr, LYSP_MODULE_NAME(aug->aug_pmod)); |
Michal Vasko | 1ade6f1 | 2021-04-19 11:32:45 +0200 | [diff] [blame] | 1678 | ctx->cur_mod = orig_mod; |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1679 | lysc_update_path(ctx, NULL, NULL); |
| 1680 | lysc_update_path(ctx, NULL, NULL); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1681 | } |
| 1682 | if (ctx->augs.count) { |
| 1683 | return LY_ENOTFOUND; |
| 1684 | } |
| 1685 | |
| 1686 | /* check that all deviations were applied */ |
| 1687 | for (i = 0; i < ctx->devs.count; ++i) { |
| 1688 | dev = ctx->devs.objs[i]; |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1689 | lysc_update_path(ctx, NULL, "{deviation}"); |
| 1690 | lysc_update_path(ctx, NULL, dev->nodeid->expr); |
| 1691 | LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.", |
| 1692 | dev->nodeid->expr, LYSP_MODULE_NAME(dev->dev_pmods[0])); |
| 1693 | lysc_update_path(ctx, NULL, NULL); |
| 1694 | lysc_update_path(ctx, NULL, NULL); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1695 | } |
| 1696 | if (ctx->devs.count) { |
| 1697 | return LY_ENOTFOUND; |
| 1698 | } |
| 1699 | |
| 1700 | return LY_SUCCESS; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1701 | } |
| 1702 | |
| 1703 | /** |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1704 | * @brief Erase all the module unres sets in a compile context. |
| 1705 | * |
| 1706 | * @param[in] ctx Compile context with unres sets. |
| 1707 | * @param[in] error Whether the compilation finished with an error or not. |
| 1708 | */ |
| 1709 | static void |
| 1710 | lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error) |
| 1711 | { |
| 1712 | uint32_t i; |
| 1713 | |
| 1714 | ly_set_erase(&ctx->groupings, NULL); |
| 1715 | ly_set_erase(&ctx->tpdf_chain, NULL); |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1716 | |
| 1717 | if (!error) { |
| 1718 | /* there can be no leftover deviations or augments */ |
| 1719 | LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), ); |
| 1720 | LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), ); |
| 1721 | |
| 1722 | ly_set_erase(&ctx->augs, NULL); |
| 1723 | ly_set_erase(&ctx->devs, NULL); |
| 1724 | ly_set_erase(&ctx->uses_augs, NULL); |
| 1725 | ly_set_erase(&ctx->uses_rfns, NULL); |
| 1726 | } else { |
| 1727 | for (i = 0; i < ctx->augs.count; ++i) { |
| 1728 | lysc_augment_free(ctx->ctx, ctx->augs.objs[i]); |
| 1729 | } |
| 1730 | ly_set_erase(&ctx->augs, NULL); |
| 1731 | for (i = 0; i < ctx->devs.count; ++i) { |
| 1732 | lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]); |
| 1733 | } |
| 1734 | ly_set_erase(&ctx->devs, NULL); |
| 1735 | for (i = 0; i < ctx->uses_augs.count; ++i) { |
| 1736 | lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]); |
| 1737 | } |
| 1738 | ly_set_erase(&ctx->uses_augs, NULL); |
| 1739 | for (i = 0; i < ctx->uses_rfns.count; ++i) { |
| 1740 | lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]); |
| 1741 | } |
| 1742 | ly_set_erase(&ctx->uses_rfns, NULL); |
| 1743 | } |
| 1744 | } |
| 1745 | |
Michal Vasko | d39bea4 | 2021-06-14 10:42:49 +0200 | [diff] [blame] | 1746 | LY_ERR |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1747 | lys_compile(struct lys_module *mod, struct lys_depset_unres *unres) |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1748 | { |
| 1749 | struct lysc_ctx ctx = {0}; |
Michal Vasko | 0b395e1 | 2021-04-23 13:43:07 +0200 | [diff] [blame] | 1750 | struct lysc_module *mod_c = NULL; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1751 | struct lysp_module *sp; |
| 1752 | struct lysp_submodule *submod; |
| 1753 | struct lysp_node *pnode; |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1754 | struct lysp_node_grp *grp; |
| 1755 | LY_ARRAY_COUNT_TYPE u; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1756 | LY_ERR ret = LY_SUCCESS; |
| 1757 | |
| 1758 | LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL); |
| 1759 | |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1760 | assert(mod->implemented && mod->to_compile); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1761 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1762 | sp = mod->parsed; |
| 1763 | |
| 1764 | ctx.ctx = mod->ctx; |
| 1765 | ctx.cur_mod = mod; |
| 1766 | ctx.pmod = sp; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1767 | ctx.path_len = 1; |
| 1768 | ctx.path[0] = '/'; |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1769 | ctx.unres = unres; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1770 | |
Michal Vasko | 0b395e1 | 2021-04-23 13:43:07 +0200 | [diff] [blame] | 1771 | ++mod->ctx->change_count; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1772 | mod->compiled = mod_c = calloc(1, sizeof *mod_c); |
| 1773 | LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM); |
| 1774 | mod_c->mod = mod; |
| 1775 | |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1776 | /* compile augments and deviations of our module from other modules so they can be applied during compilation */ |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1777 | LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), cleanup); |
| 1778 | LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1779 | |
| 1780 | /* data nodes */ |
| 1781 | LY_LIST_FOR(sp->data, pnode) { |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1782 | LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1783 | } |
| 1784 | |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1785 | /* top-level RPCs */ |
| 1786 | LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) { |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1787 | LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup); |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1788 | } |
| 1789 | |
| 1790 | /* top-level notifications */ |
| 1791 | LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) { |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1792 | LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup); |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1793 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1794 | |
| 1795 | /* extension instances */ |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1796 | COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, ret, cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1797 | |
| 1798 | /* the same for submodules */ |
| 1799 | LY_ARRAY_FOR(sp->includes, u) { |
| 1800 | submod = sp->includes[u].submodule; |
| 1801 | ctx.pmod = (struct lysp_module *)submod; |
| 1802 | |
| 1803 | LY_LIST_FOR(submod->data, pnode) { |
| 1804 | ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL); |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1805 | LY_CHECK_GOTO(ret, cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1806 | } |
| 1807 | |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1808 | LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) { |
| 1809 | ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL); |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1810 | LY_CHECK_GOTO(ret, cleanup); |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1811 | } |
| 1812 | |
| 1813 | LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) { |
| 1814 | ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL); |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1815 | LY_CHECK_GOTO(ret, cleanup); |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1816 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1817 | |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1818 | COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, ret, cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1819 | } |
Michal Vasko | 12606ee | 2020-11-25 17:05:11 +0100 | [diff] [blame] | 1820 | ctx.pmod = sp; |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1821 | |
| 1822 | /* validate non-instantiated groupings from the parsed schema, |
| 1823 | * without it we would accept even the schemas with invalid grouping specification */ |
Michal Vasko | 7c56592 | 2021-06-10 14:58:27 +0200 | [diff] [blame] | 1824 | ctx.compile_opts |= LYS_COMPILE_GROUPING; |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1825 | LY_LIST_FOR(sp->groupings, grp) { |
| 1826 | if (!(grp->flags & LYS_USED_GRP)) { |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1827 | LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1828 | } |
| 1829 | } |
| 1830 | LY_LIST_FOR(sp->data, pnode) { |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1831 | LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) { |
| 1832 | if (!(grp->flags & LYS_USED_GRP)) { |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1833 | LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1834 | } |
| 1835 | } |
| 1836 | } |
| 1837 | LY_ARRAY_FOR(sp->includes, u) { |
| 1838 | submod = sp->includes[u].submodule; |
| 1839 | ctx.pmod = (struct lysp_module *)submod; |
| 1840 | |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1841 | LY_LIST_FOR(submod->groupings, grp) { |
| 1842 | if (!(grp->flags & LYS_USED_GRP)) { |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1843 | LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1844 | } |
| 1845 | } |
| 1846 | LY_LIST_FOR(submod->data, pnode) { |
Radek Krejci | 2a9fc65 | 2021-01-22 17:44:34 +0100 | [diff] [blame] | 1847 | LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) { |
| 1848 | if (!(grp->flags & LYS_USED_GRP)) { |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1849 | LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup); |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1850 | } |
| 1851 | } |
| 1852 | } |
| 1853 | } |
| 1854 | ctx.pmod = sp; |
| 1855 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 1856 | LOG_LOCBACK(0, 0, 1, 0); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1857 | |
Michal Vasko | 405cc9e | 2020-12-01 12:01:27 +0100 | [diff] [blame] | 1858 | /* finish compilation for all unresolved module items in the context */ |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1859 | LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), cleanup); |
Michal Vasko | 12606ee | 2020-11-25 17:05:11 +0100 | [diff] [blame] | 1860 | |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1861 | cleanup: |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 1862 | LOG_LOCBACK(0, 0, 1, 0); |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1863 | lys_compile_unres_mod_erase(&ctx, ret); |
| 1864 | if (ret) { |
Michal Vasko | 1ccbf54 | 2021-04-19 11:35:00 +0200 | [diff] [blame] | 1865 | lysc_module_free(mod_c); |
| 1866 | mod->compiled = NULL; |
| 1867 | } |
Michal Vasko | 1a7a7bd | 2020-10-16 14:39:15 +0200 | [diff] [blame] | 1868 | return ret; |
| 1869 | } |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1870 | |
aPiecek | 6b3d542 | 2021-07-30 15:55:43 +0200 | [diff] [blame] | 1871 | LY_ERR |
Michal Vasko | fa5a7d7 | 2021-06-15 11:41:20 +0200 | [diff] [blame] | 1872 | lys_compile_identities(struct lys_module *mod) |
| 1873 | { |
| 1874 | struct lysc_ctx ctx = {0}; |
| 1875 | struct lysp_submodule *submod; |
| 1876 | LY_ARRAY_COUNT_TYPE u; |
| 1877 | |
aPiecek | 6b3d542 | 2021-07-30 15:55:43 +0200 | [diff] [blame] | 1878 | /* pre-compile identities of the module and any submodules */ |
| 1879 | LY_CHECK_RET(lys_identity_precompile(NULL, mod->ctx, mod->parsed, mod->parsed->identities, &mod->identities)); |
| 1880 | LY_ARRAY_FOR(mod->parsed->includes, u) { |
| 1881 | submod = mod->parsed->includes[u].submodule; |
| 1882 | LY_CHECK_RET(lys_identity_precompile(NULL, mod->ctx, (struct lysp_module *)submod, submod->identities, &mod->identities)); |
| 1883 | } |
| 1884 | |
Michal Vasko | fa5a7d7 | 2021-06-15 11:41:20 +0200 | [diff] [blame] | 1885 | /* prepare context */ |
| 1886 | ctx.ctx = mod->ctx; |
| 1887 | ctx.cur_mod = mod; |
| 1888 | ctx.pmod = mod->parsed; |
| 1889 | ctx.path_len = 1; |
| 1890 | ctx.path[0] = '/'; |
| 1891 | |
| 1892 | if (mod->parsed->identities) { |
| 1893 | LY_CHECK_RET(lys_compile_identities_derived(&ctx, mod->parsed->identities, &mod->identities)); |
| 1894 | } |
| 1895 | lysc_update_path(&ctx, NULL, "{submodule}"); |
| 1896 | LY_ARRAY_FOR(mod->parsed->includes, u) { |
| 1897 | submod = mod->parsed->includes[u].submodule; |
| 1898 | if (submod->identities) { |
| 1899 | ctx.pmod = (struct lysp_module *)submod; |
| 1900 | lysc_update_path(&ctx, NULL, submod->name); |
| 1901 | LY_CHECK_RET(lys_compile_identities_derived(&ctx, submod->identities, &mod->identities)); |
| 1902 | lysc_update_path(&ctx, NULL, NULL); |
| 1903 | } |
| 1904 | } |
| 1905 | lysc_update_path(&ctx, NULL, NULL); |
| 1906 | |
| 1907 | return LY_SUCCESS; |
| 1908 | } |
| 1909 | |
| 1910 | /** |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1911 | * @brief Check whether a module does not have any (recursive) compiled import. |
| 1912 | * |
| 1913 | * @param[in] mod Module to examine. |
| 1914 | * @return LY_SUCCESS on success. |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1915 | * @return LY_ERECOMPILE on required recompilation of the dep set. |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1916 | * @return LY_ERR on error. |
| 1917 | */ |
| 1918 | static LY_ERR |
| 1919 | lys_has_compiled_import_r(struct lys_module *mod) |
| 1920 | { |
| 1921 | LY_ARRAY_COUNT_TYPE u; |
Michal Vasko | e792712 | 2021-06-15 12:00:04 +0200 | [diff] [blame] | 1922 | struct lys_module *m; |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1923 | |
| 1924 | LY_ARRAY_FOR(mod->parsed->imports, u) { |
Michal Vasko | e792712 | 2021-06-15 12:00:04 +0200 | [diff] [blame] | 1925 | m = mod->parsed->imports[u].module; |
| 1926 | if (!m->implemented) { |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1927 | continue; |
| 1928 | } |
| 1929 | |
Michal Vasko | e792712 | 2021-06-15 12:00:04 +0200 | [diff] [blame] | 1930 | if (!m->to_compile) { |
Michal Vasko | d39bea4 | 2021-06-14 10:42:49 +0200 | [diff] [blame] | 1931 | /* module was not/will not be compiled in this compilation (so disabled nodes are not present) */ |
Michal Vasko | f4258e1 | 2021-06-15 12:11:42 +0200 | [diff] [blame] | 1932 | m->to_compile = 1; |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1933 | return LY_ERECOMPILE; |
| 1934 | } |
| 1935 | |
| 1936 | /* recursive */ |
Michal Vasko | e792712 | 2021-06-15 12:00:04 +0200 | [diff] [blame] | 1937 | LY_CHECK_RET(lys_has_compiled_import_r(m)); |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1938 | } |
| 1939 | |
| 1940 | return LY_SUCCESS; |
| 1941 | } |
| 1942 | |
| 1943 | LY_ERR |
| 1944 | lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres) |
| 1945 | { |
| 1946 | LY_ERR ret; |
| 1947 | struct lys_module *m; |
| 1948 | |
| 1949 | assert(!mod->implemented); |
| 1950 | |
Michal Vasko | fda52ac | 2022-01-21 14:13:40 +0100 | [diff] [blame] | 1951 | /* check collision with other implemented revision */ |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1952 | m = ly_ctx_get_module_implemented(mod->ctx, mod->name); |
| 1953 | if (m) { |
| 1954 | assert(m != mod); |
Michal Vasko | fda52ac | 2022-01-21 14:13:40 +0100 | [diff] [blame] | 1955 | if (!strcmp(mod->name, "yang") && (strcmp(m->revision, mod->revision) > 0)) { |
| 1956 | /* special case for newer internal module, continue */ |
| 1957 | LOGVRB("Internal module \"%s@%s\" is already implemented in revision \"%s\", using it instead.", |
| 1958 | mod->name, mod->revision ? mod->revision : "<none>", m->revision ? m->revision : "<none>"); |
| 1959 | } else { |
| 1960 | LOGERR(mod->ctx, LY_EDENIED, "Module \"%s@%s\" is already implemented in revision \"%s\".", |
| 1961 | mod->name, mod->revision ? mod->revision : "<none>", m->revision ? m->revision : "<none>"); |
| 1962 | return LY_EDENIED; |
| 1963 | } |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1964 | } |
| 1965 | |
| 1966 | /* set features */ |
| 1967 | ret = lys_set_features(mod->parsed, features); |
| 1968 | if (ret && (ret != LY_EEXIST)) { |
| 1969 | return ret; |
| 1970 | } |
| 1971 | |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1972 | /* |
| 1973 | * mark the module implemented, which means |
| 1974 | * 1) to (re)compile it only ::lys_compile() call is needed |
| 1975 | * 2) its compilation will never cause new modules to be implemented (::lys_compile() does not return ::LY_ERECOMPILE) |
| 1976 | * but there can be some unres items added that do |
| 1977 | */ |
| 1978 | mod->implemented = 1; |
| 1979 | |
Michal Vasko | a9f807e | 2021-06-15 12:07:16 +0200 | [diff] [blame] | 1980 | /* this module is compiled in this compilation */ |
| 1981 | mod->to_compile = 1; |
| 1982 | |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1983 | /* add the module into newly implemented module set */ |
| 1984 | LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL)); |
| 1985 | |
Michal Vasko | a9f807e | 2021-06-15 12:07:16 +0200 | [diff] [blame] | 1986 | /* mark target modules with our augments and deviations */ |
| 1987 | LY_CHECK_RET(lys_precompile_augments_deviations(mod, unres)); |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1988 | |
Michal Vasko | d39bea4 | 2021-06-14 10:42:49 +0200 | [diff] [blame] | 1989 | /* check whether this module may reference any modules compiled previously */ |
| 1990 | LY_CHECK_RET(lys_has_compiled_import_r(mod)); |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1991 | |
Michal Vasko | 6533388 | 2021-06-10 14:12:16 +0200 | [diff] [blame] | 1992 | return LY_SUCCESS; |
| 1993 | } |