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