uncrustify FEATURE all spacing connected to *
diff --git a/src/tree_schema_compile.c b/src/tree_schema_compile.c
index 763e72e..cae0cd0 100644
--- a/src/tree_schema_compile.c
+++ b/src/tree_schema_compile.c
@@ -299,7 +299,7 @@
* @param[in] orig The pattern structure to duplicate.
* @return The duplicated structure to use.
*/
-static struct lysc_pattern*
+static struct lysc_pattern *
lysc_pattern_dup(struct lysc_pattern *orig)
{
++orig->refcount;
@@ -316,7 +316,7 @@
* @return New sized array as a copy of @p orig.
* @return NULL in case of memory allocation error.
*/
-static struct lysc_pattern**
+static struct lysc_pattern **
lysc_patterns_dup(struct ly_ctx *ctx, struct lysc_pattern **orig)
{
struct lysc_pattern **dup = NULL;
@@ -340,7 +340,7 @@
* @return New compiled range structure as a copy of @p orig.
* @return NULL in case of memory allocation error.
*/
-struct lysc_range*
+struct lysc_range *
lysc_range_dup(struct ly_ctx *ctx, const struct lysc_range *orig)
{
struct lysc_range *dup;
@@ -556,7 +556,7 @@
ext->parent = parent;
ext->parent_type = parent_type;
- lysc_update_path(ctx, ext->parent_type == LYEXT_PAR_NODE ? (struct lysc_node*)ext->parent : NULL, "{extension}");
+ lysc_update_path(ctx, ext->parent_type == LYEXT_PAR_NODE ? (struct lysc_node *)ext->parent : NULL, "{extension}");
/* get module where the extension definition should be placed */
for (u = strlen(ext_p->name); u && ext_p->name[u - 1] != ':'; --u) {}
@@ -664,7 +664,7 @@
if (ext->def->plugin && ext->def->plugin->compile) {
if (ext->argument) {
- lysc_update_path(ctx, (struct lysc_node*)ext, ext->argument);
+ lysc_update_path(ctx, (struct lysc_node *)ext, ext->argument);
}
LY_CHECK_GOTO(ext->def->plugin->compile(ctx, ext_p, ext), cleanup);
if (ext->argument) {
@@ -2223,7 +2223,7 @@
/**
* @brief stringification of the YANG built-in data types
*/
-const char* ly_data_type2str[LY_DATA_TYPE_COUNT] = {"unknown", "binary", "8bit unsigned integer", "16bit unsigned integer",
+const char *ly_data_type2str[LY_DATA_TYPE_COUNT] = {"unknown", "binary", "8bit unsigned integer", "16bit unsigned integer",
"32bit unsigned integer", "64bit unsigned integer", "string", "bits", "boolean", "decimal64", "empty", "enumeration",
"identityref", "instance-identifier", "leafref", "union", "8bit integer", "16bit integer", "32bit integer", "64bit integer"};
@@ -2542,12 +2542,12 @@
switch (basetype) {
case LY_TYPE_BINARY:
- bin = (struct lysc_type_bin*)(*type);
+ bin = (struct lysc_type_bin *)(*type);
/* RFC 7950 9.8.1, 9.4.4 - length, number of octets it contains */
if (type_p->length) {
LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
- base ? ((struct lysc_type_bin*)base)->length : NULL, &bin->length));
+ base ? ((struct lysc_type_bin *)base)->length : NULL, &bin->length));
if (!tpdfname) {
COMPILE_EXTS_GOTO(ctx, type_p->length->exts, bin->length->exts, bin->length, LYEXT_PAR_LENGTH, ret, done);
}
@@ -2560,11 +2560,11 @@
break;
case LY_TYPE_BITS:
/* RFC 7950 9.7 - bits */
- bits = (struct lysc_type_bits*)(*type);
+ bits = (struct lysc_type_bits *)(*type);
if (type_p->bits) {
LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->bits, basetype,
- base ? (struct lysc_type_bitenum_item*)((struct lysc_type_bits*)base)->bits : NULL,
- (struct lysc_type_bitenum_item**)&bits->bits));
+ base ? (struct lysc_type_bitenum_item *)((struct lysc_type_bits *)base)->bits : NULL,
+ (struct lysc_type_bitenum_item **)&bits->bits));
}
if (!base && !type_p->flags) {
@@ -2633,25 +2633,25 @@
}
break;
case LY_TYPE_STRING:
- str = (struct lysc_type_str*)(*type);
+ str = (struct lysc_type_str *)(*type);
/* RFC 7950 9.4.4 - length */
if (type_p->length) {
LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
- base ? ((struct lysc_type_str*)base)->length : NULL, &str->length));
+ base ? ((struct lysc_type_str *)base)->length : NULL, &str->length));
if (!tpdfname) {
COMPILE_EXTS_GOTO(ctx, type_p->length->exts, str->length->exts, str->length, LYEXT_PAR_LENGTH, ret, done);
}
- } else if (base && ((struct lysc_type_str*)base)->length) {
- str->length = lysc_range_dup(ctx->ctx, ((struct lysc_type_str*)base)->length);
+ } else if (base && ((struct lysc_type_str *)base)->length) {
+ str->length = lysc_range_dup(ctx->ctx, ((struct lysc_type_str *)base)->length);
}
/* RFC 7950 9.4.5 - pattern */
if (type_p->patterns) {
LY_CHECK_RET(lys_compile_type_patterns(ctx, type_p->patterns,
- base ? ((struct lysc_type_str*)base)->patterns : NULL, &str->patterns));
- } else if (base && ((struct lysc_type_str*)base)->patterns) {
- str->patterns = lysc_patterns_dup(ctx->ctx, ((struct lysc_type_str*)base)->patterns);
+ base ? ((struct lysc_type_str *)base)->patterns : NULL, &str->patterns));
+ } else if (base && ((struct lysc_type_str *)base)->patterns) {
+ str->patterns = lysc_patterns_dup(ctx->ctx, ((struct lysc_type_str *)base)->patterns);
}
if (tpdfname) {
@@ -2660,12 +2660,12 @@
}
break;
case LY_TYPE_ENUM:
- enumeration = (struct lysc_type_enum*)(*type);
+ enumeration = (struct lysc_type_enum *)(*type);
/* RFC 7950 9.6 - enum */
if (type_p->enums) {
LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->enums, basetype,
- base ? ((struct lysc_type_enum*)base)->enums : NULL, &enumeration->enums));
+ base ? ((struct lysc_type_enum *)base)->enums : NULL, &enumeration->enums));
}
if (!base && !type_p->flags) {
@@ -2693,12 +2693,12 @@
case LY_TYPE_UINT32:
case LY_TYPE_INT64:
case LY_TYPE_UINT64:
- num = (struct lysc_type_num*)(*type);
+ num = (struct lysc_type_num *)(*type);
/* RFC 6020 9.2.4 - range */
if (type_p->range) {
LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, 0,
- base ? ((struct lysc_type_num*)base)->range : NULL, &num->range));
+ base ? ((struct lysc_type_num *)base)->range : NULL, &num->range));
if (!tpdfname) {
COMPILE_EXTS_GOTO(ctx, type_p->range->exts, num->range->exts, num->range, LYEXT_PAR_RANGE, ret, done);
}
@@ -2710,7 +2710,7 @@
}
break;
case LY_TYPE_IDENT:
- idref = (struct lysc_type_identityref*)(*type);
+ idref = (struct lysc_type_identityref *)(*type);
/* RFC 7950 9.10.2 - base */
if (type_p->bases) {
@@ -2749,7 +2749,7 @@
}
break;
case LY_TYPE_LEAFREF:
- lref = (struct lysc_type_leafref*)*type;
+ lref = (struct lysc_type_leafref *)*type;
/* RFC 7950 9.9.3 - require-instance */
if (type_p->flags & LYS_SET_REQINST) {
@@ -2777,8 +2777,8 @@
lref->path = lyxp_expr_dup(ctx->ctx, type_p->path);
lref->path_context = module;
} else if (base) {
- lref->path = lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref*)base)->path);
- lref->path_context = ((struct lysc_type_leafref*)base)->path_context;
+ lref->path = lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref *)base)->path);
+ lref->path_context = ((struct lysc_type_leafref *)base)->path_context;
} else if (tpdfname) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type ", tpdfname);
return LY_EVALID;
@@ -2796,10 +2796,10 @@
case LY_TYPE_INST:
/* RFC 7950 9.9.3 - require-instance */
if (type_p->flags & LYS_SET_REQINST) {
- ((struct lysc_type_instanceid*)(*type))->require_instance = type_p->require_instance;
+ ((struct lysc_type_instanceid *)(*type))->require_instance = type_p->require_instance;
} else {
/* default is true */
- ((struct lysc_type_instanceid*)(*type))->require_instance = 1;
+ ((struct lysc_type_instanceid *)(*type))->require_instance = 1;
}
if (tpdfname) {
@@ -2808,7 +2808,7 @@
}
break;
case LY_TYPE_UNION:
- un = (struct lysc_type_union*)(*type);
+ un = (struct lysc_type_union *)(*type);
/* RFC 7950 7.4 - type */
if (type_p->types) {
@@ -2834,22 +2834,22 @@
if (un->types[u + additional]->basetype == LY_TYPE_UNION) {
/* add space for additional types from the union subtype */
un_aux = (struct lysc_type_union *)un->types[u + additional];
- LY_ARRAY_RESIZE_ERR_RET(ctx->ctx, un->types, (*((uint64_t*)(type_p->types) - 1)) + additional + LY_ARRAY_COUNT(un_aux->types) - 1,
- lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux), LY_EMEM);
+ LY_ARRAY_RESIZE_ERR_RET(ctx->ctx, un->types, (*((uint64_t *)(type_p->types) - 1)) + additional + LY_ARRAY_COUNT(un_aux->types) - 1,
+ lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux), LY_EMEM);
/* copy subtypes of the subtype union */
for (LY_ARRAY_COUNT_TYPE v = 0; v < LY_ARRAY_COUNT(un_aux->types); ++v) {
if (un_aux->types[v]->basetype == LY_TYPE_LEAFREF) {
/* duplicate the whole structure because of the instance-specific path resolving for realtype */
un->types[u + additional] = calloc(1, sizeof(struct lysc_type_leafref));
- LY_CHECK_ERR_RET(!un->types[u + additional], LOGMEM(ctx->ctx); lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux), LY_EMEM);
+ LY_CHECK_ERR_RET(!un->types[u + additional], LOGMEM(ctx->ctx); lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux), LY_EMEM);
lref = (struct lysc_type_leafref *)un->types[u + additional];
lref->basetype = LY_TYPE_LEAFREF;
- lref->path = lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref*)un_aux->types[v])->path);
+ lref->path = lyxp_expr_dup(ctx->ctx, ((struct lysc_type_leafref *)un_aux->types[v])->path);
lref->refcount = 1;
- lref->require_instance = ((struct lysc_type_leafref*)un_aux->types[v])->require_instance;
- lref->path_context = ((struct lysc_type_leafref*)un_aux->types[v])->path_context;
+ lref->require_instance = ((struct lysc_type_leafref *)un_aux->types[v])->require_instance;
+ lref->path_context = ((struct lysc_type_leafref *)un_aux->types[v])->path_context;
/* TODO extensions */
} else {
@@ -2863,7 +2863,7 @@
--additional;
/* free the replaced union subtype */
- lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux);
+ lysc_type_free(ctx->ctx, (struct lysc_type *)un_aux);
} else {
LY_ARRAY_INCREMENT(un->types);
}
@@ -2962,7 +2962,7 @@
*dflt_mod = tctx->mod->mod;
}
if (dummyloops && (!units || *units) && dflt && *dflt) {
- basetype = ((struct type_context*)tpdf_chain.objs[tpdf_chain.count - 1])->tpdf->type.compiled->basetype;
+ basetype = ((struct type_context *)tpdf_chain.objs[tpdf_chain.count - 1])->tpdf->type.compiled->basetype;
break;
}
@@ -2983,7 +2983,7 @@
/* circular typedef reference detection */
for (u = 0; u < tpdf_chain.count; u++) {
/* local part */
- tctx_iter = (struct type_context*)tpdf_chain.objs[u];
+ tctx_iter = (struct type_context *)tpdf_chain.objs[u];
if (tctx_iter->mod == tctx->mod && tctx_iter->node == tctx->node && tctx_iter->tpdf == tctx->tpdf) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
"Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
@@ -2994,7 +2994,7 @@
}
for (u = 0; u < ctx->tpdf_chain.count; u++) {
/* global part for unions corner case */
- tctx_iter = (struct type_context*)ctx->tpdf_chain.objs[u];
+ tctx_iter = (struct type_context *)ctx->tpdf_chain.objs[u];
if (tctx_iter->mod == tctx->mod && tctx_iter->node == tctx->node && tctx_iter->tpdf == tctx->tpdf) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
"Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
@@ -3076,7 +3076,7 @@
/* get restrictions from the referred typedefs */
for (u = tpdf_chain.count - 1; u + 1 > 0; --u) {
- tctx = (struct type_context*)tpdf_chain.objs[u];
+ tctx = (struct type_context *)tpdf_chain.objs[u];
/* remember the typedef context for circular check */
ly_set_add(&ctx->tpdf_chain, tctx, LY_SET_OPT_USEASLIST);
@@ -3086,7 +3086,7 @@
continue;
} else if (basetype != LY_TYPE_LEAFREF && (u != tpdf_chain.count - 1) && !(tctx->tpdf->type.flags)) {
/* no change, just use the type information from the base */
- base = ((struct lysp_tpdf*)tctx->tpdf)->type.compiled = ((struct type_context*)tpdf_chain.objs[u + 1])->tpdf->type.compiled;
+ base = ((struct lysp_tpdf *)tctx->tpdf)->type.compiled = ((struct type_context *)tpdf_chain.objs[u + 1])->tpdf->type.compiled;
++base->refcount;
continue;
}
@@ -3109,7 +3109,7 @@
/* TODO user type plugins */
(*type)->plugin = &ly_builtin_type_plugins[basetype];
prev_type = *type;
- ret = lys_compile_type_(ctx, tctx->node, tctx->tpdf->flags, tctx->mod, tctx->tpdf->name, &((struct lysp_tpdf*)tctx->tpdf)->type,
+ ret = lys_compile_type_(ctx, tctx->node, tctx->tpdf->flags, tctx->mod, tctx->tpdf->name, &((struct lysp_tpdf *)tctx->tpdf)->type,
basetype & (LY_TYPE_LEAFREF | LY_TYPE_UNION) ? lysp_find_module(ctx->ctx, tctx->mod) : NULL,
basetype, tctx->tpdf->name, base, type);
LY_CHECK_GOTO(ret, cleanup);
@@ -3287,23 +3287,23 @@
COMPILE_EXTS_GOTO(ctx, action_p->exts, action->exts, action, LYEXT_PAR_NODE, ret, cleanup);
/* input */
- lysc_update_path(ctx, (struct lysc_node*)action, "input");
+ lysc_update_path(ctx, (struct lysc_node *)action, "input");
COMPILE_ARRAY_GOTO(ctx, action_p->input.musts, action->input.musts, u, lys_compile_must, ret, cleanup);
COMPILE_EXTS_GOTO(ctx, action_p->input.exts, action->input_exts, &action->input, LYEXT_PAR_INPUT, ret, cleanup);
ctx->options |= LYSC_OPT_RPC_INPUT;
LY_LIST_FOR(action_p->input.data, child_p) {
- LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)action, uses_status));
+ LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node *)action, uses_status));
}
lysc_update_path(ctx, NULL, NULL);
ctx->options = opt_prev;
/* output */
- lysc_update_path(ctx, (struct lysc_node*)action, "output");
+ lysc_update_path(ctx, (struct lysc_node *)action, "output");
COMPILE_ARRAY_GOTO(ctx, action_p->output.musts, action->output.musts, u, lys_compile_must, ret, cleanup);
COMPILE_EXTS_GOTO(ctx, action_p->output.exts, action->output_exts, &action->output, LYEXT_PAR_OUTPUT, ret, cleanup);
ctx->options |= LYSC_OPT_RPC_OUTPUT;
LY_LIST_FOR(action_p->output.data, child_p) {
- LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)action, uses_status));
+ LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node *)action, uses_status));
}
lysc_update_path(ctx, NULL, NULL);
lysc_update_path(ctx, NULL, NULL);
@@ -3378,7 +3378,7 @@
ctx->options |= LYSC_OPT_NOTIFICATION;
LY_LIST_FOR(notif_p->data, child_p) {
- LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)notif, uses_status));
+ LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node *)notif, uses_status));
}
lysc_update_path(ctx, NULL, NULL);
@@ -3398,8 +3398,8 @@
static LY_ERR
lys_compile_node_container(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
{
- struct lysp_node_container *cont_p = (struct lysp_node_container*)node_p;
- struct lysc_node_container *cont = (struct lysc_node_container*)node;
+ struct lysp_node_container *cont_p = (struct lysp_node_container *)node_p;
+ struct lysc_node_container *cont = (struct lysc_node_container *)node;
struct lysp_node *child_p;
LY_ARRAY_COUNT_TYPE u;
LY_ERR ret = LY_SUCCESS;
@@ -3507,8 +3507,8 @@
static LY_ERR
lys_compile_node_leaf(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
{
- struct lysp_node_leaf *leaf_p = (struct lysp_node_leaf*)node_p;
- struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
+ struct lysp_node_leaf *leaf_p = (struct lysp_node_leaf *)node_p;
+ struct lysc_node_leaf *leaf = (struct lysc_node_leaf *)node;
LY_ARRAY_COUNT_TYPE u;
LY_ERR ret = LY_SUCCESS;
@@ -3546,8 +3546,8 @@
static LY_ERR
lys_compile_node_leaflist(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
{
- struct lysp_node_leaflist *llist_p = (struct lysp_node_leaflist*)node_p;
- struct lysc_node_leaflist *llist = (struct lysc_node_leaflist*)node;
+ struct lysp_node_leaflist *llist_p = (struct lysp_node_leaflist *)node_p;
+ struct lysc_node_leaflist *llist = (struct lysc_node_leaflist *)node;
LY_ARRAY_COUNT_TYPE u;
LY_ERR ret = LY_SUCCESS;
@@ -3617,8 +3617,8 @@
/* unique node must be present */
LY_ARRAY_NEW_RET(ctx->ctx, *unique, key, LY_EMEM);
- ret = lysc_resolve_schema_nodeid(ctx, keystr, len, (struct lysc_node*)list, context_module, LYS_LEAF, 0,
- (const struct lysc_node**)key, &flags);
+ ret = lysc_resolve_schema_nodeid(ctx, keystr, len, (struct lysc_node *)list, context_module, LYS_LEAF, 0,
+ (const struct lysc_node **)key, &flags);
if (ret != LY_SUCCESS) {
if (ret == LY_EDENIED) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
@@ -3680,8 +3680,8 @@
static LY_ERR
lys_compile_node_list(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
{
- struct lysp_node_list *list_p = (struct lysp_node_list*)node_p;
- struct lysc_node_list *list = (struct lysc_node_list*)node;
+ struct lysp_node_list *list_p = (struct lysp_node_list *)node_p;
+ struct lysc_node_list *list = (struct lysc_node_list *)node;
struct lysp_node *child_p;
struct lysc_node_leaf *key, *prev_key = NULL;
size_t len;
@@ -3729,7 +3729,7 @@
}
/* key node must be present */
- key = (struct lysc_node_leaf*)lys_find_child(node, node->module, keystr, len, LYS_LEAF, LYS_GETNEXT_NOCHOICE | LYS_GETNEXT_NOSTATECHECK);
+ key = (struct lysc_node_leaf *)lys_find_child(node, node->module, keystr, len, LYS_LEAF, LYS_GETNEXT_NOCHOICE | LYS_GETNEXT_NOSTATECHECK);
if (!(key)) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
"The list's key \"%.*s\" not found.", len, keystr);
@@ -3743,7 +3743,7 @@
return LY_EVALID;
}
- lysc_update_path(ctx, (struct lysc_node*)list, key->name);
+ lysc_update_path(ctx, (struct lysc_node *)list, key->name);
/* key must have the same config flag as the list itself */
if ((list->flags & LYS_CONFIG_MASK) != (key->flags & LYS_CONFIG_MASK)) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Key of the configuration list must not be status leaf.");
@@ -3785,7 +3785,7 @@
key->flags |= LYS_KEY;
/* move it to the correct position */
- if ((prev_key && (struct lysc_node*)prev_key != key->prev) || (!prev_key && key->prev->next)) {
+ if ((prev_key && (struct lysc_node *)prev_key != key->prev) || (!prev_key && key->prev->next)) {
/* fix links in closest previous siblings of the key */
if (key->next) {
key->next->prev = key->prev;
@@ -3798,7 +3798,7 @@
}
/* fix links in the key */
if (prev_key) {
- key->prev = (struct lysc_node*)prev_key;
+ key->prev = (struct lysc_node *)prev_key;
key->next = prev_key->next;
} else {
key->prev = list->child->prev;
@@ -3807,17 +3807,17 @@
/* fix links in closes future siblings of the key */
if (prev_key) {
if (prev_key->next) {
- prev_key->next->prev = (struct lysc_node*)key;
+ prev_key->next->prev = (struct lysc_node *)key;
} else {
- list->child->prev = (struct lysc_node*)key;
+ list->child->prev = (struct lysc_node *)key;
}
- prev_key->next = (struct lysc_node*)key;
+ prev_key->next = (struct lysc_node *)key;
} else {
- list->child->prev = (struct lysc_node*)key;
+ list->child->prev = (struct lysc_node *)key;
}
/* fix links in parent */
if (!key->prev->next) {
- list->child = (struct lysc_node*)key;
+ list->child = (struct lysc_node *)key;
}
}
@@ -3853,7 +3853,7 @@
static LY_ERR
lys_compile_node_choice_dflt(struct lysc_ctx *ctx, const char *dflt, struct lysc_node_choice *ch)
{
- struct lysc_node *iter, *node = (struct lysc_node*)ch;
+ struct lysc_node *iter, *node = (struct lysc_node *)ch;
const char *prefix = NULL, *name;
size_t prefix_len = 0;
@@ -3873,7 +3873,7 @@
prefix_len, prefix);
return LY_EVALID;
}
- ch->dflt = (struct lysc_node_case*)lys_find_child(node, node->module, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
+ ch->dflt = (struct lysc_node_case *)lys_find_child(node, node->module, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
if (!ch->dflt) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
"Default case \"%s\" not found.", dflt);
@@ -3881,7 +3881,7 @@
}
/* no mandatory nodes directly under the default case */
LY_LIST_FOR(ch->dflt->child, iter) {
- if (iter->parent != (struct lysc_node*)ch->dflt) {
+ if (iter->parent != (struct lysc_node *)ch->dflt) {
break;
}
if (iter->flags & LYS_MAND_TRUE) {
@@ -3924,7 +3924,7 @@
mod = ctx->mod;
}
/* get the default case */
- cs = (struct lysc_node_case*)lys_find_child((struct lysc_node*)ch, mod, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
+ cs = (struct lysc_node_case *)lys_find_child((struct lysc_node *)ch, mod, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
if (!cs) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
"Invalid deviation adding \"default\" property \"%s\" of choice - the specified case does not exists.", dflt);
@@ -3933,7 +3933,7 @@
/* check that there is no mandatory node */
LY_LIST_FOR(cs->child, node) {
- if (node->parent != (struct lysc_node*)cs) {
+ if (node->parent != (struct lysc_node *)cs) {
break;
}
if (node->flags & LYS_MAND_TRUE) {
@@ -3962,14 +3962,14 @@
static LY_ERR
lys_compile_node_choice(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
{
- struct lysp_node_choice *ch_p = (struct lysp_node_choice*)node_p;
- struct lysc_node_choice *ch = (struct lysc_node_choice*)node;
+ struct lysp_node_choice *ch_p = (struct lysp_node_choice *)node_p;
+ struct lysc_node_choice *ch = (struct lysc_node_choice *)node;
struct lysp_node *child_p, *case_child_p;
LY_ERR ret = LY_SUCCESS;
LY_LIST_FOR(ch_p->child, child_p) {
if (child_p->nodetype == LYS_CASE) {
- LY_LIST_FOR(((struct lysp_node_case*)child_p)->child, case_child_p) {
+ LY_LIST_FOR(((struct lysp_node_case *)child_p)->child, case_child_p) {
LY_CHECK_RET(lys_compile_node(ctx, case_child_p, node, 0));
}
} else {
@@ -3996,8 +3996,8 @@
static LY_ERR
lys_compile_node_any(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
{
- struct lysp_node_anydata *any_p = (struct lysp_node_anydata*)node_p;
- struct lysc_node_anydata *any = (struct lysc_node_anydata*)node;
+ struct lysp_node_anydata *any_p = (struct lysp_node_anydata *)node_p;
+ struct lysc_node_anydata *any = (struct lysc_node_anydata *)node;
unsigned int u;
LY_ERR ret = LY_SUCCESS;
@@ -4033,7 +4033,7 @@
const struct lys_module *mod;
if (node->nodetype == LYS_CASE) {
- children = (struct lysc_node**)&((struct lysc_node_choice*)parent)->cases;
+ children = (struct lysc_node **)&((struct lysc_node_choice *)parent)->cases;
} else {
children = lysc_node_children_p(parent, ctx->options);
}
@@ -4097,7 +4097,7 @@
* @return The case structure where the child node belongs to, NULL in case of error. Note that the child is not connected into the siblings list,
* it is linked from the case structure only in case it is its first child.
*/
-static struct lysc_node_case*
+static struct lysc_node_case *
lys_compile_node_case(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node_choice *ch, struct lysc_node *child)
{
struct lysc_node *iter;
@@ -4120,19 +4120,19 @@
/* we have to add an implicit case node into the parent choice */
cs = calloc(1, sizeof(struct lysc_node_case));
DUP_STRING(ctx->ctx, child->name, cs->name);
- cs->parent = (struct lysc_node*)ch;
+ cs->parent = (struct lysc_node *)ch;
cs->flags = ch->flags & LYS_STATUS_MASK;
} else if (node_p->nodetype == LYS_CASE) {
if (ch->cases && (node_p == ch->cases->prev->sp)) {
/* the case is already present since the child is not its first children */
- return (struct lysc_node_case*)ch->cases->prev;
+ return (struct lysc_node_case *)ch->cases->prev;
}
UNIQUE_CHECK(node_p->name, ctx->mod);
/* explicit parent case is not present (this is its first child) */
cs = calloc(1, sizeof(struct lysc_node_case));
DUP_STRING(ctx->ctx, node_p->name, cs->name);
- cs->parent = (struct lysc_node*)ch;
+ cs->parent = (struct lysc_node *)ch;
cs->flags = LYS_STATUS_MASK & node_p->flags;
cs->sp = node_p;
@@ -4155,15 +4155,15 @@
goto error;
}
cs->module = ctx->mod;
- cs->prev = (struct lysc_node*)cs;
+ cs->prev = (struct lysc_node *)cs;
cs->nodetype = LYS_CASE;
- lys_compile_node_connect(ctx, (struct lysc_node*)ch, (struct lysc_node*)cs);
+ lys_compile_node_connect(ctx, (struct lysc_node *)ch, (struct lysc_node *)cs);
cs->child = child;
return cs;
error:
if (cs) {
- lysc_node_free(ctx->ctx, (struct lysc_node*)cs);
+ lysc_node_free(ctx->ctx, (struct lysc_node *)cs);
}
return NULL;
@@ -4221,7 +4221,7 @@
node->flags |= config;
/* inherit the change into the children */
- LY_LIST_FOR((struct lysc_node*)lysc_node_children(node, 0), child) {
+ LY_LIST_FOR((struct lysc_node *)lysc_node_children(node, 0), child) {
LY_CHECK_RET(lys_compile_change_config(ctx, child, config_flag, 1, refine_flag));
}
@@ -4250,7 +4250,7 @@
}
} else { /* unset flag */
for ( ; parent && parent->nodetype == LYS_CONTAINER && (parent->flags & LYS_MAND_TRUE); parent = parent->parent) {
- for (iter = (struct lysc_node*)lysc_node_children(parent, 0); iter; iter = iter->next) {
+ for (iter = (struct lysc_node *)lysc_node_children(parent, 0); iter; iter = iter->next) {
if (iter->flags & LYS_MAND_TRUE) {
/* there is another mandatory node */
return;
@@ -4374,7 +4374,7 @@
ret = lysc_resolve_schema_nodeid(ctx, aug_p->nodeid, 0, parent, parent ? parent->module : ctx->mod_def,
LYS_CONTAINER | LYS_LIST | LYS_CHOICE | LYS_CASE | LYS_INOUT | LYS_NOTIF,
- 1, (const struct lysc_node**)&target, &flags);
+ 1, (const struct lysc_node **)&target, &flags);
if (ret != LY_SUCCESS) {
if (ret == LY_EDENIED) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
@@ -4420,13 +4420,13 @@
* here we gets the last created node as last children of our parent */
if (target->nodetype == LYS_CASE) {
/* the compiled node is the last child of the target (but it is a case, so we have to be careful and stop) */
- for (node = (struct lysc_node*)lysc_node_children(target, flags); node->next && node->next->parent == node->parent; node = node->next) {}
+ for (node = (struct lysc_node *)lysc_node_children(target, flags); node->next && node->next->parent == node->parent; node = node->next) {}
} else if (target->nodetype == LYS_CHOICE) {
/* to pass when statement, we need the last case no matter if it is explicit or implicit case */
- node = ((struct lysc_node_choice*)target)->cases->prev;
+ node = ((struct lysc_node_choice *)target)->cases->prev;
} else {
/* the compiled node is the last child of the target */
- node = (struct lysc_node*)lysc_node_children(target, flags);
+ node = (struct lysc_node *)lysc_node_children(target, flags);
if (!node) {
/* there is no data children (compiled nodes is e.g. notification or action or nothing) */
break;
@@ -4470,15 +4470,15 @@
ctx->options |= flags;
switch (target->nodetype) {
case LYS_CONTAINER:
- COMPILE_ARRAY1_GOTO(ctx, aug_p->actions, ((struct lysc_node_container*)target)->actions, target,
+ COMPILE_ARRAY1_GOTO(ctx, aug_p->actions, ((struct lysc_node_container *)target)->actions, target,
u, lys_compile_action, 0, ret, error);
- COMPILE_ARRAY1_GOTO(ctx, aug_p->notifs, ((struct lysc_node_container*)target)->notifs, target,
+ COMPILE_ARRAY1_GOTO(ctx, aug_p->notifs, ((struct lysc_node_container *)target)->notifs, target,
u, lys_compile_notif, 0, ret, error);
break;
case LYS_LIST:
- COMPILE_ARRAY1_GOTO(ctx, aug_p->actions, ((struct lysc_node_list*)target)->actions, target,
+ COMPILE_ARRAY1_GOTO(ctx, aug_p->actions, ((struct lysc_node_list *)target)->actions, target,
u, lys_compile_action, 0, ret, error);
- COMPILE_ARRAY1_GOTO(ctx, aug_p->notifs, ((struct lysc_node_list*)target)->notifs, target,
+ COMPILE_ARRAY1_GOTO(ctx, aug_p->notifs, ((struct lysc_node_list *)target)->notifs, target,
u, lys_compile_notif, 0, ret, error);
break;
default:
@@ -4596,7 +4596,7 @@
.module = ctx->mod,
.flags = parent ? parent->flags : 0,
.child = NULL, .next = NULL,
- .prev = (struct lysc_node*)&context_node_fake,
+ .prev = (struct lysc_node *)&context_node_fake,
.actions = NULL, .notifs = NULL};
struct lysp_grp *grp = NULL;
LY_ARRAY_COUNT_TYPE u, v;
@@ -4632,7 +4632,7 @@
}
if (mod == ctx->mod_def) {
for (node_p = uses_p->parent; !found && node_p; node_p = node_p->parent) {
- grp = (struct lysp_grp*)lysp_node_groupings(node_p);
+ grp = (struct lysp_grp *)lysp_node_groupings(node_p);
LY_ARRAY_FOR(grp, u) {
if (!strcmp(grp[u].name, name)) {
grp = &grp[u];
@@ -4676,7 +4676,7 @@
/* grouping must not reference themselves - stack in ctx maintains list of groupings currently being applied */
grp_stack_count = ctx->groupings.count;
- ly_set_add(&ctx->groupings, (void*)grp, 0);
+ ly_set_add(&ctx->groupings, (void *)grp, 0);
if (grp_stack_count == ctx->groupings.count) {
/* the target grouping is already in the stack, so we are already inside it -> circular dependency */
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
@@ -4699,9 +4699,9 @@
* applu refine and augment only to the nodes from the uses */
if (parent) {
if (parent->nodetype == LYS_CASE) {
- child = (struct lysc_node*)lysc_node_children(parent->parent, ctx->options & LYSC_OPT_RPC_MASK);
+ child = (struct lysc_node *)lysc_node_children(parent->parent, ctx->options & LYSC_OPT_RPC_MASK);
} else {
- child = (struct lysc_node*)lysc_node_children(parent, ctx->options & LYSC_OPT_RPC_MASK);
+ child = (struct lysc_node *)lysc_node_children(parent, ctx->options & LYSC_OPT_RPC_MASK);
}
} else if (ctx->mod->compiled->data) {
child = ctx->mod->compiled->data;
@@ -4723,7 +4723,7 @@
if (child) {
context_node_fake.child = child->next;
} else if (parent) {
- context_node_fake.child = (struct lysc_node*)lysc_node_children(parent, ctx->options & LYSC_OPT_RPC_MASK);
+ context_node_fake.child = (struct lysc_node *)lysc_node_children(parent, ctx->options & LYSC_OPT_RPC_MASK);
} else if (ctx->mod->compiled->data) {
context_node_fake.child = ctx->mod->compiled->data;
}
@@ -4735,7 +4735,7 @@
when_shared = NULL;
LY_LIST_FOR(context_node_fake.child, iter) {
- iter->parent = (struct lysc_node*)&context_node_fake;
+ iter->parent = (struct lysc_node *)&context_node_fake;
/* pass uses's when to all the data children, actions and notifications are ignored */
if (uses_p->when) {
@@ -4790,7 +4790,7 @@
/* sort and apply augments */
LY_CHECK_GOTO(lys_compile_augment_sort(ctx, uses_p->augments, NULL, &augments), cleanup);
LY_ARRAY_FOR(augments, u) {
- LY_CHECK_GOTO(lys_compile_augment(ctx, augments[u], (struct lysc_node*)&context_node_fake), cleanup);
+ LY_CHECK_GOTO(lys_compile_augment(ctx, augments[u], (struct lysc_node *)&context_node_fake), cleanup);
}
/* reload previous context's mod_def */
@@ -4801,8 +4801,8 @@
LY_ARRAY_FOR(uses_p->refines, struct lysp_refine, rfn) {
lysc_update_path(ctx, NULL, rfn->nodeid);
- LY_CHECK_GOTO(lysc_resolve_schema_nodeid(ctx, rfn->nodeid, 0, (struct lysc_node*)&context_node_fake, ctx->mod,
- 0, 0, (const struct lysc_node**)&node, &flags),
+ LY_CHECK_GOTO(lysc_resolve_schema_nodeid(ctx, rfn->nodeid, 0, (struct lysc_node *)&context_node_fake, ctx->mod,
+ 0, 0, (const struct lysc_node **)&node, &flags),
cleanup);
ly_set_add(&refined, node, LY_SET_OPT_USEASLIST);
@@ -4837,11 +4837,11 @@
ctx->mod_def), cleanup);
node->flags |= LYS_SET_DFLT;
} else if (node->nodetype == LYS_CHOICE) {
- if (((struct lysc_node_choice*)node)->dflt) {
+ if (((struct lysc_node_choice *)node)->dflt) {
/* unset LYS_SET_DFLT from the current default case */
- ((struct lysc_node_choice*)node)->dflt->flags &= ~LYS_SET_DFLT;
+ ((struct lysc_node_choice *)node)->dflt->flags &= ~LYS_SET_DFLT;
}
- LY_CHECK_GOTO(lys_compile_node_choice_dflt(ctx, rfn->dflts[0], (struct lysc_node_choice*)node), cleanup);
+ LY_CHECK_GOTO(lys_compile_node_choice_dflt(ctx, rfn->dflts[0], (struct lysc_node_choice *)node), cleanup);
}
}
@@ -4887,20 +4887,20 @@
if (rfn->musts) {
switch (node->nodetype) {
case LYS_LEAF:
- COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_leaf*)node)->musts, u, lys_compile_must, ret, cleanup);
+ COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_leaf *)node)->musts, u, lys_compile_must, ret, cleanup);
break;
case LYS_LEAFLIST:
- COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_leaflist*)node)->musts, u, lys_compile_must, ret, cleanup);
+ COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_leaflist *)node)->musts, u, lys_compile_must, ret, cleanup);
break;
case LYS_LIST:
- COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_list*)node)->musts, u, lys_compile_must, ret, cleanup);
+ COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_list *)node)->musts, u, lys_compile_must, ret, cleanup);
break;
case LYS_CONTAINER:
- COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_container*)node)->musts, u, lys_compile_must, ret, cleanup);
+ COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_container *)node)->musts, u, lys_compile_must, ret, cleanup);
break;
case LYS_ANYXML:
case LYS_ANYDATA:
- COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_anydata*)node)->musts, u, lys_compile_must, ret, cleanup);
+ COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_anydata *)node)->musts, u, lys_compile_must, ret, cleanup);
break;
default:
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
@@ -4916,10 +4916,10 @@
switch (node->nodetype) {
case LYS_LEAFLIST:
if (rfn->flags & LYS_SET_MAX) {
- ((struct lysc_node_leaflist*)node)->max = rfn->max ? rfn->max : (uint32_t)-1;
+ ((struct lysc_node_leaflist *)node)->max = rfn->max ? rfn->max : (uint32_t)-1;
}
if (rfn->flags & LYS_SET_MIN) {
- ((struct lysc_node_leaflist*)node)->min = rfn->min;
+ ((struct lysc_node_leaflist *)node)->min = rfn->min;
if (rfn->min) {
node->flags |= LYS_MAND_TRUE;
lys_compile_mandatory_parents(node->parent, 1);
@@ -4931,10 +4931,10 @@
break;
case LYS_LIST:
if (rfn->flags & LYS_SET_MAX) {
- ((struct lysc_node_list*)node)->max = rfn->max ? rfn->max : (uint32_t)-1;
+ ((struct lysc_node_list *)node)->max = rfn->max ? rfn->max : (uint32_t)-1;
}
if (rfn->flags & LYS_SET_MIN) {
- ((struct lysc_node_list*)node)->min = rfn->min;
+ ((struct lysc_node_list *)node)->min = rfn->min;
if (rfn->min) {
node->flags |= LYS_MAND_TRUE;
lys_compile_mandatory_parents(node->parent, 1);
@@ -4963,13 +4963,13 @@
/* do some additional checks of the changed nodes when all the refines are applied */
for (uint32_t i = 0; i < refined.count; ++i) {
- node = (struct lysc_node*)refined.objs[i];
+ node = (struct lysc_node *)refined.objs[i];
rfn = &uses_p->refines[i];
lysc_update_path(ctx, NULL, rfn->nodeid);
/* check possible conflict with default value (default added, mandatory left true) */
if ((node->flags & LYS_MAND_TRUE) &&
- (((node->nodetype & LYS_CHOICE) && ((struct lysc_node_choice*)node)->dflt) ||
+ (((node->nodetype & LYS_CHOICE) && ((struct lysc_node_choice *)node)->dflt) ||
((node->nodetype & LYS_LEAF) && (node->flags & LYS_SET_DFLT)))) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
"Invalid refine of default - the node is mandatory.");
@@ -4978,11 +4978,11 @@
if (rfn->flags & (LYS_SET_MAX | LYS_SET_MIN)) {
if (node->nodetype == LYS_LIST) {
- min = ((struct lysc_node_list*)node)->min;
- max = ((struct lysc_node_list*)node)->max;
+ min = ((struct lysc_node_list *)node)->min;
+ max = ((struct lysc_node_list *)node)->max;
} else {
- min = ((struct lysc_node_leaflist*)node)->min;
- max = ((struct lysc_node_leaflist*)node)->max;
+ min = ((struct lysc_node_leaflist *)node)->min;
+ max = ((struct lysc_node_leaflist *)node)->max;
}
if (min > max) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
@@ -5104,7 +5104,7 @@
.flags = node_p ? (node_p->flags & LYS_FLAGS_COMPILED_MASK) : 0,
.module = ctx->mod,
.sp = NULL, .parent = NULL, .next = NULL,
- .prev = (struct lysc_node*)&fake_container,
+ .prev = (struct lysc_node *)&fake_container,
.name = "fake",
.dsc = NULL, .ref = NULL, .exts = NULL, .iffeatures = NULL, .when = NULL,
.child = NULL, .musts = NULL, .actions = NULL, .notifs = NULL
@@ -5125,7 +5125,7 @@
lysc_update_path(ctx, NULL, "{grouping}");
lysc_update_path(ctx, NULL, grp->name);
- ret = lys_compile_uses(ctx, &fake_uses, (struct lysc_node*)&fake_container, NULL);
+ ret = lys_compile_uses(ctx, &fake_uses, (struct lysc_node *)&fake_container, NULL);
lysc_update_path(ctx, NULL, NULL);
lysc_update_path(ctx, NULL, NULL);
@@ -5157,7 +5157,7 @@
struct lysc_node_case *cs = NULL;
struct lysc_when **when;
unsigned int u;
- LY_ERR (*node_compile_spec)(struct lysc_ctx*, struct lysp_node*, struct lysc_node*);
+ LY_ERR (*node_compile_spec)(struct lysc_ctx *, struct lysp_node *, struct lysc_node *);
if (node_p->nodetype != LYS_USES) {
lysc_update_path(ctx, parent, node_p->name);
@@ -5168,39 +5168,39 @@
switch (node_p->nodetype) {
case LYS_CONTAINER:
- node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_container));
+ node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_container));
node_compile_spec = lys_compile_node_container;
break;
case LYS_LEAF:
- node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_leaf));
+ node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_leaf));
node_compile_spec = lys_compile_node_leaf;
break;
case LYS_LIST:
- node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_list));
+ node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_list));
node_compile_spec = lys_compile_node_list;
break;
case LYS_LEAFLIST:
- node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_leaflist));
+ node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_leaflist));
node_compile_spec = lys_compile_node_leaflist;
break;
case LYS_CHOICE:
- node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_choice));
+ node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_choice));
node_compile_spec = lys_compile_node_choice;
break;
case LYS_ANYXML:
case LYS_ANYDATA:
- node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_anydata));
+ node = (struct lysc_node *)calloc(1, sizeof(struct lysc_node_anydata));
node_compile_spec = lys_compile_node_any;
break;
case LYS_USES:
if (parent && parent->nodetype == LYS_CHOICE) {
assert(node_p->parent->nodetype == LYS_CASE);
lysc_update_path(ctx, parent, node_p->parent->name);
- cs = lys_compile_node_case(ctx, node_p->parent, (struct lysc_node_choice*)parent, NULL);
+ cs = lys_compile_node_case(ctx, node_p->parent, (struct lysc_node_choice *)parent, NULL);
LY_CHECK_ERR_GOTO(!cs, ret = LY_EVALID, error);
}
- ret = lys_compile_uses(ctx, (struct lysp_node_uses*)node_p, cs ? (struct lysc_node*)cs : parent, &node);
+ ret = lys_compile_uses(ctx, (struct lysp_node_uses *)node_p, cs ? (struct lysc_node *)cs : parent, &node);
if (cs) {
cs->child = node;
lysc_update_path(ctx, NULL, NULL);
@@ -5305,14 +5305,14 @@
} else {
lysc_update_path(ctx, parent, node->name);
}
- cs = lys_compile_node_case(ctx, node_p->parent, (struct lysc_node_choice*)parent, node);
+ cs = lys_compile_node_case(ctx, node_p->parent, (struct lysc_node_choice *)parent, node);
LY_CHECK_ERR_GOTO(!cs, ret = LY_EVALID, error);
if (uses_status) {}
/* the postponed status check of the node and its real parent - in case of implicit case,
* it directly gets the same status flags as the choice;
* uses_status cannot be applied here since uses cannot be child statement of choice */
LY_CHECK_GOTO(ret = lys_compile_status(ctx, &node->flags, cs->flags), error);
- node->parent = (struct lysc_node*)cs;
+ node->parent = (struct lysc_node *)cs;
lysc_update_path(ctx, parent, node->name);
} else { /* other than choice */
lysc_update_path(ctx, parent, node->name);
@@ -5360,15 +5360,15 @@
/* parent's first child */
if (parent && parent->nodetype == LYS_CHOICE) {
- cs = (struct lysc_node_case*)node;
+ cs = (struct lysc_node_case *)node;
} else if (parent && parent->nodetype == LYS_CASE) {
/* disconnecting some node in a case */
- cs = (struct lysc_node_case*)parent;
+ cs = (struct lysc_node_case *)parent;
parent = cs->parent;
- for (child = cs->child; child && child->parent == (struct lysc_node*)cs; child = child->next) {
+ for (child = cs->child; child && child->parent == (struct lysc_node *)cs; child = child->next) {
if (child == node) {
if (cs->child == child) {
- if (!child->next || child->next->parent != (struct lysc_node*)cs) {
+ if (!child->next || child->next->parent != (struct lysc_node *)cs) {
/* case with a single child -> remove also the case */
child->parent = NULL;
remove_cs = 1;
@@ -5390,24 +5390,24 @@
if (cs) {
if (remove_cs) {
/* cs has only one child which is being also removed */
- lysc_disconnect((struct lysc_node*)cs);
- lysc_node_free(cs->module->ctx, (struct lysc_node*)cs);
+ lysc_disconnect((struct lysc_node *)cs);
+ lysc_node_free(cs->module->ctx, (struct lysc_node *)cs);
} else {
- if (((struct lysc_node_choice*)parent)->dflt == cs) {
+ if (((struct lysc_node_choice *)parent)->dflt == cs) {
/* default case removed */
- ((struct lysc_node_choice*)parent)->dflt = NULL;
+ ((struct lysc_node_choice *)parent)->dflt = NULL;
}
- if (((struct lysc_node_choice*)parent)->cases == cs) {
+ if (((struct lysc_node_choice *)parent)->cases == cs) {
/* first case removed */
- ((struct lysc_node_choice*)parent)->cases = (struct lysc_node_case*)cs->next;
+ ((struct lysc_node_choice *)parent)->cases = (struct lysc_node_case *)cs->next;
}
if (cs->child) {
/* cs will be removed and disconnected from its siblings, but we have to take care also about its children */
- if (cs->child->prev->parent != (struct lysc_node*)cs) {
+ if (cs->child->prev->parent != (struct lysc_node *)cs) {
prev = cs->child->prev;
} /* else all the children are under a single case */
LY_LIST_FOR_SAFE(cs->child, next, child) {
- if (child->parent != (struct lysc_node*)cs) {
+ if (child->parent != (struct lysc_node *)cs) {
break;
}
lysc_node_free(node->module->ctx, child);
@@ -5420,7 +5420,7 @@
child->prev = prev;
} else {
/* link from the first child under the cases */
- ((struct lysc_node_choice*)cs->parent)->cases->child->prev = prev;
+ ((struct lysc_node_choice *)cs->parent)->cases->child->prev = prev;
}
}
}
@@ -5435,22 +5435,22 @@
node->next->prev = node->prev;
} else if (node->nodetype != LYS_CASE) {
if (parent) {
- child = (struct lysc_node*)lysc_node_children(parent, node->flags);
+ child = (struct lysc_node *)lysc_node_children(parent, node->flags);
} else {
child = modc->data;
}
if (child) {
child->prev = node->prev;
}
- } else if (((struct lysc_node_choice*)parent)->cases) {
- ((struct lysc_node_choice*)parent)->cases->prev = node->prev;
+ } else if (((struct lysc_node_choice *)parent)->cases) {
+ ((struct lysc_node_choice *)parent)->cases->prev = node->prev;
}
}
struct lysc_deviation {
const char *nodeid;
struct lysc_node *target; /* target node of the deviation */
- struct lysp_deviate** deviates;/* sized array of pointers to parsed deviate statements to apply on target */
+ struct lysp_deviate **deviates;/* sized array of pointers to parsed deviate statements to apply on target */
uint16_t flags; /* target's flags from lysc_resolve_schema_nodeid() */
uint8_t not_supported; /* flag if deviates contains not-supported deviate */
};
@@ -5658,11 +5658,11 @@
if (target->nodetype == LYS_LEAFLIST) {
DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_leaflist *, > 0, min, "min-elements");
/* change value */
- ((struct lysc_node_leaflist*)target)->min = d->min;
+ ((struct lysc_node_leaflist *)target)->min = d->min;
} else if (target->nodetype == LYS_LIST) {
DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_list *, > 0, min, "min-elements");
/* change value */
- ((struct lysc_node_list*)target)->min = d->min;
+ ((struct lysc_node_list *)target)->min = d->min;
} else {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
lys_nodetype2str(target->nodetype), "add", "min-elements");
@@ -5678,11 +5678,11 @@
if (target->nodetype == LYS_LEAFLIST) {
DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_leaflist *, < (uint32_t)-1, max, "max-elements");
/* change value */
- ((struct lysc_node_leaflist*)target)->max = d->max ? d->max : (uint32_t)-1;
+ ((struct lysc_node_leaflist *)target)->max = d->max ? d->max : (uint32_t)-1;
} else if (target->nodetype == LYS_LIST) {
DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_list *, < (uint32_t)-1, max, "max-elements");
/* change value */
- ((struct lysc_node_list*)target)->max = d->max ? d->max : (uint32_t)-1;
+ ((struct lysc_node_list *)target)->max = d->max ? d->max : (uint32_t)-1;
} else {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
lys_nodetype2str(target->nodetype), "add", "max-elements");
@@ -5899,15 +5899,15 @@
/* [units-stmt] */
if (d->units) {
DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "delete", "units");
- DEV_CHECK_PRESENCE(struct lysc_node_leaf*, 0, units, "deleting", "units", d->units);
- if (strcmp(((struct lysc_node_leaf*)target)->units, d->units)) {
+ DEV_CHECK_PRESENCE(struct lysc_node_leaf *, 0, units, "deleting", "units", d->units);
+ if (strcmp(((struct lysc_node_leaf *)target)->units, d->units)) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
"Invalid deviation deleting \"units\" property \"%s\" which does not match the target's property value \"%s\".",
- d->units, ((struct lysc_node_leaf*)target)->units);
+ d->units, ((struct lysc_node_leaf *)target)->units);
goto cleanup;
}
- lydict_remove(ctx->ctx, ((struct lysc_node_leaf*)target)->units);
- ((struct lysc_node_leaf*)target)->units = NULL;
+ lydict_remove(ctx->ctx, ((struct lysc_node_leaf *)target)->units);
+ ((struct lysc_node_leaf *)target)->units = NULL;
}
/* *must-stmt */
@@ -5915,23 +5915,23 @@
switch (target->nodetype) {
case LYS_CONTAINER:
case LYS_LIST:
- DEV_DEL_ARRAY(struct lysc_node_container*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
+ DEV_DEL_ARRAY(struct lysc_node_container *, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
break;
case LYS_LEAF:
case LYS_LEAFLIST:
case LYS_ANYDATA:
- DEV_DEL_ARRAY(struct lysc_node_leaf*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
+ DEV_DEL_ARRAY(struct lysc_node_leaf *, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
break;
case LYS_NOTIF:
- DEV_DEL_ARRAY(struct lysc_notif*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
+ DEV_DEL_ARRAY(struct lysc_notif *, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
break;
case LYS_RPC:
case LYS_ACTION:
if (dev_flags & LYSC_OPT_RPC_INPUT) {
- DEV_DEL_ARRAY(struct lysc_action*, input.musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
+ DEV_DEL_ARRAY(struct lysc_action *, input.musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
break;
} else if (dev_flags & LYSC_OPT_RPC_OUTPUT) {
- DEV_DEL_ARRAY(struct lysc_action*, output.musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
+ DEV_DEL_ARRAY(struct lysc_action *, output.musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
break;
}
/* fall through */
@@ -5996,7 +5996,7 @@
break;
case LYS_CHOICE:
DEV_CHECK_CARDINALITY(d->dflts, 1, "default");
- DEV_CHECK_PRESENCE(struct lysc_node_choice*, 0, dflt, "deleting", "default", d->dflts[0]);
+ DEV_CHECK_PRESENCE(struct lysc_node_choice *, 0, dflt, "deleting", "default", d->dflts[0]);
nodeid = d->dflts[0];
LY_CHECK_GOTO(ly_parse_nodeid(&nodeid, &prefix, &prefix_len, &name, &name_len), cleanup);
if (prefix) {
@@ -6007,7 +6007,7 @@
"The prefix does not match any imported module of the deviation module.", d->dflts[0]);
goto cleanup;
}
- if (mod != ((struct lysc_node_choice*)target)->dflt->module) {
+ if (mod != ((struct lysc_node_choice *)target)->dflt->module) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
"Invalid deviation deleting \"default\" property \"%s\" of choice. "
"The prefix does not match the default case's module.", d->dflts[0]);
@@ -6018,14 +6018,14 @@
* strictly, the default prefix would point to the deviation module, but the value should actually
* match the default string in the original module (usually unprefixed), so in this case we do not check
* the module of the default case, just matching its name */
- if (strcmp(name, ((struct lysc_node_choice*)target)->dflt->name)) {
+ if (strcmp(name, ((struct lysc_node_choice *)target)->dflt->name)) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
"Invalid deviation deleting \"default\" property \"%s\" of choice does not match the default case name \"%s\".",
- d->dflts[0], ((struct lysc_node_choice*)target)->dflt->name);
+ d->dflts[0], ((struct lysc_node_choice *)target)->dflt->name);
goto cleanup;
}
- ((struct lysc_node_choice*)target)->dflt->flags &= ~LYS_SET_DFLT;
- ((struct lysc_node_choice*)target)->dflt = NULL;
+ ((struct lysc_node_choice *)target)->dflt->flags &= ~LYS_SET_DFLT;
+ ((struct lysc_node_choice *)target)->dflt = NULL;
break;
default:
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
@@ -6399,7 +6399,7 @@
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
"Invalid deviation combining default value and mandatory %s.", lys_nodetype2str(target->nodetype));
goto cleanup;
- } else if ((target->nodetype & LYS_CHOICE) && ((struct lysc_node_choice*)target)->dflt
+ } else if ((target->nodetype & LYS_CHOICE) && ((struct lysc_node_choice *)target)->dflt
&& (target->flags & LYS_MAND_TRUE)) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid deviation combining default case and mandatory choice.");
goto cleanup;
@@ -6459,17 +6459,17 @@
/* resolve the target */
LY_CHECK_GOTO(lysc_resolve_schema_nodeid(ctx, dev->nodeid, 0, NULL, ctx->mod, 0, 1,
- (const struct lysc_node**)&target, &flags), cleanup);
+ (const struct lysc_node **)&target, &flags), cleanup);
if (target->nodetype & (LYS_RPC | LYS_ACTION)) {
/* move the target pointer to input/output to make them different from the action and
* between them. Before the devs[] item is being processed, the target pointer must be fixed
* back to the RPC/action node due to a better compatibility and decision code in this function.
* The LYSC_OPT_INTERNAL is used as a flag to this change. */
if (flags & LYSC_OPT_RPC_INPUT) {
- target = (struct lysc_node*)&((struct lysc_action*)target)->input;
+ target = (struct lysc_node *)&((struct lysc_action *)target)->input;
flags |= LYSC_OPT_INTERNAL;
} else if (flags & LYSC_OPT_RPC_OUTPUT) {
- target = (struct lysc_node*)&((struct lysc_action*)target)->output;
+ target = (struct lysc_node *)&((struct lysc_action *)target)->output;
flags |= LYSC_OPT_INTERNAL;
}
}
@@ -6661,21 +6661,21 @@
if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
/* single item */
- if (*(struct lysc_type**)substmts[u].storage) {
+ if (*(struct lysc_type **)substmts[u].storage) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
goto cleanup;
}
compiled = substmts[u].storage;
} else {
/* sized array */
- struct lysc_type ***types = (struct lysc_type***)substmts[u].storage, **type = NULL;
+ struct lysc_type ***types = (struct lysc_type ***)substmts[u].storage, **type = NULL;
LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
- compiled = (void*)type;
+ compiled = (void *)type;
}
LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, stmt->kw, &parsed, NULL), ret = r, cleanup);
- LY_CHECK_ERR_GOTO(r = lys_compile_type(ctx, ext->parent_type == LYEXT_PAR_NODE ? ((struct lysc_node*)ext->parent)->sp : NULL,
- flags ? *flags : 0, ctx->mod_def->parsed, ext->name, parsed, (struct lysc_type**)compiled,
+ LY_CHECK_ERR_GOTO(r = lys_compile_type(ctx, ext->parent_type == LYEXT_PAR_NODE ? ((struct lysc_node *)ext->parent)->sp : NULL,
+ flags ? *flags : 0, ctx->mod_def->parsed, ext->name, parsed, (struct lysc_type **)compiled,
units && !*units ? units : NULL, NULL, NULL), lysp_type_free(ctx->ctx, parsed); free(parsed); ret = r, cleanup);
lysp_type_free(ctx->ctx, parsed);
free(parsed);
@@ -6686,14 +6686,14 @@
if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
/* single item */
- if (((struct lysc_iffeature*)substmts[u].storage)->features) {
+ if (((struct lysc_iffeature *)substmts[u].storage)->features) {
LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
goto cleanup;
}
- iff = (struct lysc_iffeature*)substmts[u].storage;
+ iff = (struct lysc_iffeature *)substmts[u].storage;
} else {
/* sized array */
- struct lysc_iffeature **iffs = (struct lysc_iffeature**)substmts[u].storage;
+ struct lysc_iffeature **iffs = (struct lysc_iffeature **)substmts[u].storage;
LY_ARRAY_NEW_GOTO(ctx->ctx, *iffs, iff, ret, cleanup);
}
LY_CHECK_ERR_GOTO(r = lys_compile_iffeature(ctx, &stmt->arg, iff), ret = r, cleanup);
@@ -7207,17 +7207,17 @@
/* store pointer to the real type */
type = ((struct lysc_node_leaf *)ctx->leafrefs.objs[i])->type;
if (type->basetype == LY_TYPE_LEAFREF) {
- for (typeiter = ((struct lysc_type_leafref*)type)->realtype;
+ for (typeiter = ((struct lysc_type_leafref *)type)->realtype;
typeiter->basetype == LY_TYPE_LEAFREF;
- typeiter = ((struct lysc_type_leafref*)typeiter)->realtype) {}
- ((struct lysc_type_leafref*)type)->realtype = typeiter;
+ typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
+ ((struct lysc_type_leafref *)type)->realtype = typeiter;
} else if (type->basetype == LY_TYPE_UNION) {
- LY_ARRAY_FOR(((struct lysc_type_union*)type)->types, v) {
- if (((struct lysc_type_union*)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
- for (typeiter = ((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[v])->realtype;
+ LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
+ if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
+ for (typeiter = ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype;
typeiter->basetype == LY_TYPE_LEAFREF;
- typeiter = ((struct lysc_type_leafref*)typeiter)->realtype) {}
- ((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[v])->realtype = typeiter;
+ typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
+ ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype = typeiter;
}
}
}
@@ -7368,7 +7368,7 @@
}
}
LY_LIST_FOR(sp->data, node_p) {
- grps = (struct lysp_grp*)lysp_node_groupings(node_p);
+ grps = (struct lysp_grp *)lysp_node_groupings(node_p);
LY_ARRAY_FOR(grps, u) {
if (!(grps[u].flags & LYS_USED_GRP)) {
LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, node_p, &grps[u]), error);