libyang CHANGE unify the statement enumerations
Instead of keeping a separate enumeration for YANG extension pattern
statements, just use the standard ly_stmt enumeration.
diff --git a/src/parser_stmt.c b/src/parser_stmt.c
index 0536f70..3f6cf96 100644
--- a/src/parser_stmt.c
+++ b/src/parser_stmt.c
@@ -79,14 +79,14 @@
*
* @param[in] ctx parser context.
* @param[in] stmt Source statement data from the parsed extension instance.
- * @param[in] insubstmt Type of the keyword this extension instance is a substatement of.
+ * @param[in] insubstmt The statement this extension instance is a substatement of.
* @param[in] insubstmt_index Index of the keyword instance this extension instance is a substatement of.
* @param[in,out] exts Extension instances to add to.
*
* @return LY_ERR values.
*/
static LY_ERR
-lysp_stmt_ext(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, LYEXT_SUBSTMT insubstmt,
+lysp_stmt_ext(struct lys_parser_ctx *ctx, const struct lysp_stmt *stmt, enum ly_stmt insubstmt,
LY_ARRAY_COUNT_TYPE insubstmt_index, struct lysp_ext_instance **exts)
{
struct lysp_ext_instance *e;
@@ -254,7 +254,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_STATUS, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_STATUS, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "status");
@@ -301,7 +301,7 @@
LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &when->ref, Y_STR_ARG, &when->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &when->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &when->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "when");
@@ -345,7 +345,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_CONFIG, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_CONFIG, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "config");
@@ -390,7 +390,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_MANDATORY, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_MANDATORY, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "mandatory");
@@ -432,7 +432,7 @@
LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &restr->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &restr->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));
@@ -512,7 +512,7 @@
LY_CHECK_RET(lysp_stmt_when(ctx, child, &any->when));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &any->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &any->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw),
@@ -591,7 +591,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw == LY_STMT_VALUE ? LYEXT_SUBSTMT_VALUE : LYEXT_SUBSTMT_POSITION, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, stmt->kw == LY_STMT_VALUE ? LY_STMT_VALUE : LY_STMT_POSITION, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));
@@ -655,7 +655,7 @@
LY_CHECK_RET(lysp_stmt_type_enum_value_pos(ctx, child, &enm->value, &enm->flags, &enm->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &enm->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &enm->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));
@@ -710,7 +710,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_FRACTION_DIGITS, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_FRACTION_DIGITS, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "fraction-digits");
@@ -755,7 +755,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_REQUIRE_INSTANCE, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_REQUIRE_INSTANCE, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "require-instance");
@@ -806,7 +806,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_MODIFIER, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_MODIFIER, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "modifier");
@@ -864,7 +864,7 @@
LY_CHECK_RET(lysp_stmt_type_pattern_modifier(ctx, child, &restr->arg.str, &restr->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &restr->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &restr->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "pattern");
@@ -961,7 +961,7 @@
type->flags |= LYS_SET_TYPE;
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &type->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &type->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "type");
@@ -1034,7 +1034,7 @@
LY_CHECK_RET(lysp_stmt_when(ctx, child, &leaf->when));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &leaf->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &leaf->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "leaf");
@@ -1107,7 +1107,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_MAX_ELEMENTS, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "max-elements");
@@ -1168,7 +1168,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_MIN_ELEMENTS, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "min-elements");
@@ -1214,7 +1214,7 @@
for (const struct lysp_stmt *child = stmt->child; child; child = child->next) {
switch (child->kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_ORDERED_BY, 0, exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_ORDERED_BY, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "ordered-by");
@@ -1294,7 +1294,7 @@
LY_CHECK_RET(lysp_stmt_when(ctx, child, &llist->when));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &llist->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &llist->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "llist");
@@ -1365,7 +1365,7 @@
LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &rf->presence, Y_STR_ARG, &rf->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &rf->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &rf->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "refine");
@@ -1420,7 +1420,7 @@
LY_CHECK_RET(lysp_stmt_text_field(ctx, child, 0, &tpdf->units, Y_STR_ARG, &tpdf->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &tpdf->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &tpdf->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "typedef");
@@ -1504,7 +1504,7 @@
LY_CHECK_RET(lysp_stmt_grouping(ctx, child, &inout_p->node, &inout_p->groupings));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &inout_p->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &inout_p->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), ly_stmt2str(stmt->kw));
@@ -1572,7 +1572,7 @@
LY_CHECK_RET(lysp_stmt_grouping(ctx, child, &act->node, &act->groupings));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &act->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &act->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), parent ? "action" : "rpc");
@@ -1669,7 +1669,7 @@
LY_CHECK_RET(lysp_stmt_grouping(ctx, child, ¬if->node, ¬if->groupings));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, ¬if->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, ¬if->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "notification");
@@ -1755,7 +1755,7 @@
LY_CHECK_RET(lysp_stmt_notif(ctx, child, &grp->node, &grp->notifs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &grp->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &grp->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "grouping");
@@ -1844,7 +1844,7 @@
LY_CHECK_RET(lysp_stmt_notif(ctx, child, &aug->node, &aug->notifs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &aug->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &aug->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "augment");
@@ -1905,7 +1905,7 @@
LY_CHECK_RET(lysp_stmt_augment(ctx, child, &uses->node, &uses->augments));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &uses->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &uses->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "uses");
@@ -1984,7 +1984,7 @@
LY_CHECK_RET(lysp_stmt_uses(ctx, child, &cas->node, &cas->child));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &cas->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &cas->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "case");
@@ -2072,7 +2072,7 @@
LY_CHECK_RET(lysp_stmt_list(ctx, child, &choice->node, &choice->child));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &choice->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &choice->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "choice");
@@ -2173,7 +2173,7 @@
LY_CHECK_RET(lysp_stmt_notif(ctx, child, &cont->node, &cont->notifs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &cont->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &cont->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "container");
@@ -2288,7 +2288,7 @@
LY_CHECK_RET(lysp_stmt_notif(ctx, child, &list->node, &list->notifs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(lysp_stmt_ext(ctx, child, LYEXT_SUBSTMT_SELF, 0, &list->exts));
+ LY_CHECK_RET(lysp_stmt_ext(ctx, child, LY_STMT_NONE, 0, &list->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(child->kw), "list");
@@ -2360,7 +2360,7 @@
ret = lysp_stmt_qnames(&pctx, stmt, (struct lysp_qname **)result, Y_STR_ARG, exts);
break;
case LY_STMT_EXTENSION_INSTANCE:
- ret = lysp_stmt_ext(&pctx, stmt, LYEXT_SUBSTMT_SELF, 0, exts);
+ ret = lysp_stmt_ext(&pctx, stmt, LY_STMT_NONE, 0, exts);
break;
case LY_STMT_FRACTION_DIGITS:
ret = lysp_stmt_type_fracdigits(&pctx, stmt, *(uint8_t **)result, exts);
diff --git a/src/parser_yang.c b/src/parser_yang.c
index 4d6e589..47f437c 100644
--- a/src/parser_yang.c
+++ b/src/parser_yang.c
@@ -827,14 +827,14 @@
* @param[in] ctx yang parser context for logging.
* @param[in] ext_name Extension instance substatement name (keyword).
* @param[in] ext_name_len Extension instance substatement name length.
- * @param[in] insubstmt Type of the keyword this extension instance is a substatement of.
+ * @param[in] insubstmt The statement this extension instance is a substatement of.
* @param[in] insubstmt_index Index of the keyword instance this extension instance is a substatement of.
* @param[in,out] exts Extension instances to add to.
*
* @return LY_ERR values.
*/
static LY_ERR
-parse_ext(struct lys_yang_parser_ctx *ctx, const char *ext_name, size_t ext_name_len, LYEXT_SUBSTMT insubstmt,
+parse_ext(struct lys_yang_parser_ctx *ctx, const char *ext_name, size_t ext_name_len, enum ly_stmt insubstmt,
LY_ARRAY_COUNT_TYPE insubstmt_index, struct lysp_ext_instance **exts)
{
LY_ERR ret = LY_SUCCESS;
@@ -885,7 +885,7 @@
* @return LY_ERR values.
*/
static LY_ERR
-parse_text_field(struct lys_yang_parser_ctx *ctx, LYEXT_SUBSTMT substmt, uint32_t substmt_index,
+parse_text_field(struct lys_yang_parser_ctx *ctx, enum ly_stmt substmt, uint32_t substmt_index,
const char **value, enum yang_arg arg, struct lysp_ext_instance **exts)
{
LY_ERR ret = LY_SUCCESS;
@@ -956,7 +956,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_YANG_VERSION, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_YANG_VERSION, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "yang-version");
@@ -1001,10 +1001,10 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks) {
switch (kw) {
case LY_STMT_PREFIX:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_PREFIX, 0, prefix, Y_IDENTIF_ARG, exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PREFIX, 0, prefix, Y_IDENTIF_ARG, exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_BELONGS_TO, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_BELONGS_TO, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "belongs-to");
@@ -1059,7 +1059,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_REVISION_DATE, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_REVISION_DATE, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "revision-date");
@@ -1105,17 +1105,17 @@
switch (kw) {
case LY_STMT_DESCRIPTION:
PARSER_CHECK_STMTVER2_RET(ctx, "description", "include");
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &inc->dsc, Y_STR_ARG, &inc->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &inc->dsc, Y_STR_ARG, &inc->exts));
break;
case LY_STMT_REFERENCE:
PARSER_CHECK_STMTVER2_RET(ctx, "reference", "include");
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &inc->ref, Y_STR_ARG, &inc->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &inc->ref, Y_STR_ARG, &inc->exts));
break;
case LY_STMT_REVISION_DATE:
LY_CHECK_RET(parse_revisiondate(ctx, inc->rev, &inc->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &inc->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &inc->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "include");
@@ -1152,22 +1152,22 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks) {
switch (kw) {
case LY_STMT_PREFIX:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_PREFIX, 0, &imp->prefix, Y_IDENTIF_ARG, &imp->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PREFIX, 0, &imp->prefix, Y_IDENTIF_ARG, &imp->exts));
LY_CHECK_RET(lysp_check_prefix((struct lys_parser_ctx *)ctx, *imports, module_prefix, &imp->prefix), LY_EVALID);
break;
case LY_STMT_DESCRIPTION:
PARSER_CHECK_STMTVER2_RET(ctx, "description", "import");
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &imp->dsc, Y_STR_ARG, &imp->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &imp->dsc, Y_STR_ARG, &imp->exts));
break;
case LY_STMT_REFERENCE:
PARSER_CHECK_STMTVER2_RET(ctx, "reference", "import");
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &imp->ref, Y_STR_ARG, &imp->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &imp->ref, Y_STR_ARG, &imp->exts));
break;
case LY_STMT_REVISION_DATE:
LY_CHECK_RET(parse_revisiondate(ctx, imp->rev, &imp->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &imp->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &imp->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "import");
@@ -1216,13 +1216,13 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &rev->dsc, Y_STR_ARG, &rev->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &rev->dsc, Y_STR_ARG, &rev->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &rev->ref, Y_STR_ARG, &rev->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &rev->ref, Y_STR_ARG, &rev->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &rev->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &rev->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "revision");
@@ -1244,7 +1244,7 @@
* @return LY_ERR values.
*/
static LY_ERR
-parse_text_fields(struct lys_yang_parser_ctx *ctx, LYEXT_SUBSTMT substmt, const char ***texts, enum yang_arg arg,
+parse_text_fields(struct lys_yang_parser_ctx *ctx, enum ly_stmt substmt, const char ***texts, enum yang_arg arg,
struct lysp_ext_instance **exts)
{
LY_ERR ret = LY_SUCCESS;
@@ -1285,7 +1285,7 @@
* @return LY_ERR values.
*/
static LY_ERR
-parse_qnames(struct lys_yang_parser_ctx *ctx, LYEXT_SUBSTMT substmt, struct lysp_qname **qnames,
+parse_qnames(struct lys_yang_parser_ctx *ctx, enum ly_stmt substmt, struct lysp_qname **qnames,
enum yang_arg arg, struct lysp_ext_instance **exts)
{
LY_ERR ret = LY_SUCCESS;
@@ -1354,7 +1354,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_CONFIG, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_CONFIG, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "config");
@@ -1403,7 +1403,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_MANDATORY, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MANDATORY, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "mandatory");
@@ -1439,19 +1439,19 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &restr->dsc, Y_STR_ARG, &restr->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &restr->dsc, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &restr->ref, Y_STR_ARG, &restr->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &restr->ref, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_ERROR_APP_TAG:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_ERROR_APP_TAG, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ERROR_APP_TAG, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_ERROR_MESSAGE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_ERROR_MESSAGE, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ERROR_MESSAGE, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &restr->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &restr->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(restr_kw));
@@ -1520,7 +1520,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_STATUS, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_STATUS, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "status");
@@ -1564,13 +1564,13 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &when->dsc, Y_STR_ARG, &when->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &when->dsc, Y_STR_ARG, &when->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &when->ref, Y_STR_ARG, &when->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &when->ref, Y_STR_ARG, &when->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &when->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &when->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "when");
@@ -1614,10 +1614,10 @@
LY_CHECK_RET(parse_config(ctx, &any->flags, &any->exts));
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &any->dsc, Y_STR_ARG, &any->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &any->dsc, Y_STR_ARG, &any->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &any->iffeatures, Y_STR_ARG, &any->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &any->iffeatures, Y_STR_ARG, &any->exts));
break;
case LY_STMT_MANDATORY:
LY_CHECK_RET(parse_mandatory(ctx, &any->flags, &any->exts));
@@ -1626,7 +1626,7 @@
LY_CHECK_RET(parse_restrs(ctx, kw, &any->musts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &any->ref, Y_STR_ARG, &any->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &any->ref, Y_STR_ARG, &any->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &any->flags, &any->exts));
@@ -1635,7 +1635,7 @@
LY_CHECK_RET(parse_when(ctx, &any->when));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &any->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &any->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw),
@@ -1715,7 +1715,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, val_kw == LY_STMT_VALUE ? LYEXT_SUBSTMT_VALUE : LYEXT_SUBSTMT_POSITION, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, val_kw == LY_STMT_VALUE ? LY_STMT_VALUE : LY_STMT_POSITION, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(val_kw));
@@ -1762,14 +1762,14 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &enm->dsc, Y_STR_ARG, &enm->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &enm->dsc, Y_STR_ARG, &enm->exts));
break;
case LY_STMT_IF_FEATURE:
PARSER_CHECK_STMTVER2_RET(ctx, "if-feature", ly_stmt2str(enum_kw));
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &enm->iffeatures, Y_STR_ARG, &enm->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &enm->iffeatures, Y_STR_ARG, &enm->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &enm->ref, Y_STR_ARG, &enm->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &enm->ref, Y_STR_ARG, &enm->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &enm->flags, &enm->exts));
@@ -1785,7 +1785,7 @@
LY_CHECK_RET(parse_type_enum_value_pos(ctx, kw, &enm->value, &enm->flags, &enm->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &enm->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &enm->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(enum_kw));
@@ -1846,7 +1846,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_FRACTION_DIGITS, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_FRACTION_DIGITS, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "fraction-digits");
@@ -1896,7 +1896,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_REQUIRE_INSTANCE, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_REQUIRE_INSTANCE, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "require-instance");
@@ -1951,7 +1951,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_MODIFIER, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MODIFIER, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "modifier");
@@ -2000,23 +2000,23 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &restr->dsc, Y_STR_ARG, &restr->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &restr->dsc, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &restr->ref, Y_STR_ARG, &restr->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &restr->ref, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_ERROR_APP_TAG:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_ERROR_APP_TAG, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ERROR_APP_TAG, 0, &restr->eapptag, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_ERROR_MESSAGE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_ERROR_MESSAGE, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ERROR_MESSAGE, 0, &restr->emsg, Y_STR_ARG, &restr->exts));
break;
case LY_STMT_MODIFIER:
PARSER_CHECK_STMTVER2_RET(ctx, "modifier", "pattern");
LY_CHECK_RET(parse_type_pattern_modifier(ctx, &restr->arg.str, &restr->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &restr->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &restr->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "pattern");
@@ -2059,7 +2059,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_BASE:
- LY_CHECK_RET(parse_text_fields(ctx, LYEXT_SUBSTMT_BASE, &type->bases, Y_PREF_IDENTIF_ARG, &type->exts));
+ LY_CHECK_RET(parse_text_fields(ctx, LY_STMT_BASE, &type->bases, Y_PREF_IDENTIF_ARG, &type->exts));
type->flags |= LYS_SET_BASE;
break;
case LY_STMT_BIT:
@@ -2087,11 +2087,11 @@
break;
case LY_STMT_PATH:
if (type->path) {
- LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, lyext_substmt2str(LYEXT_SUBSTMT_PATH));
+ LOGVAL_PARSER(ctx, LY_VCODE_DUPSTMT, lyext_substmt2str(LY_STMT_PATH));
return LY_EVALID;
}
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_PATH, 0, &str_path, Y_STR_ARG, &type->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PATH, 0, &str_path, Y_STR_ARG, &type->exts));
ret = ly_path_parse(PARSER_CTX(ctx), NULL, str_path, 0, LY_PATH_BEGIN_EITHER, LY_PATH_LREF_TRUE,
LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_LEAFREF, &type->path);
lydict_remove(PARSER_CTX(ctx), str_path);
@@ -2123,7 +2123,7 @@
type->flags |= LYS_SET_TYPE;
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &type->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &type->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "type");
@@ -2166,14 +2166,14 @@
LY_CHECK_RET(parse_config(ctx, &leaf->flags, &leaf->exts));
break;
case LY_STMT_DEFAULT:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DEFAULT, 0, &leaf->dflt.str, Y_STR_ARG, &leaf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DEFAULT, 0, &leaf->dflt.str, Y_STR_ARG, &leaf->exts));
leaf->dflt.mod = ctx->parsed_mod;
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &leaf->dsc, Y_STR_ARG, &leaf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &leaf->dsc, Y_STR_ARG, &leaf->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &leaf->iffeatures, Y_STR_ARG, &leaf->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &leaf->iffeatures, Y_STR_ARG, &leaf->exts));
break;
case LY_STMT_MANDATORY:
LY_CHECK_RET(parse_mandatory(ctx, &leaf->flags, &leaf->exts));
@@ -2182,7 +2182,7 @@
LY_CHECK_RET(parse_restrs(ctx, kw, &leaf->musts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &leaf->ref, Y_STR_ARG, &leaf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &leaf->ref, Y_STR_ARG, &leaf->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &leaf->flags, &leaf->exts));
@@ -2191,13 +2191,13 @@
LY_CHECK_RET(parse_type(ctx, &leaf->type));
break;
case LY_STMT_UNITS:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_UNITS, 0, &leaf->units, Y_STR_ARG, &leaf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_UNITS, 0, &leaf->units, Y_STR_ARG, &leaf->exts));
break;
case LY_STMT_WHEN:
LY_CHECK_RET(parse_when(ctx, &leaf->when));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &leaf->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &leaf->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "leaf");
@@ -2274,7 +2274,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MAX_ELEMENTS, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "max-elements");
@@ -2337,7 +2337,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_MIN_ELEMENTS, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "min-elements");
@@ -2386,7 +2386,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_ORDERED_BY, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_ORDERED_BY, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "ordered-by");
@@ -2430,13 +2430,13 @@
break;
case LY_STMT_DEFAULT:
PARSER_CHECK_STMTVER2_RET(ctx, "default", "leaf-list");
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_DEFAULT, &llist->dflts, Y_STR_ARG, &llist->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_DEFAULT, &llist->dflts, Y_STR_ARG, &llist->exts));
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &llist->dsc, Y_STR_ARG, &llist->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &llist->dsc, Y_STR_ARG, &llist->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &llist->iffeatures, Y_STR_ARG, &llist->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &llist->iffeatures, Y_STR_ARG, &llist->exts));
break;
case LY_STMT_MAX_ELEMENTS:
LY_CHECK_RET(parse_maxelements(ctx, &llist->max, &llist->flags, &llist->exts));
@@ -2451,7 +2451,7 @@
LY_CHECK_RET(parse_orderedby(ctx, &llist->flags, &llist->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &llist->ref, Y_STR_ARG, &llist->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &llist->ref, Y_STR_ARG, &llist->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &llist->flags, &llist->exts));
@@ -2460,13 +2460,13 @@
LY_CHECK_RET(parse_type(ctx, &llist->type));
break;
case LY_STMT_UNITS:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_UNITS, 0, &llist->units, Y_STR_ARG, &llist->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_UNITS, 0, &llist->units, Y_STR_ARG, &llist->exts));
break;
case LY_STMT_WHEN:
LY_CHECK_RET(parse_when(ctx, &llist->when));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &llist->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &llist->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "llist");
@@ -2514,14 +2514,14 @@
LY_CHECK_RET(parse_config(ctx, &rf->flags, &rf->exts));
break;
case LY_STMT_DEFAULT:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_DEFAULT, &rf->dflts, Y_STR_ARG, &rf->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_DEFAULT, &rf->dflts, Y_STR_ARG, &rf->exts));
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &rf->dsc, Y_STR_ARG, &rf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &rf->dsc, Y_STR_ARG, &rf->exts));
break;
case LY_STMT_IF_FEATURE:
PARSER_CHECK_STMTVER2_RET(ctx, "if-feature", "refine");
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &rf->iffeatures, Y_STR_ARG, &rf->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &rf->iffeatures, Y_STR_ARG, &rf->exts));
break;
case LY_STMT_MAX_ELEMENTS:
LY_CHECK_RET(parse_maxelements(ctx, &rf->max, &rf->flags, &rf->exts));
@@ -2536,13 +2536,13 @@
LY_CHECK_RET(parse_mandatory(ctx, &rf->flags, &rf->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &rf->ref, Y_STR_ARG, &rf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &rf->ref, Y_STR_ARG, &rf->exts));
break;
case LY_STMT_PRESENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_PRESENCE, 0, &rf->presence, Y_STR_ARG, &rf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PRESENCE, 0, &rf->presence, Y_STR_ARG, &rf->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &rf->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &rf->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "refine");
@@ -2579,14 +2579,14 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks) {
switch (kw) {
case LY_STMT_DEFAULT:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DEFAULT, 0, &tpdf->dflt.str, Y_STR_ARG, &tpdf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DEFAULT, 0, &tpdf->dflt.str, Y_STR_ARG, &tpdf->exts));
tpdf->dflt.mod = ctx->parsed_mod;
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &tpdf->dsc, Y_STR_ARG, &tpdf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &tpdf->dsc, Y_STR_ARG, &tpdf->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &tpdf->ref, Y_STR_ARG, &tpdf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &tpdf->ref, Y_STR_ARG, &tpdf->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &tpdf->flags, &tpdf->exts));
@@ -2595,10 +2595,10 @@
LY_CHECK_RET(parse_type(ctx, &tpdf->type));
break;
case LY_STMT_UNITS:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_UNITS, 0, &tpdf->units, Y_STR_ARG, &tpdf->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_UNITS, 0, &tpdf->units, Y_STR_ARG, &tpdf->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &tpdf->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &tpdf->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "typedef");
@@ -2688,7 +2688,7 @@
LY_CHECK_RET(parse_grouping(ctx, (struct lysp_node *)inout_p, &inout_p->groupings));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &inout_p->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &inout_p->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), ly_stmt2str(inout_kw));
@@ -2734,13 +2734,13 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &act->dsc, Y_STR_ARG, &act->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &act->dsc, Y_STR_ARG, &act->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &act->iffeatures, Y_STR_ARG, &act->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &act->iffeatures, Y_STR_ARG, &act->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &act->ref, Y_STR_ARG, &act->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &act->ref, Y_STR_ARG, &act->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &act->flags, &act->exts));
@@ -2760,7 +2760,7 @@
LY_CHECK_RET(parse_grouping(ctx, (struct lysp_node *)act, &act->groupings));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &act->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &act->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), parent ? "action" : "rpc");
@@ -2813,13 +2813,13 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, ¬if->dsc, Y_STR_ARG, ¬if->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, ¬if->dsc, Y_STR_ARG, ¬if->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, ¬if->iffeatures, Y_STR_ARG, ¬if->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, ¬if->iffeatures, Y_STR_ARG, ¬if->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, ¬if->ref, Y_STR_ARG, ¬if->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, ¬if->ref, Y_STR_ARG, ¬if->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, ¬if->flags, ¬if->exts));
@@ -2861,7 +2861,7 @@
LY_CHECK_RET(parse_grouping(ctx, (struct lysp_node *)notif, ¬if->groupings));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, ¬if->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, ¬if->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "notification");
@@ -2900,10 +2900,10 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &grp->dsc, Y_STR_ARG, &grp->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &grp->dsc, Y_STR_ARG, &grp->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &grp->ref, Y_STR_ARG, &grp->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &grp->ref, Y_STR_ARG, &grp->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &grp->flags, &grp->exts));
@@ -2949,7 +2949,7 @@
LY_CHECK_RET(parse_notif(ctx, &grp->node, &grp->notifs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &grp->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &grp->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "grouping");
@@ -2989,13 +2989,13 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &aug->dsc, Y_STR_ARG, &aug->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &aug->dsc, Y_STR_ARG, &aug->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &aug->iffeatures, Y_STR_ARG, &aug->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &aug->iffeatures, Y_STR_ARG, &aug->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &aug->ref, Y_STR_ARG, &aug->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &aug->ref, Y_STR_ARG, &aug->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &aug->flags, &aug->exts));
@@ -3041,7 +3041,7 @@
LY_CHECK_RET(parse_notif(ctx, (struct lysp_node *)aug, &aug->notifs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &aug->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &aug->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "augment");
@@ -3082,13 +3082,13 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &uses->dsc, Y_STR_ARG, &uses->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &uses->dsc, Y_STR_ARG, &uses->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &uses->iffeatures, Y_STR_ARG, &uses->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &uses->iffeatures, Y_STR_ARG, &uses->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &uses->ref, Y_STR_ARG, &uses->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &uses->ref, Y_STR_ARG, &uses->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &uses->flags, &uses->exts));
@@ -3104,7 +3104,7 @@
LY_CHECK_RET(parse_augment(ctx, (struct lysp_node *)uses, &uses->augments));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &uses->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &uses->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "uses");
@@ -3145,13 +3145,13 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &cas->dsc, Y_STR_ARG, &cas->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &cas->dsc, Y_STR_ARG, &cas->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &cas->iffeatures, Y_STR_ARG, &cas->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &cas->iffeatures, Y_STR_ARG, &cas->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &cas->ref, Y_STR_ARG, &cas->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &cas->ref, Y_STR_ARG, &cas->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &cas->flags, &cas->exts));
@@ -3185,7 +3185,7 @@
LY_CHECK_RET(parse_uses(ctx, (struct lysp_node *)cas, &cas->child));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &cas->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &cas->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "case");
@@ -3228,16 +3228,16 @@
LY_CHECK_RET(parse_config(ctx, &choice->flags, &choice->exts));
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &choice->dsc, Y_STR_ARG, &choice->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &choice->dsc, Y_STR_ARG, &choice->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &choice->iffeatures, Y_STR_ARG, &choice->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &choice->iffeatures, Y_STR_ARG, &choice->exts));
break;
case LY_STMT_MANDATORY:
LY_CHECK_RET(parse_mandatory(ctx, &choice->flags, &choice->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &choice->ref, Y_STR_ARG, &choice->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &choice->ref, Y_STR_ARG, &choice->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &choice->flags, &choice->exts));
@@ -3246,7 +3246,7 @@
LY_CHECK_RET(parse_when(ctx, &choice->when));
break;
case LY_STMT_DEFAULT:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DEFAULT, 0, &choice->dflt.str, Y_PREF_IDENTIF_ARG,
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DEFAULT, 0, &choice->dflt.str, Y_PREF_IDENTIF_ARG,
&choice->exts));
choice->dflt.mod = ctx->parsed_mod;
break;
@@ -3277,7 +3277,7 @@
LY_CHECK_RET(parse_list(ctx, (struct lysp_node *)choice, &choice->child));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &choice->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &choice->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "choice");
@@ -3320,13 +3320,13 @@
LY_CHECK_RET(parse_config(ctx, &cont->flags, &cont->exts));
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &cont->dsc, Y_STR_ARG, &cont->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &cont->dsc, Y_STR_ARG, &cont->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &cont->iffeatures, Y_STR_ARG, &cont->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &cont->iffeatures, Y_STR_ARG, &cont->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &cont->ref, Y_STR_ARG, &cont->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &cont->ref, Y_STR_ARG, &cont->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &cont->flags, &cont->exts));
@@ -3335,7 +3335,7 @@
LY_CHECK_RET(parse_when(ctx, &cont->when));
break;
case LY_STMT_PRESENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_PRESENCE, 0, &cont->presence, Y_STR_ARG, &cont->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PRESENCE, 0, &cont->presence, Y_STR_ARG, &cont->exts));
break;
case LY_STMT_ANYDATA:
@@ -3381,7 +3381,7 @@
LY_CHECK_RET(parse_notif(ctx, (struct lysp_node *)cont, &cont->notifs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &cont->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &cont->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "container");
@@ -3425,13 +3425,13 @@
LY_CHECK_RET(parse_config(ctx, &list->flags, &list->exts));
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &list->dsc, Y_STR_ARG, &list->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &list->dsc, Y_STR_ARG, &list->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &list->iffeatures, Y_STR_ARG, &list->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &list->iffeatures, Y_STR_ARG, &list->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &list->ref, Y_STR_ARG, &list->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &list->ref, Y_STR_ARG, &list->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &list->flags, &list->exts));
@@ -3440,7 +3440,7 @@
LY_CHECK_RET(parse_when(ctx, &list->when));
break;
case LY_STMT_KEY:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_KEY, 0, &list->key, Y_STR_ARG, &list->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_KEY, 0, &list->key, Y_STR_ARG, &list->exts));
break;
case LY_STMT_MAX_ELEMENTS:
LY_CHECK_RET(parse_maxelements(ctx, &list->max, &list->flags, &list->exts));
@@ -3452,7 +3452,7 @@
LY_CHECK_RET(parse_orderedby(ctx, &list->flags, &list->exts));
break;
case LY_STMT_UNIQUE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_UNIQUE, &list->uniques, Y_STR_ARG, &list->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_UNIQUE, &list->uniques, Y_STR_ARG, &list->exts));
break;
case LY_STMT_ANYDATA:
@@ -3498,7 +3498,7 @@
LY_CHECK_RET(parse_notif(ctx, (struct lysp_node *)list, &list->notifs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &list->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &list->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "list");
@@ -3548,7 +3548,7 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_YIN_ELEMENT, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_YIN_ELEMENT, 0, exts));
LY_CHECK_RET(ret);
break;
default:
@@ -3592,7 +3592,7 @@
LY_CHECK_RET(parse_yinelement(ctx, flags, exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_ARGUMENT, 0, exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_ARGUMENT, 0, exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "argument");
@@ -3628,10 +3628,10 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &ex->dsc, Y_STR_ARG, &ex->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &ex->dsc, Y_STR_ARG, &ex->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &ex->ref, Y_STR_ARG, &ex->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &ex->ref, Y_STR_ARG, &ex->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &ex->flags, &ex->exts));
@@ -3640,7 +3640,7 @@
LY_CHECK_RET(parse_argument(ctx, &ex->argument, &ex->flags, &ex->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &ex->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &ex->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "extension");
@@ -3757,11 +3757,11 @@
LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
return LY_EVALID;
case LYS_DEV_REPLACE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DEFAULT, 0, &d_rpl->dflt.str, Y_STR_ARG, &d->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DEFAULT, 0, &d_rpl->dflt.str, Y_STR_ARG, &d->exts));
d_rpl->dflt.mod = ctx->parsed_mod;
break;
default:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_DEFAULT, d_dflts, Y_STR_ARG, &d->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_DEFAULT, d_dflts, Y_STR_ARG, &d->exts));
break;
}
break;
@@ -3834,7 +3834,7 @@
LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
return LY_EVALID;
default:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_UNIQUE, d_uniques, Y_STR_ARG, &d->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_UNIQUE, d_uniques, Y_STR_ARG, &d->exts));
break;
}
break;
@@ -3844,12 +3844,12 @@
LOGVAL_PARSER(ctx, LY_VCODE_INDEV, ly_devmod2str(dev_mod), ly_stmt2str(kw));
return LY_EVALID;
default:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_UNITS, 0, d_units, Y_STR_ARG, &d->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_UNITS, 0, d_units, Y_STR_ARG, &d->exts));
break;
}
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &d->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &d->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "deviate");
@@ -3886,16 +3886,16 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, goto checks) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &dev->dsc, Y_STR_ARG, &dev->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &dev->dsc, Y_STR_ARG, &dev->exts));
break;
case LY_STMT_DEVIATE:
LY_CHECK_RET(parse_deviate(ctx, &dev->deviates));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &dev->ref, Y_STR_ARG, &dev->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &dev->ref, Y_STR_ARG, &dev->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &dev->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &dev->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "deviation");
@@ -3939,19 +3939,19 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &feat->dsc, Y_STR_ARG, &feat->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &feat->dsc, Y_STR_ARG, &feat->exts));
break;
case LY_STMT_IF_FEATURE:
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &feat->iffeatures, Y_STR_ARG, &feat->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &feat->iffeatures, Y_STR_ARG, &feat->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &feat->ref, Y_STR_ARG, &feat->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &feat->ref, Y_STR_ARG, &feat->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &feat->flags, &feat->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &feat->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &feat->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "feature");
@@ -3987,14 +3987,14 @@
YANG_READ_SUBSTMT_FOR(ctx, kw, word, word_len, ret, ) {
switch (kw) {
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &ident->dsc, Y_STR_ARG, &ident->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &ident->dsc, Y_STR_ARG, &ident->exts));
break;
case LY_STMT_IF_FEATURE:
PARSER_CHECK_STMTVER2_RET(ctx, "if-feature", "identity");
- LY_CHECK_RET(parse_qnames(ctx, LYEXT_SUBSTMT_IF_FEATURE, &ident->iffeatures, Y_STR_ARG, &ident->exts));
+ LY_CHECK_RET(parse_qnames(ctx, LY_STMT_IF_FEATURE, &ident->iffeatures, Y_STR_ARG, &ident->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &ident->ref, Y_STR_ARG, &ident->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &ident->ref, Y_STR_ARG, &ident->exts));
break;
case LY_STMT_STATUS:
LY_CHECK_RET(parse_status(ctx, &ident->flags, &ident->exts));
@@ -4004,10 +4004,10 @@
LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Identity can be derived from multiple base identities only in YANG 1.1 modules");
return LY_EVALID;
}
- LY_CHECK_RET(parse_text_fields(ctx, LYEXT_SUBSTMT_BASE, &ident->bases, Y_PREF_IDENTIF_ARG, &ident->exts));
+ LY_CHECK_RET(parse_text_fields(ctx, LY_STMT_BASE, &ident->bases, Y_PREF_IDENTIF_ARG, &ident->exts));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &ident->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &ident->exts));
break;
default:
LOGVAL_PARSER(ctx, LY_VCODE_INCHILDSTMT, ly_stmt2str(kw), "identity");
@@ -4106,10 +4106,10 @@
LY_CHECK_RET(parse_yangversion(ctx, &mod->version, &mod->exts));
break;
case LY_STMT_NAMESPACE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_NAMESPACE, 0, &mod->mod->ns, Y_STR_ARG, &mod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_NAMESPACE, 0, &mod->mod->ns, Y_STR_ARG, &mod->exts));
break;
case LY_STMT_PREFIX:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_PREFIX, 0, &mod->mod->prefix, Y_IDENTIF_ARG, &mod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_PREFIX, 0, &mod->mod->prefix, Y_IDENTIF_ARG, &mod->exts));
break;
/* linkage */
@@ -4122,16 +4122,16 @@
/* meta */
case LY_STMT_ORGANIZATION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, &mod->mod->org, Y_STR_ARG, &mod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ORGANIZATION, 0, &mod->mod->org, Y_STR_ARG, &mod->exts));
break;
case LY_STMT_CONTACT:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_CONTACT, 0, &mod->mod->contact, Y_STR_ARG, &mod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_CONTACT, 0, &mod->mod->contact, Y_STR_ARG, &mod->exts));
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &mod->mod->dsc, Y_STR_ARG, &mod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &mod->mod->dsc, Y_STR_ARG, &mod->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &mod->mod->ref, Y_STR_ARG, &mod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &mod->mod->ref, Y_STR_ARG, &mod->exts));
break;
/* revision */
@@ -4193,7 +4193,7 @@
LY_CHECK_RET(parse_typedef(ctx, NULL, &mod->typedefs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &mod->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &mod->exts));
break;
default:
@@ -4329,16 +4329,16 @@
/* meta */
case LY_STMT_ORGANIZATION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, &submod->org, Y_STR_ARG, &submod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_ORGANIZATION, 0, &submod->org, Y_STR_ARG, &submod->exts));
break;
case LY_STMT_CONTACT:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_CONTACT, 0, &submod->contact, Y_STR_ARG, &submod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_CONTACT, 0, &submod->contact, Y_STR_ARG, &submod->exts));
break;
case LY_STMT_DESCRIPTION:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, &submod->dsc, Y_STR_ARG, &submod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_DESCRIPTION, 0, &submod->dsc, Y_STR_ARG, &submod->exts));
break;
case LY_STMT_REFERENCE:
- LY_CHECK_RET(parse_text_field(ctx, LYEXT_SUBSTMT_REFERENCE, 0, &submod->ref, Y_STR_ARG, &submod->exts));
+ LY_CHECK_RET(parse_text_field(ctx, LY_STMT_REFERENCE, 0, &submod->ref, Y_STR_ARG, &submod->exts));
break;
/* revision */
@@ -4400,7 +4400,7 @@
LY_CHECK_RET(parse_typedef(ctx, NULL, &submod->typedefs));
break;
case LY_STMT_EXTENSION_INSTANCE:
- LY_CHECK_RET(parse_ext(ctx, word, word_len, LYEXT_SUBSTMT_SELF, 0, &submod->exts));
+ LY_CHECK_RET(parse_ext(ctx, word, word_len, LY_STMT_NONE, 0, &submod->exts));
break;
default:
diff --git a/src/parser_yin.c b/src/parser_yin.c
index 58a068c..90fbf78 100644
--- a/src/parser_yin.c
+++ b/src/parser_yin.c
@@ -2769,76 +2769,76 @@
*
* @return correct LYEXT_SUBSTMT information.
*/
-static LYEXT_SUBSTMT
+static enum ly_stmt
kw2lyext_substmt(enum ly_stmt kw)
{
switch (kw) {
case LY_STMT_ARGUMENT:
- return LYEXT_SUBSTMT_ARGUMENT;
+ return LY_STMT_ARGUMENT;
case LY_STMT_BASE:
- return LYEXT_SUBSTMT_BASE;
+ return LY_STMT_BASE;
case LY_STMT_BELONGS_TO:
- return LYEXT_SUBSTMT_BELONGS_TO;
+ return LY_STMT_BELONGS_TO;
case LY_STMT_CONTACT:
- return LYEXT_SUBSTMT_CONTACT;
+ return LY_STMT_CONTACT;
case LY_STMT_DEFAULT:
- return LYEXT_SUBSTMT_DEFAULT;
+ return LY_STMT_DEFAULT;
case LY_STMT_DESCRIPTION:
- return LYEXT_SUBSTMT_DESCRIPTION;
+ return LY_STMT_DESCRIPTION;
case LY_STMT_ERROR_APP_TAG:
- return LYEXT_SUBSTMT_ERROR_APP_TAG;
+ return LY_STMT_ERROR_APP_TAG;
case LY_STMT_ERROR_MESSAGE:
- return LYEXT_SUBSTMT_ERROR_MESSAGE;
+ return LY_STMT_ERROR_MESSAGE;
case LY_STMT_KEY:
- return LYEXT_SUBSTMT_KEY;
+ return LY_STMT_KEY;
case LY_STMT_NAMESPACE:
- return LYEXT_SUBSTMT_NAMESPACE;
+ return LY_STMT_NAMESPACE;
case LY_STMT_ORGANIZATION:
- return LYEXT_SUBSTMT_ORGANIZATION;
+ return LY_STMT_ORGANIZATION;
case LY_STMT_PATH:
- return LYEXT_SUBSTMT_PATH;
+ return LY_STMT_PATH;
case LY_STMT_PREFIX:
- return LYEXT_SUBSTMT_PREFIX;
+ return LY_STMT_PREFIX;
case LY_STMT_PRESENCE:
- return LYEXT_SUBSTMT_PRESENCE;
+ return LY_STMT_PRESENCE;
case LY_STMT_REFERENCE:
- return LYEXT_SUBSTMT_REFERENCE;
+ return LY_STMT_REFERENCE;
case LY_STMT_REVISION_DATE:
- return LYEXT_SUBSTMT_REVISION_DATE;
+ return LY_STMT_REVISION_DATE;
case LY_STMT_UNITS:
- return LYEXT_SUBSTMT_UNITS;
+ return LY_STMT_UNITS;
case LY_STMT_VALUE:
- return LYEXT_SUBSTMT_VALUE;
+ return LY_STMT_VALUE;
case LY_STMT_YANG_VERSION:
- return LYEXT_SUBSTMT_YANG_VERSION;
+ return LY_STMT_YANG_VERSION;
case LY_STMT_MODIFIER:
- return LYEXT_SUBSTMT_MODIFIER;
+ return LY_STMT_MODIFIER;
case LY_STMT_REQUIRE_INSTANCE:
- return LYEXT_SUBSTMT_REQUIRE_INSTANCE;
+ return LY_STMT_REQUIRE_INSTANCE;
case LY_STMT_YIN_ELEMENT:
- return LYEXT_SUBSTMT_YIN_ELEMENT;
+ return LY_STMT_YIN_ELEMENT;
case LY_STMT_CONFIG:
- return LYEXT_SUBSTMT_CONFIG;
+ return LY_STMT_CONFIG;
case LY_STMT_MANDATORY:
- return LYEXT_SUBSTMT_MANDATORY;
+ return LY_STMT_MANDATORY;
case LY_STMT_ORDERED_BY:
- return LYEXT_SUBSTMT_ORDERED_BY;
+ return LY_STMT_ORDERED_BY;
case LY_STMT_STATUS:
- return LYEXT_SUBSTMT_STATUS;
+ return LY_STMT_STATUS;
case LY_STMT_FRACTION_DIGITS:
- return LYEXT_SUBSTMT_FRACTION_DIGITS;
+ return LY_STMT_FRACTION_DIGITS;
case LY_STMT_MAX_ELEMENTS:
- return LYEXT_SUBSTMT_MAX_ELEMENTS;
+ return LY_STMT_MAX_ELEMENTS;
case LY_STMT_MIN_ELEMENTS:
- return LYEXT_SUBSTMT_MIN_ELEMENTS;
+ return LY_STMT_MIN_ELEMENTS;
case LY_STMT_POSITION:
- return LYEXT_SUBSTMT_POSITION;
+ return LY_STMT_POSITION;
case LY_STMT_UNIQUE:
- return LYEXT_SUBSTMT_UNIQUE;
+ return LY_STMT_UNIQUE;
case LY_STMT_IF_FEATURE:
- return LYEXT_SUBSTMT_IF_FEATURE;
+ return LY_STMT_IF_FEATURE;
default:
- return LYEXT_SUBSTMT_SELF;
+ return LY_STMT_NONE;
}
}
@@ -3214,14 +3214,14 @@
* @brief Parse instance of extension.
*
* @param[in,out] ctx Yin parser context for logging and to store current state.
- * @param[in] subelem Type of the keyword this extension instance is a subelement of.
+ * @param[in] subelem The statement this extension instance is a subelement of.
* @param[in] subelem_index Index of the keyword instance this extension instance is a subelement of
* @param[in,out] exts Extension instance to add to.
*
* @return LY_ERR values.
*/
LY_ERR
-yin_parse_extension_instance(struct lys_yin_parser_ctx *ctx, LYEXT_SUBSTMT subelem, LY_ARRAY_COUNT_TYPE subelem_index,
+yin_parse_extension_instance(struct lys_yin_parser_ctx *ctx, enum ly_stmt subelem, LY_ARRAY_COUNT_TYPE subelem_index,
struct lysp_ext_instance **exts)
{
struct lysp_ext_instance *e;
diff --git a/src/printer_yang.c b/src/printer_yang.c
index 0bca5ee..c08da2f 100644
--- a/src/printer_yang.c
+++ b/src/printer_yang.c
@@ -203,7 +203,7 @@
* @param[in] count Number of extensions to print, 0 to print them all.
*/
static void
-yprp_extension_instances(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index,
+yprp_extension_instances(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index,
struct lysp_ext_instance *ext, ly_bool *flag, LY_ARRAY_COUNT_TYPE count)
{
LY_ARRAY_COUNT_TYPE u;
@@ -260,11 +260,11 @@
}
}
-static void yprc_extension_instances(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index,
+static void yprc_extension_instances(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index,
struct lysc_ext_instance *ext, ly_bool *flag, LY_ARRAY_COUNT_TYPE count);
static void
-ypr_substmt(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, const char *text, void *ext)
+ypr_substmt(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index, const char *text, void *ext)
{
LY_ARRAY_COUNT_TYPE u;
ly_bool extflag = 0;
@@ -297,7 +297,7 @@
}
static void
-ypr_unsigned(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, void *exts, unsigned long int attr_value, ly_bool *flag)
+ypr_unsigned(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index, void *exts, unsigned long int attr_value, ly_bool *flag)
{
char *str;
@@ -311,7 +311,7 @@
}
static void
-ypr_signed(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, void *exts, signed long int attr_value, ly_bool *flag)
+ypr_signed(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index, void *exts, signed long int attr_value, ly_bool *flag)
{
char *str;
@@ -330,9 +330,9 @@
if (rev->dsc || rev->ref || rev->exts) {
ly_print_(ctx->out, "%*srevision %s {\n", INDENT, rev->date);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, rev->exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, rev->dsc, rev->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, rev->ref, rev->exts);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, rev->exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, rev->dsc, rev->exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, rev->ref, rev->exts);
LEVEL--;
ly_print_(ctx->out, "%*s}\n", INDENT);
} else {
@@ -345,7 +345,7 @@
{
if (flags & LYS_MAND_MASK) {
ypr_open(ctx->out, flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_MANDATORY, 0, (flags & LYS_MAND_TRUE) ? "true" : "false", exts);
+ ypr_substmt(ctx, LY_STMT_MANDATORY, 0, (flags & LYS_MAND_TRUE) ? "true" : "false", exts);
}
}
@@ -354,7 +354,7 @@
{
if (flags & LYS_CONFIG_MASK) {
ypr_open(ctx->out, flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_CONFIG, 0, (flags & LYS_CONFIG_W) ? "true" : "false", exts);
+ ypr_substmt(ctx, LY_STMT_CONFIG, 0, (flags & LYS_CONFIG_W) ? "true" : "false", exts);
}
}
@@ -374,7 +374,7 @@
status = "obsolete";
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_STATUS, 0, status, exts);
+ ypr_substmt(ctx, LY_STMT_STATUS, 0, status, exts);
}
static void
@@ -382,7 +382,7 @@
{
if (dsc) {
ypr_open(ctx->out, flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, dsc, exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, dsc, exts);
}
}
@@ -391,7 +391,7 @@
{
if (ref) {
ypr_open(ctx->out, flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, ref, exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, ref, exts);
}
}
@@ -410,7 +410,7 @@
/* extensions */
LEVEL++;
LY_ARRAY_FOR(exts, v) {
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_IF_FEATURE, u, &exts[v], &extflag, 1);
+ yprp_extension_instances(ctx, LY_STMT_IF_FEATURE, u, &exts[v], &extflag, 1);
}
LEVEL--;
ypr_close(ctx, extflag);
@@ -427,7 +427,7 @@
LEVEL++;
if (ext->exts) {
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ext->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, ext->exts, &flag, 0);
}
if (ext->argument) {
@@ -436,14 +436,14 @@
LEVEL++;
if (ext->exts) {
u = -1;
- while ((u = lysp_ext_instance_iter(ext->exts, u + 1, LYEXT_SUBSTMT_ARGUMENT)) != LY_ARRAY_COUNT(ext->exts)) {
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_ARGUMENT, 0, &ext->exts[u], &flag2, 1);
+ while ((u = lysp_ext_instance_iter(ext->exts, u + 1, LY_STMT_ARGUMENT)) != LY_ARRAY_COUNT(ext->exts)) {
+ yprp_extension_instances(ctx, LY_STMT_ARGUMENT, 0, &ext->exts[u], &flag2, 1);
}
}
if ((ext->flags & LYS_YINELEM_MASK) ||
- (ext->exts && (lysp_ext_instance_iter(ext->exts, 0, LYEXT_SUBSTMT_YIN_ELEMENT) != LY_ARRAY_COUNT(ext->exts)))) {
+ (ext->exts && (lysp_ext_instance_iter(ext->exts, 0, LY_STMT_YIN_ELEMENT) != LY_ARRAY_COUNT(ext->exts)))) {
ypr_open(ctx->out, &flag2);
- ypr_substmt(ctx, LYEXT_SUBSTMT_YIN_ELEMENT, 0, (ext->flags & LYS_YINELEM_TRUE) ? "true" : "false", ext->exts);
+ ypr_substmt(ctx, LY_STMT_YIN_ELEMENT, 0, (ext->flags & LYS_YINELEM_TRUE) ? "true" : "false", ext->exts);
}
LEVEL--;
ypr_close(ctx, flag2);
@@ -464,7 +464,7 @@
ly_print_(ctx->out, "\n%*sfeature %s", INDENT, feat->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, feat->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, feat->exts, &flag, 0);
yprp_iffeatures(ctx, feat->iffeatures, feat->exts, &flag);
ypr_status(ctx, feat->flags, feat->exts, &flag);
ypr_description(ctx, feat->dsc, feat->exts, &flag);
@@ -482,12 +482,12 @@
ly_print_(ctx->out, "\n%*sidentity %s", INDENT, ident->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ident->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, ident->exts, &flag, 0);
yprp_iffeatures(ctx, ident->iffeatures, ident->exts, &flag);
LY_ARRAY_FOR(ident->bases, u) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_BASE, u, ident->bases[u], ident->exts);
+ ypr_substmt(ctx, LY_STMT_BASE, u, ident->bases[u], ident->exts);
}
ypr_status(ctx, ident->flags, ident->exts, &flag);
@@ -507,7 +507,7 @@
ly_print_(ctx->out, "\n%*sidentity %s", INDENT, ident->name);
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ident->exts, &flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, ident->exts, &flag, 0);
LY_ARRAY_FOR(ident->derived, u) {
ypr_open(ctx->out, &flag);
@@ -543,19 +543,19 @@
ly_print_(ctx->out, "\"");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, restr->exts, &inner_flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, restr->exts, &inner_flag, 0);
if (restr->arg.str[0] == LYSP_RESTR_PATTERN_NACK) {
/* special byte value in pattern's expression: 0x15 - invert-match, 0x06 - match */
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_MODIFIER, 0, "invert-match", restr->exts);
+ ypr_substmt(ctx, LY_STMT_MODIFIER, 0, "invert-match", restr->exts);
}
if (restr->emsg) {
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_MESSAGE, 0, restr->emsg, restr->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_MESSAGE, 0, restr->emsg, restr->exts);
}
if (restr->eapptag) {
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_APP_TAG, 0, restr->eapptag, restr->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_APP_TAG, 0, restr->eapptag, restr->exts);
}
ypr_description(ctx, restr->dsc, restr->exts, &inner_flag);
ypr_reference(ctx, restr->ref, restr->exts, &inner_flag);
@@ -575,14 +575,14 @@
ly_print_(ctx->out, "\"");
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, must->exts, &inner_flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, must->exts, &inner_flag, 0);
if (must->emsg) {
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_MESSAGE, 0, must->emsg, must->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_MESSAGE, 0, must->emsg, must->exts);
}
if (must->eapptag) {
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_APP_TAG, 0, must->eapptag, must->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_APP_TAG, 0, must->eapptag, must->exts);
}
ypr_description(ctx, must->dsc, must->exts, &inner_flag);
ypr_reference(ctx, must->ref, must->exts, &inner_flag);
@@ -624,14 +624,14 @@
ly_print_(ctx->out, "\"");
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, range->exts, &inner_flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, range->exts, &inner_flag, 0);
if (range->emsg) {
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_MESSAGE, 0, range->emsg, range->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_MESSAGE, 0, range->emsg, range->exts);
}
if (range->eapptag) {
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_APP_TAG, 0, range->eapptag, range->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_APP_TAG, 0, range->eapptag, range->exts);
}
ypr_description(ctx, range->dsc, range->exts, &inner_flag);
ypr_reference(ctx, range->ref, range->exts, &inner_flag);
@@ -651,19 +651,19 @@
ly_print_(ctx->out, "\"");
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, pattern->exts, &inner_flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, pattern->exts, &inner_flag, 0);
if (pattern->inverted) {
/* special byte value in pattern's expression: 0x15 - invert-match, 0x06 - match */
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_MODIFIER, 0, "invert-match", pattern->exts);
+ ypr_substmt(ctx, LY_STMT_MODIFIER, 0, "invert-match", pattern->exts);
}
if (pattern->emsg) {
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_MESSAGE, 0, pattern->emsg, pattern->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_MESSAGE, 0, pattern->emsg, pattern->exts);
}
if (pattern->eapptag) {
ypr_open(ctx->out, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_APP_TAG, 0, pattern->eapptag, pattern->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_APP_TAG, 0, pattern->eapptag, pattern->exts);
}
ypr_description(ctx, pattern->dsc, pattern->exts, &inner_flag);
ypr_reference(ctx, pattern->ref, pattern->exts, &inner_flag);
@@ -687,7 +687,7 @@
ly_print_(ctx->out, "\"");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, when->exts, &inner_flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, when->exts, &inner_flag, 0);
ypr_description(ctx, when->dsc, when->exts, &inner_flag);
ypr_reference(ctx, when->ref, when->exts, &inner_flag);
LEVEL--;
@@ -709,7 +709,7 @@
ly_print_(ctx->out, "\"");
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, when->exts, &inner_flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, when->exts, &inner_flag, 0);
ypr_description(ctx, when->dsc, when->exts, &inner_flag);
ypr_reference(ctx, when->ref, when->exts, &inner_flag);
LEVEL--;
@@ -733,13 +733,13 @@
}
inner_flag = 0;
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, items[u].exts, &inner_flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, items[u].exts, &inner_flag, 0);
yprp_iffeatures(ctx, items[u].iffeatures, items[u].exts, &inner_flag);
if (items[u].flags & LYS_SET_VALUE) {
if (type == LY_TYPE_BITS) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_POSITION, 0, items[u].exts, items[u].value, &inner_flag);
+ ypr_unsigned(ctx, LY_STMT_POSITION, 0, items[u].exts, items[u].value, &inner_flag);
} else { /* LY_TYPE_ENUM */
- ypr_signed(ctx, LYEXT_SUBSTMT_VALUE, 0, items[u].exts, items[u].value, &inner_flag);
+ ypr_signed(ctx, LY_STMT_VALUE, 0, items[u].exts, items[u].value, &inner_flag);
}
}
ypr_status(ctx, items[u].flags, items[u].exts, &inner_flag);
@@ -759,7 +759,7 @@
ly_print_(ctx->out, "%*stype %s", INDENT, type->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, type->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, type->exts, &flag, 0);
yprp_restr(ctx, type->range, "range", &flag);
yprp_restr(ctx, type->length, "length", &flag);
@@ -771,18 +771,18 @@
if (type->path) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PATH, 0, type->path->expr, type->exts);
+ ypr_substmt(ctx, LY_STMT_PATH, 0, type->path->expr, type->exts);
}
if (type->flags & LYS_SET_REQINST) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REQUIRE_INSTANCE, 0, type->require_instance ? "true" : "false", type->exts);
+ ypr_substmt(ctx, LY_STMT_REQUIRE_INSTANCE, 0, type->require_instance ? "true" : "false", type->exts);
}
if (type->flags & LYS_SET_FRDIGITS) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_FRACTION_DIGITS, 0, type->exts, type->fraction_digits, &flag);
+ ypr_unsigned(ctx, LY_STMT_FRACTION_DIGITS, 0, type->exts, type->fraction_digits, &flag);
}
LY_ARRAY_FOR(type->bases, u) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_BASE, u, type->bases[u], type->exts);
+ ypr_substmt(ctx, LY_STMT_BASE, u, type->bases[u], type->exts);
}
LY_ARRAY_FOR(type->types, u) {
ypr_open(ctx->out, &flag);
@@ -800,7 +800,7 @@
const char *str;
str = value->realtype->plugin->print(value, LY_PREF_JSON, NULL, &dynamic);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, str, exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, str, exts);
if (dynamic) {
free((void *)str);
}
@@ -815,7 +815,7 @@
ly_print_(ctx->out, "%*stype %s", INDENT, lys_datatype2str(type->basetype));
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, type->exts, &flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, type->exts, &flag, 0);
switch (type->basetype) {
case LY_TYPE_BINARY: {
@@ -856,11 +856,11 @@
ypr_encode(ctx->out, item->name, -1);
ly_print_(ctx->out, "\"");
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, item->exts, &inner_flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, item->exts, &inner_flag, 0);
if (type->basetype == LY_TYPE_BITS) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_POSITION, 0, item->exts, item->position, &inner_flag);
+ ypr_unsigned(ctx, LY_STMT_POSITION, 0, item->exts, item->position, &inner_flag);
} else { /* LY_TYPE_ENUM */
- ypr_signed(ctx, LYEXT_SUBSTMT_VALUE, 0, item->exts, item->value, &inner_flag);
+ ypr_signed(ctx, LY_STMT_VALUE, 0, item->exts, item->value, &inner_flag);
}
ypr_status(ctx, item->flags, item->exts, &inner_flag);
ypr_description(ctx, item->dsc, item->exts, &inner_flag);
@@ -877,7 +877,7 @@
case LY_TYPE_DEC64: {
struct lysc_type_dec *dec = (struct lysc_type_dec *)type;
ypr_open(ctx->out, &flag);
- ypr_unsigned(ctx, LYEXT_SUBSTMT_FRACTION_DIGITS, 0, type->exts, dec->fraction_digits, &flag);
+ ypr_unsigned(ctx, LY_STMT_FRACTION_DIGITS, 0, type->exts, dec->fraction_digits, &flag);
yprc_range(ctx, dec->range, dec->basetype, &flag);
break;
}
@@ -885,21 +885,21 @@
struct lysc_type_identityref *ident = (struct lysc_type_identityref *)type;
LY_ARRAY_FOR(ident->bases, u) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_BASE, u, ident->bases[u]->name, type->exts);
+ ypr_substmt(ctx, LY_STMT_BASE, u, ident->bases[u]->name, type->exts);
}
break;
}
case LY_TYPE_INST: {
struct lysc_type_instanceid *inst = (struct lysc_type_instanceid *)type;
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REQUIRE_INSTANCE, 0, inst->require_instance ? "true" : "false", inst->exts);
+ ypr_substmt(ctx, LY_STMT_REQUIRE_INSTANCE, 0, inst->require_instance ? "true" : "false", inst->exts);
break;
}
case LY_TYPE_LEAFREF: {
struct lysc_type_leafref *lr = (struct lysc_type_leafref *)type;
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PATH, 0, lr->path->expr, lr->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REQUIRE_INSTANCE, 0, lr->require_instance ? "true" : "false", lr->exts);
+ ypr_substmt(ctx, LY_STMT_PATH, 0, lr->path->expr, lr->exts);
+ ypr_substmt(ctx, LY_STMT_REQUIRE_INSTANCE, 0, lr->require_instance ? "true" : "false", lr->exts);
yprc_type(ctx, lr->realtype);
break;
}
@@ -925,15 +925,15 @@
ly_print_(ctx->out, "\n%*stypedef %s {\n", INDENT, tpdf->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, tpdf->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, tpdf->exts, NULL, 0);
yprp_type(ctx, &tpdf->type);
if (tpdf->units) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, tpdf->units, tpdf->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, tpdf->units, tpdf->exts);
}
if (tpdf->dflt.str) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, tpdf->dflt.str, tpdf->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, tpdf->dflt.str, tpdf->exts);
}
ypr_status(ctx, tpdf->flags, tpdf->exts, NULL);
@@ -962,7 +962,7 @@
ly_print_(ctx->out, "\n%*sgrouping %s", INDENT, grp->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, grp->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, grp->exts, &flag, 0);
ypr_status(ctx, grp->flags, grp->exts, &flag);
ypr_description(ctx, grp->dsc, grp->exts, &flag);
ypr_reference(ctx, grp->ref, grp->exts, &flag);
@@ -1012,7 +1012,7 @@
ly_print_(ctx->out, "\n%*s%s {\n", INDENT, inout->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, inout->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, inout->exts, NULL, 0);
LY_ARRAY_FOR(inout->musts, u) {
yprp_restr(ctx, &inout->musts[u], "must", NULL);
}
@@ -1046,7 +1046,7 @@
ly_print_(ctx->out, "\n%*s%s {\n", INDENT, inout->name);
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, inout->exts, NULL, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, inout->exts, NULL, 0);
LY_ARRAY_FOR(inout->musts, u) {
yprc_must(ctx, &inout->musts[u], NULL);
}
@@ -1072,7 +1072,7 @@
ly_print_(ctx->out, "%*snotification %s", INDENT, notif->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, notif->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, notif->exts, &flag, 0);
yprp_iffeatures(ctx, notif->iffeatures, notif->exts, &flag);
LY_ARRAY_FOR(notif->musts, u) {
@@ -1111,7 +1111,7 @@
ly_print_(ctx->out, "%*snotification %s", INDENT, notif->name);
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, notif->exts, &flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, notif->exts, &flag, 0);
LY_ARRAY_FOR(notif->musts, u) {
yprc_must(ctx, ¬if->musts[u], &flag);
@@ -1141,7 +1141,7 @@
ly_print_(ctx->out, "%*s%s %s", INDENT, action->parent ? "action" : "rpc", action->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, action->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, action->exts, &flag, 0);
yprp_iffeatures(ctx, action->iffeatures, action->exts, &flag);
ypr_status(ctx, action->flags, action->exts, &flag);
ypr_description(ctx, action->dsc, action->exts, &flag);
@@ -1172,7 +1172,7 @@
ly_print_(ctx->out, "%*s%s %s", INDENT, action->parent ? "action" : "rpc", action->name);
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, action->exts, &flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, action->exts, &flag, 0);
ypr_status(ctx, action->flags, action->exts, &flag);
ypr_description(ctx, action->dsc, action->exts, &flag);
ypr_reference(ctx, action->ref, action->exts, &flag);
@@ -1190,7 +1190,7 @@
ly_print_(ctx->out, "%*s%s %s%s", INDENT, lys_nodetype2str(node->nodetype), node->name, flag ? "" : " {\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, node->exts, flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, node->exts, flag, 0);
yprp_when(ctx, lysp_node_when(node), flag);
yprp_iffeatures(ctx, node->iffeatures, node->exts, flag);
}
@@ -1204,7 +1204,7 @@
ly_print_(ctx->out, "%*s%s %s%s", INDENT, lys_nodetype2str(node->nodetype), node->name, flag ? "" : " {\n");
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, node->exts, flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, node->exts, flag, 0);
when = lysc_node_when(node);
LY_ARRAY_FOR(when, u) {
@@ -1254,7 +1254,7 @@
}
if (cont->presence) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, cont->presence, cont->exts);
+ ypr_substmt(ctx, LY_STMT_PRESENCE, 0, cont->presence, cont->exts);
}
yprp_node_common2(ctx, node, &flag);
@@ -1305,7 +1305,7 @@
}
if (cont->flags & LYS_PRESENCE) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, "true", cont->exts);
+ ypr_substmt(ctx, LY_STMT_PRESENCE, 0, "true", cont->exts);
}
yprc_node_common2(ctx, node, &flag);
@@ -1381,7 +1381,7 @@
if (choice->dflt.str) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, choice->dflt.str, choice->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, choice->dflt.str, choice->exts);
}
yprp_node_common2(ctx, node, &flag);
@@ -1406,7 +1406,7 @@
if (choice->dflt) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, choice->dflt->name, choice->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, choice->dflt->name, choice->exts);
}
yprc_node_common2(ctx, node, &flag);
@@ -1429,11 +1429,11 @@
yprp_node_common1(ctx, node, NULL);
yprp_type(ctx, &leaf->type);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, leaf->units, leaf->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, leaf->units, leaf->exts);
LY_ARRAY_FOR(leaf->musts, u) {
yprp_restr(ctx, &leaf->musts[u], "must", NULL);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, leaf->dflt.str, leaf->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, leaf->dflt.str, leaf->exts);
yprp_node_common2(ctx, node, NULL);
@@ -1450,7 +1450,7 @@
yprc_node_common1(ctx, node, NULL);
yprc_type(ctx, leaf->type);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, leaf->units, leaf->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, leaf->units, leaf->exts);
LY_ARRAY_FOR(leaf->musts, u) {
yprc_must(ctx, &leaf->musts[u], NULL);
}
@@ -1474,29 +1474,29 @@
yprp_node_common1(ctx, node, NULL);
yprp_type(ctx, &llist->type);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, llist->units, llist->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, llist->units, llist->exts);
LY_ARRAY_FOR(llist->musts, u) {
yprp_restr(ctx, &llist->musts[u], "must", NULL);
}
LY_ARRAY_FOR(llist->dflts, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, llist->dflts[u].str, llist->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, u, llist->dflts[u].str, llist->exts);
}
ypr_config(ctx, node->flags, node->exts, NULL);
if (llist->flags & LYS_SET_MIN) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, llist->exts, llist->min, NULL);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, llist->exts, llist->min, NULL);
}
if (llist->flags & LYS_SET_MAX) {
if (llist->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, llist->exts, llist->max, NULL);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, llist->exts, llist->max, NULL);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", llist->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", llist->exts);
}
}
if (llist->flags & LYS_ORDBY_MASK) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORDERED_BY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
+ ypr_substmt(ctx, LY_STMT_ORDERED_BY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
}
ypr_status(ctx, node->flags, node->exts, NULL);
@@ -1516,7 +1516,7 @@
yprc_node_common1(ctx, node, NULL);
yprc_type(ctx, llist->type);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, llist->units, llist->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, llist->units, llist->exts);
LY_ARRAY_FOR(llist->musts, u) {
yprc_must(ctx, &llist->musts[u], NULL);
}
@@ -1526,14 +1526,14 @@
ypr_config(ctx, node->flags, node->exts, NULL);
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, llist->exts, llist->min, NULL);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, llist->exts, llist->min, NULL);
if (llist->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, llist->exts, llist->max, NULL);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, llist->exts, llist->max, NULL);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", llist->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", llist->exts);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORDERED_BY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
+ ypr_substmt(ctx, LY_STMT_ORDERED_BY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
ypr_status(ctx, node->flags, node->exts, NULL);
ypr_description(ctx, node->dsc, node->exts, NULL);
@@ -1561,30 +1561,30 @@
}
if (list->key) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_KEY, 0, list->key, list->exts);
+ ypr_substmt(ctx, LY_STMT_KEY, 0, list->key, list->exts);
}
LY_ARRAY_FOR(list->uniques, u) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, list->uniques[u].str, list->exts);
+ ypr_substmt(ctx, LY_STMT_UNIQUE, u, list->uniques[u].str, list->exts);
}
ypr_config(ctx, node->flags, node->exts, &flag);
if (list->flags & LYS_SET_MIN) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, list->exts, list->min, &flag);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, list->exts, list->min, &flag);
}
if (list->flags & LYS_SET_MAX) {
if (list->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, list->exts, list->max, &flag);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, list->exts, list->max, &flag);
} else {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", list->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", list->exts);
}
}
if (list->flags & LYS_ORDBY_MASK) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORDERED_BY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
+ ypr_substmt(ctx, LY_STMT_ORDERED_BY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
}
ypr_status(ctx, node->flags, node->exts, &flag);
@@ -1648,14 +1648,14 @@
ypr_config(ctx, node->flags, node->exts, NULL);
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, list->exts, list->min, NULL);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, list->exts, list->min, NULL);
if (list->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, list->exts, list->max, NULL);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, list->exts, list->max, NULL);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", list->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", list->exts);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORDERED_BY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
+ ypr_substmt(ctx, LY_STMT_ORDERED_BY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
ypr_status(ctx, node->flags, node->exts, NULL);
ypr_description(ctx, node->dsc, node->exts, NULL);
@@ -1692,7 +1692,7 @@
ly_print_(ctx->out, "%*srefine \"%s\"", INDENT, refine->nodeid);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, refine->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, refine->exts, &flag, 0);
yprp_iffeatures(ctx, refine->iffeatures, refine->exts, &flag);
LY_ARRAY_FOR(refine->musts, u) {
@@ -1702,12 +1702,12 @@
if (refine->presence) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, refine->presence, refine->exts);
+ ypr_substmt(ctx, LY_STMT_PRESENCE, 0, refine->presence, refine->exts);
}
LY_ARRAY_FOR(refine->dflts, u) {
ypr_open(ctx->out, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, refine->dflts[u].str, refine->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, u, refine->dflts[u].str, refine->exts);
}
ypr_config(ctx, refine->flags, refine->exts, &flag);
@@ -1715,14 +1715,14 @@
if (refine->flags & LYS_SET_MIN) {
ypr_open(ctx->out, &flag);
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, refine->exts, refine->min, NULL);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, refine->exts, refine->min, NULL);
}
if (refine->flags & LYS_SET_MAX) {
ypr_open(ctx->out, &flag);
if (refine->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, refine->exts, refine->max, NULL);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, refine->exts, refine->max, NULL);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", refine->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", refine->exts);
}
}
@@ -1743,7 +1743,7 @@
ly_print_(ctx->out, "%*saugment \"%s\" {\n", INDENT, aug->nodeid);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, aug->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, aug->exts, NULL, 0);
yprp_when(ctx, aug->when, NULL);
yprp_iffeatures(ctx, aug->iffeatures, aug->exts, NULL);
ypr_status(ctx, aug->flags, aug->exts, NULL);
@@ -1905,7 +1905,7 @@
ly_print_(ctx->out, "%*sdeviation \"%s\" {\n", INDENT, deviation->nodeid);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, deviation->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, deviation->exts, NULL, 0);
ypr_description(ctx, deviation->dsc, deviation->exts, NULL);
ypr_reference(ctx, deviation->ref, deviation->exts, NULL);
@@ -1916,7 +1916,7 @@
ly_print_(ctx->out, "not-supported {\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, elem->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, elem->exts, NULL, 0);
} else {
ly_print_(ctx->out, "not-supported;\n");
continue;
@@ -1926,27 +1926,27 @@
ly_print_(ctx->out, "add {\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, add->exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, add->units, add->exts);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, add->exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, add->units, add->exts);
LY_ARRAY_FOR(add->musts, u) {
yprp_restr(ctx, &add->musts[u], "must", NULL);
}
LY_ARRAY_FOR(add->uniques, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, add->uniques[u].str, add->exts);
+ ypr_substmt(ctx, LY_STMT_UNIQUE, u, add->uniques[u].str, add->exts);
}
LY_ARRAY_FOR(add->dflts, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, add->dflts[u].str, add->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, u, add->dflts[u].str, add->exts);
}
ypr_config(ctx, add->flags, add->exts, NULL);
ypr_mandatory(ctx, add->flags, add->exts, NULL);
if (add->flags & LYS_SET_MIN) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, add->exts, add->min, NULL);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, add->exts, add->min, NULL);
}
if (add->flags & LYS_SET_MAX) {
if (add->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, add->exts, add->max, NULL);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, add->exts, add->max, NULL);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", add->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", add->exts);
}
}
} else if (elem->mod == LYS_DEV_REPLACE) {
@@ -1954,22 +1954,22 @@
ly_print_(ctx->out, "replace {\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, rpl->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, rpl->exts, NULL, 0);
if (rpl->type) {
yprp_type(ctx, rpl->type);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, rpl->units, rpl->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, rpl->dflt.str, rpl->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, rpl->units, rpl->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, rpl->dflt.str, rpl->exts);
ypr_config(ctx, rpl->flags, rpl->exts, NULL);
ypr_mandatory(ctx, rpl->flags, rpl->exts, NULL);
if (rpl->flags & LYS_SET_MIN) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, rpl->exts, rpl->min, NULL);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, rpl->exts, rpl->min, NULL);
}
if (rpl->flags & LYS_SET_MAX) {
if (rpl->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, rpl->exts, rpl->max, NULL);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, rpl->exts, rpl->max, NULL);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", rpl->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", rpl->exts);
}
}
} else if (elem->mod == LYS_DEV_DELETE) {
@@ -1977,16 +1977,16 @@
ly_print_(ctx->out, "delete {\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, del->exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, del->units, del->exts);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, del->exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, del->units, del->exts);
LY_ARRAY_FOR(del->musts, u) {
yprp_restr(ctx, &del->musts[u], "must", NULL);
}
LY_ARRAY_FOR(del->uniques, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, del->uniques[u].str, del->exts);
+ ypr_substmt(ctx, LY_STMT_UNIQUE, u, del->uniques[u].str, del->exts);
}
LY_ARRAY_FOR(del->dflts, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, del->dflts[u].str, del->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, u, del->dflts[u].str, del->exts);
}
}
@@ -2010,13 +2010,13 @@
ly_print_(ctx->out, "%s%*simport %s {\n", u ? "" : "\n", INDENT, modp->imports[u].name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->imports[u].exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, modp->imports[u].prefix, modp->imports[u].exts);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, modp->imports[u].exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_PREFIX, 0, modp->imports[u].prefix, modp->imports[u].exts);
if (modp->imports[u].rev[0]) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_REVISION_DATE, 0, modp->imports[u].rev, modp->imports[u].exts);
+ ypr_substmt(ctx, LY_STMT_REVISION_DATE, 0, modp->imports[u].rev, modp->imports[u].exts);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, modp->imports[u].dsc, modp->imports[u].exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, modp->imports[u].ref, modp->imports[u].exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, modp->imports[u].dsc, modp->imports[u].exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, modp->imports[u].ref, modp->imports[u].exts);
LEVEL--;
ly_print_(ctx->out, "%*s}\n", INDENT);
}
@@ -2028,12 +2028,12 @@
if (modp->includes[u].rev[0] || modp->includes[u].dsc || modp->includes[u].ref || modp->includes[u].exts) {
ly_print_(ctx->out, "%s%*sinclude %s {\n", u ? "" : "\n", INDENT, modp->includes[u].name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->includes[u].exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, modp->includes[u].exts, NULL, 0);
if (modp->includes[u].rev[0]) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_REVISION_DATE, 0, modp->includes[u].rev, modp->includes[u].exts);
+ ypr_substmt(ctx, LY_STMT_REVISION_DATE, 0, modp->includes[u].rev, modp->includes[u].exts);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, modp->includes[u].dsc, modp->includes[u].exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, modp->includes[u].ref, modp->includes[u].exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, modp->includes[u].dsc, modp->includes[u].exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, modp->includes[u].ref, modp->includes[u].exts);
LEVEL--;
ly_print_(ctx->out, "%*s}\n", INDENT);
} else {
@@ -2058,7 +2058,7 @@
}
if (modp->exts) {
ly_print_(ctx->out, "\n");
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, modp->exts, NULL, 0);
}
LY_ARRAY_FOR(modp->features, u) {
@@ -2110,11 +2110,11 @@
/* module-header-stmts */
if (modp->version) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_YANG_VERSION, 0, modp->version == LYS_VERSION_1_1 ? "1.1" : "1", modp->exts);
+ ypr_substmt(ctx, LY_STMT_YANG_VERSION, 0, modp->version == LYS_VERSION_1_1 ? "1.1" : "1", modp->exts);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_NAMESPACE, 0, module->ns, modp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, module->prefix, modp->exts);
+ ypr_substmt(ctx, LY_STMT_NAMESPACE, 0, module->ns, modp->exts);
+ ypr_substmt(ctx, LY_STMT_PREFIX, 0, module->prefix, modp->exts);
/* linkage-stmts (import/include) */
yang_print_parsed_linkage(ctx, modp);
@@ -2123,10 +2123,10 @@
if (module->org || module->contact || module->dsc || module->ref) {
ly_print_(out, "\n");
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, module->org, modp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, module->contact, modp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, module->dsc, modp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, module->ref, modp->exts);
+ ypr_substmt(ctx, LY_STMT_ORGANIZATION, 0, module->org, modp->exts);
+ ypr_substmt(ctx, LY_STMT_CONTACT, 0, module->contact, modp->exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, module->dsc, modp->exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, module->ref, modp->exts);
/* revision-stmts */
if (modp->revs) {
@@ -2150,8 +2150,8 @@
{
ly_print_(ctx->out, "%*sbelongs-to %s {\n", INDENT, submodp->mod->name);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_BELONGS_TO, 0, submodp->exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, submodp->prefix, submodp->exts);
+ yprp_extension_instances(ctx, LY_STMT_BELONGS_TO, 0, submodp->exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_PREFIX, 0, submodp->prefix, submodp->exts);
LEVEL--;
ly_print_(ctx->out, "%*s}\n", INDENT);
}
@@ -2170,7 +2170,7 @@
/* submodule-header-stmts */
if (submodp->version) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_YANG_VERSION, 0, submodp->version == LYS_VERSION_1_1 ? "1.1" : "1", submodp->exts);
+ ypr_substmt(ctx, LY_STMT_YANG_VERSION, 0, submodp->version == LYS_VERSION_1_1 ? "1.1" : "1", submodp->exts);
}
yprp_belongsto(ctx, submodp);
@@ -2182,10 +2182,10 @@
if (submodp->org || submodp->contact || submodp->dsc || submodp->ref) {
ly_print_(out, "\n");
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, submodp->org, submodp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, submodp->contact, submodp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, submodp->dsc, submodp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, submodp->ref, submodp->exts);
+ ypr_substmt(ctx, LY_STMT_ORGANIZATION, 0, submodp->org, submodp->exts);
+ ypr_substmt(ctx, LY_STMT_CONTACT, 0, submodp->contact, submodp->exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, submodp->dsc, submodp->exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, submodp->ref, submodp->exts);
/* revision-stmts */
if (submodp->revs) {
@@ -2226,8 +2226,8 @@
LEVEL++;
/* module-header-stmts */
- ypr_substmt(ctx, LYEXT_SUBSTMT_NAMESPACE, 0, module->ns, modc->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, module->prefix, modc->exts);
+ ypr_substmt(ctx, LY_STMT_NAMESPACE, 0, module->ns, modc->exts);
+ ypr_substmt(ctx, LY_STMT_PREFIX, 0, module->prefix, modc->exts);
/* no linkage-stmts */
@@ -2235,10 +2235,10 @@
if (module->org || module->contact || module->dsc || module->ref) {
ly_print_(out, "\n");
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, module->org, modc->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, module->contact, modc->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, module->dsc, modc->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, module->ref, modc->exts);
+ ypr_substmt(ctx, LY_STMT_ORGANIZATION, 0, module->org, modc->exts);
+ ypr_substmt(ctx, LY_STMT_CONTACT, 0, module->contact, modc->exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, module->dsc, modc->exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, module->ref, modc->exts);
/* revision-stmts */
if (module->revision) {
@@ -2248,7 +2248,7 @@
/* body-stmts */
if (modc->exts) {
ly_print_(out, "\n");
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, module->compiled->exts, NULL, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, module->compiled->exts, NULL, 0);
}
LY_ARRAY_FOR(module->identities, u) {
@@ -2284,7 +2284,7 @@
* @param[in] count Number of extensions to print, 0 to print them all.
*/
static void
-yprc_extension_instances(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index,
+yprc_extension_instances(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index,
struct lysc_ext_instance *ext, ly_bool *flag, LY_ARRAY_COUNT_TYPE count)
{
LY_ARRAY_COUNT_TYPE u;
@@ -2314,7 +2314,7 @@
}
LEVEL++;
- yprc_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ext[u].exts, &inner_flag, 0);
+ yprc_extension_instances(ctx, LY_STMT_NONE, 0, ext[u].exts, &inner_flag, 0);
if (ext[u].def->plugin->sprinter) {
ext[u].def->plugin->sprinter(ctx, &ext[u], &inner_flag);
diff --git a/src/printer_yin.c b/src/printer_yin.c
index 6e3432b..8cbe8cc 100644
--- a/src/printer_yin.c
+++ b/src/printer_yin.c
@@ -40,7 +40,7 @@
const struct lys_module *module; /**< schema to print */
};
-static void yprp_extension_instances(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index,
+static void yprp_extension_instances(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index,
struct lysp_ext_instance *ext, int8_t *flag, LY_ARRAY_COUNT_TYPE count);
static void
@@ -90,7 +90,7 @@
}
static void
-ypr_substmt(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, const char *text, void *ext)
+ypr_substmt(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index, const char *text, void *ext)
{
LY_ARRAY_COUNT_TYPE u;
int8_t extflag = 0;
@@ -125,7 +125,7 @@
}
static void
-ypr_unsigned(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, void *exts, unsigned long int attr_value)
+ypr_unsigned(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index, void *exts, unsigned long int attr_value)
{
char *str;
@@ -138,7 +138,7 @@
}
static void
-ypr_signed(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index, void *exts, signed long int attr_value)
+ypr_signed(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index, void *exts, signed long int attr_value)
{
char *str;
@@ -156,9 +156,9 @@
if (rev->dsc || rev->ref || rev->exts) {
ypr_open(ctx, "revision", "date", rev->date, 1);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, rev->exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, rev->dsc, rev->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, rev->ref, rev->exts);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, rev->exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, rev->dsc, rev->exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, rev->ref, rev->exts);
LEVEL--;
ypr_close(ctx, "revision", 1);
} else {
@@ -171,7 +171,7 @@
{
if (flags & LYS_MAND_MASK) {
ypr_close_parent(ctx, flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_MANDATORY, 0, (flags & LYS_MAND_TRUE) ? "true" : "false", exts);
+ ypr_substmt(ctx, LY_STMT_MANDATORY, 0, (flags & LYS_MAND_TRUE) ? "true" : "false", exts);
}
}
@@ -180,7 +180,7 @@
{
if (flags & LYS_CONFIG_MASK) {
ypr_close_parent(ctx, flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_CONFIG, 0, (flags & LYS_CONFIG_W) ? "true" : "false", exts);
+ ypr_substmt(ctx, LY_STMT_CONFIG, 0, (flags & LYS_CONFIG_W) ? "true" : "false", exts);
}
}
@@ -200,7 +200,7 @@
status = "obsolete";
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_STATUS, 0, status, exts);
+ ypr_substmt(ctx, LY_STMT_STATUS, 0, status, exts);
}
static void
@@ -208,7 +208,7 @@
{
if (dsc) {
ypr_close_parent(ctx, flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, dsc, exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, dsc, exts);
}
}
@@ -217,7 +217,7 @@
{
if (ref) {
ypr_close_parent(ctx, flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, ref, exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, ref, exts);
}
}
@@ -236,7 +236,7 @@
/* extensions */
LEVEL++;
LY_ARRAY_FOR(exts, v) {
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_IF_FEATURE, u, &exts[v], &extflag, 1);
+ yprp_extension_instances(ctx, LY_STMT_IF_FEATURE, u, &exts[v], &extflag, 1);
}
LEVEL--;
ly_print_(ctx->out, "\"/>\n");
@@ -254,7 +254,7 @@
if (ext->exts) {
ypr_close_parent(ctx, &flag);
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ext->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, ext->exts, &flag, 0);
}
if (ext->argument) {
@@ -264,15 +264,15 @@
LEVEL++;
if (ext->exts) {
u = -1;
- while ((u = lysp_ext_instance_iter(ext->exts, u + 1, LYEXT_SUBSTMT_ARGUMENT)) != LY_ARRAY_COUNT(ext->exts)) {
+ while ((u = lysp_ext_instance_iter(ext->exts, u + 1, LY_STMT_ARGUMENT)) != LY_ARRAY_COUNT(ext->exts)) {
ypr_close_parent(ctx, &flag2);
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_ARGUMENT, 0, &ext->exts[u], &flag2, 1);
+ yprp_extension_instances(ctx, LY_STMT_ARGUMENT, 0, &ext->exts[u], &flag2, 1);
}
}
if ((ext->flags & LYS_YINELEM_MASK) ||
- (ext->exts && (lysp_ext_instance_iter(ext->exts, 0, LYEXT_SUBSTMT_YIN_ELEMENT) != LY_ARRAY_COUNT(ext->exts)))) {
+ (ext->exts && (lysp_ext_instance_iter(ext->exts, 0, LY_STMT_YIN_ELEMENT) != LY_ARRAY_COUNT(ext->exts)))) {
ypr_close_parent(ctx, &flag2);
- ypr_substmt(ctx, LYEXT_SUBSTMT_YIN_ELEMENT, 0, (ext->flags & LYS_YINELEM_TRUE) ? "true" : "false", ext->exts);
+ ypr_substmt(ctx, LY_STMT_YIN_ELEMENT, 0, (ext->flags & LYS_YINELEM_TRUE) ? "true" : "false", ext->exts);
}
LEVEL--;
ypr_close(ctx, "argument", flag2);
@@ -293,7 +293,7 @@
ypr_open(ctx, "feature", "name", feat->name, flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, feat->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, feat->exts, &flag, 0);
yprp_iffeatures(ctx, feat->iffeatures, feat->exts, &flag);
ypr_status(ctx, feat->flags, feat->exts, &flag);
ypr_description(ctx, feat->dsc, feat->exts, &flag);
@@ -311,12 +311,12 @@
ypr_open(ctx, "identity", "name", ident->name, flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, ident->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, ident->exts, &flag, 0);
yprp_iffeatures(ctx, ident->iffeatures, ident->exts, &flag);
LY_ARRAY_FOR(ident->bases, u) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_BASE, u, ident->bases[u], ident->exts);
+ ypr_substmt(ctx, LY_STMT_BASE, u, ident->bases[u], ident->exts);
}
ypr_status(ctx, ident->flags, ident->exts, &flag);
@@ -344,19 +344,19 @@
ly_print_(ctx->out, "\"");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, restr->exts, &inner_flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, restr->exts, &inner_flag, 0);
if (restr->arg.str[0] == LYSP_RESTR_PATTERN_NACK) {
ypr_close_parent(ctx, &inner_flag);
/* special byte value in pattern's expression: 0x15 - invert-match, 0x06 - match */
- ypr_substmt(ctx, LYEXT_SUBSTMT_MODIFIER, 0, "invert-match", restr->exts);
+ ypr_substmt(ctx, LY_STMT_MODIFIER, 0, "invert-match", restr->exts);
}
if (restr->emsg) {
ypr_close_parent(ctx, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_MESSAGE, 0, restr->emsg, restr->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_MESSAGE, 0, restr->emsg, restr->exts);
}
if (restr->eapptag) {
ypr_close_parent(ctx, &inner_flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ERROR_APP_TAG, 0, restr->eapptag, restr->exts);
+ ypr_substmt(ctx, LY_STMT_ERROR_APP_TAG, 0, restr->eapptag, restr->exts);
}
ypr_description(ctx, restr->dsc, restr->exts, &inner_flag);
ypr_reference(ctx, restr->ref, restr->exts, &inner_flag);
@@ -381,7 +381,7 @@
ly_print_(ctx->out, "\"");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, when->exts, &inner_flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, when->exts, &inner_flag, 0);
ypr_description(ctx, when->dsc, when->exts, &inner_flag);
ypr_reference(ctx, when->ref, when->exts, &inner_flag);
LEVEL--;
@@ -408,15 +408,15 @@
}
inner_flag = 0;
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, items[u].exts, &inner_flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, items[u].exts, &inner_flag, 0);
yprp_iffeatures(ctx, items[u].iffeatures, items[u].exts, &inner_flag);
if (items[u].flags & LYS_SET_VALUE) {
if (type == LY_TYPE_BITS) {
ypr_close_parent(ctx, &inner_flag);
- ypr_unsigned(ctx, LYEXT_SUBSTMT_POSITION, 0, items[u].exts, items[u].value);
+ ypr_unsigned(ctx, LY_STMT_POSITION, 0, items[u].exts, items[u].value);
} else { /* LY_TYPE_ENUM */
ypr_close_parent(ctx, &inner_flag);
- ypr_signed(ctx, LYEXT_SUBSTMT_VALUE, 0, items[u].exts, items[u].value);
+ ypr_signed(ctx, LY_STMT_VALUE, 0, items[u].exts, items[u].value);
}
}
ypr_status(ctx, items[u].flags, items[u].exts, &inner_flag);
@@ -440,7 +440,7 @@
ypr_open(ctx, "type", "name", type->name, flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, type->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, type->exts, &flag, 0);
if (type->range || type->length || type->patterns || type->bits || type->enums) {
ypr_close_parent(ctx, &flag);
@@ -455,19 +455,19 @@
if (type->path) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PATH, 0, type->path->expr, type->exts);
+ ypr_substmt(ctx, LY_STMT_PATH, 0, type->path->expr, type->exts);
}
if (type->flags & LYS_SET_REQINST) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REQUIRE_INSTANCE, 0, type->require_instance ? "true" : "false", type->exts);
+ ypr_substmt(ctx, LY_STMT_REQUIRE_INSTANCE, 0, type->require_instance ? "true" : "false", type->exts);
}
if (type->flags & LYS_SET_FRDIGITS) {
ypr_close_parent(ctx, &flag);
- ypr_unsigned(ctx, LYEXT_SUBSTMT_FRACTION_DIGITS, 0, type->exts, type->fraction_digits);
+ ypr_unsigned(ctx, LY_STMT_FRACTION_DIGITS, 0, type->exts, type->fraction_digits);
}
LY_ARRAY_FOR(type->bases, u) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_BASE, u, type->bases[u], type->exts);
+ ypr_substmt(ctx, LY_STMT_BASE, u, type->bases[u], type->exts);
}
LY_ARRAY_FOR(type->types, u) {
ypr_close_parent(ctx, &flag);
@@ -484,15 +484,15 @@
ypr_open(ctx, "typedef", "name", tpdf->name, 1);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, tpdf->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, tpdf->exts, NULL, 0);
yprp_type(ctx, &tpdf->type);
if (tpdf->units) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, tpdf->units, tpdf->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, tpdf->units, tpdf->exts);
}
if (tpdf->dflt.str) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, tpdf->dflt.str, tpdf->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, tpdf->dflt.str, tpdf->exts);
}
ypr_status(ctx, tpdf->flags, tpdf->exts, NULL);
@@ -520,7 +520,7 @@
ypr_open(ctx, "grouping", "name", grp->name, flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, grp->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, grp->exts, &flag, 0);
ypr_status(ctx, grp->flags, grp->exts, &flag);
ypr_description(ctx, grp->dsc, grp->exts, &flag);
ypr_reference(ctx, grp->ref, grp->exts, &flag);
@@ -570,7 +570,7 @@
ypr_open(ctx, inout->name, NULL, NULL, *flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, inout->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, inout->exts, NULL, 0);
LY_ARRAY_FOR(inout->musts, u) {
yprp_restr(ctx, &inout->musts[u], "must", "condition", NULL);
}
@@ -600,7 +600,7 @@
ypr_open(ctx, "notification", "name", notif->name, flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, notif->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, notif->exts, &flag, 0);
yprp_iffeatures(ctx, notif->iffeatures, notif->exts, &flag);
LY_ARRAY_FOR(notif->musts, u) {
@@ -640,7 +640,7 @@
ypr_open(ctx, action->parent ? "action" : "rpc", "name", action->name, flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, action->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, action->exts, &flag, 0);
yprp_iffeatures(ctx, action->iffeatures, action->exts, &flag);
ypr_status(ctx, action->flags, action->exts, &flag);
ypr_description(ctx, action->dsc, action->exts, &flag);
@@ -669,7 +669,7 @@
ypr_open(ctx, lys_nodetype2str(node->nodetype), "name", node->name, *flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, node->exts, flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, node->exts, flag, 0);
yprp_when(ctx, lysp_node_when(node), flag);
yprp_iffeatures(ctx, node->iffeatures, node->exts, flag);
}
@@ -705,7 +705,7 @@
}
if (cont->presence) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, cont->presence, cont->exts);
+ ypr_substmt(ctx, LY_STMT_PRESENCE, 0, cont->presence, cont->exts);
}
yprp_node_common2(ctx, node, &flag);
@@ -769,7 +769,7 @@
if (choice->dflt.str) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, choice->dflt.str, choice->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, choice->dflt.str, choice->exts);
}
yprp_node_common2(ctx, node, &flag);
@@ -794,11 +794,11 @@
yprp_node_common1(ctx, node, &flag);
yprp_type(ctx, &leaf->type);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, leaf->units, leaf->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, leaf->units, leaf->exts);
LY_ARRAY_FOR(leaf->musts, u) {
yprp_restr(ctx, &leaf->musts[u], "must", "condition", &flag);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, leaf->dflt.str, leaf->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, leaf->dflt.str, leaf->exts);
yprp_node_common2(ctx, node, &flag);
@@ -816,29 +816,29 @@
yprp_node_common1(ctx, node, &flag);
yprp_type(ctx, &llist->type);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, llist->units, llist->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, llist->units, llist->exts);
LY_ARRAY_FOR(llist->musts, u) {
yprp_restr(ctx, &llist->musts[u], "must", "condition", NULL);
}
LY_ARRAY_FOR(llist->dflts, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, llist->dflts[u].str, llist->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, u, llist->dflts[u].str, llist->exts);
}
ypr_config(ctx, node->flags, node->exts, NULL);
if (llist->flags & LYS_SET_MIN) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, llist->exts, llist->min);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, llist->exts, llist->min);
}
if (llist->flags & LYS_SET_MAX) {
if (llist->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, llist->exts, llist->max);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, llist->exts, llist->max);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", llist->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", llist->exts);
}
}
if (llist->flags & LYS_ORDBY_MASK) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORDERED_BY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
+ ypr_substmt(ctx, LY_STMT_ORDERED_BY, 0, (llist->flags & LYS_ORDBY_USER) ? "user" : "system", llist->exts);
}
ypr_status(ctx, node->flags, node->exts, &flag);
@@ -868,29 +868,29 @@
}
if (list->key) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_KEY, 0, list->key, list->exts);
+ ypr_substmt(ctx, LY_STMT_KEY, 0, list->key, list->exts);
}
LY_ARRAY_FOR(list->uniques, u) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, list->uniques[u].str, list->exts);
+ ypr_substmt(ctx, LY_STMT_UNIQUE, u, list->uniques[u].str, list->exts);
}
ypr_config(ctx, node->flags, node->exts, NULL);
if (list->flags & LYS_SET_MIN) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, list->exts, list->min);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, list->exts, list->min);
}
if (list->flags & LYS_SET_MAX) {
if (list->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, list->exts, list->max);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, list->exts, list->max);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", list->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", list->exts);
}
}
if (list->flags & LYS_ORDBY_MASK) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORDERED_BY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
+ ypr_substmt(ctx, LY_STMT_ORDERED_BY, 0, (list->flags & LYS_ORDBY_USER) ? "user" : "system", list->exts);
}
ypr_status(ctx, node->flags, node->exts, &flag);
@@ -935,7 +935,7 @@
ypr_open(ctx, "refine", "target-node", refine->nodeid, flag);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, refine->exts, &flag, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, refine->exts, &flag, 0);
yprp_iffeatures(ctx, refine->iffeatures, refine->exts, &flag);
LY_ARRAY_FOR(refine->musts, u) {
@@ -945,12 +945,12 @@
if (refine->presence) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PRESENCE, 0, refine->presence, refine->exts);
+ ypr_substmt(ctx, LY_STMT_PRESENCE, 0, refine->presence, refine->exts);
}
LY_ARRAY_FOR(refine->dflts, u) {
ypr_close_parent(ctx, &flag);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, refine->dflts[u].str, refine->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, u, refine->dflts[u].str, refine->exts);
}
ypr_config(ctx, refine->flags, refine->exts, &flag);
@@ -958,14 +958,14 @@
if (refine->flags & LYS_SET_MIN) {
ypr_close_parent(ctx, &flag);
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, refine->exts, refine->min);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, refine->exts, refine->min);
}
if (refine->flags & LYS_SET_MAX) {
ypr_close_parent(ctx, &flag);
if (refine->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, refine->exts, refine->max);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, refine->exts, refine->max);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", refine->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", refine->exts);
}
}
@@ -986,7 +986,7 @@
ypr_open(ctx, "augment", "target-node", aug->nodeid, 1);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, aug->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, aug->exts, NULL, 0);
yprp_when(ctx, aug->when, NULL);
yprp_iffeatures(ctx, aug->iffeatures, aug->exts, NULL);
ypr_status(ctx, aug->flags, aug->exts, NULL);
@@ -1100,7 +1100,7 @@
ypr_open(ctx, "deviation", "target-node", deviation->nodeid, 1);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, deviation->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, deviation->exts, NULL, 0);
ypr_description(ctx, deviation->dsc, deviation->exts, NULL);
ypr_reference(ctx, deviation->ref, deviation->exts, NULL);
@@ -1111,7 +1111,7 @@
ly_print_(ctx->out, "not-supported\"/>\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, elem->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, elem->exts, NULL, 0);
} else {
ly_print_(ctx->out, "not-supported\"/>\n");
continue;
@@ -1121,27 +1121,27 @@
ly_print_(ctx->out, "add\">\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, add->exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, add->units, add->exts);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, add->exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, add->units, add->exts);
LY_ARRAY_FOR(add->musts, u) {
yprp_restr(ctx, &add->musts[u], "must", "condition", NULL);
}
LY_ARRAY_FOR(add->uniques, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, add->uniques[u].str, add->exts);
+ ypr_substmt(ctx, LY_STMT_UNIQUE, u, add->uniques[u].str, add->exts);
}
LY_ARRAY_FOR(add->dflts, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, add->dflts[u].str, add->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, u, add->dflts[u].str, add->exts);
}
ypr_config(ctx, add->flags, add->exts, NULL);
ypr_mandatory(ctx, add->flags, add->exts, NULL);
if (add->flags & LYS_SET_MIN) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, add->exts, add->min);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, add->exts, add->min);
}
if (add->flags & LYS_SET_MAX) {
if (add->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, add->exts, add->max);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, add->exts, add->max);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", add->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", add->exts);
}
}
} else if (elem->mod == LYS_DEV_REPLACE) {
@@ -1149,22 +1149,22 @@
ly_print_(ctx->out, "replace\">\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, rpl->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, rpl->exts, NULL, 0);
if (rpl->type) {
yprp_type(ctx, rpl->type);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, rpl->units, rpl->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, 0, rpl->dflt.str, rpl->exts);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, rpl->units, rpl->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, 0, rpl->dflt.str, rpl->exts);
ypr_config(ctx, rpl->flags, rpl->exts, NULL);
ypr_mandatory(ctx, rpl->flags, rpl->exts, NULL);
if (rpl->flags & LYS_SET_MIN) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MIN_ELEMENTS, 0, rpl->exts, rpl->min);
+ ypr_unsigned(ctx, LY_STMT_MIN_ELEMENTS, 0, rpl->exts, rpl->min);
}
if (rpl->flags & LYS_SET_MAX) {
if (rpl->max) {
- ypr_unsigned(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, rpl->exts, rpl->max);
+ ypr_unsigned(ctx, LY_STMT_MAX_ELEMENTS, 0, rpl->exts, rpl->max);
} else {
- ypr_substmt(ctx, LYEXT_SUBSTMT_MAX_ELEMENTS, 0, "unbounded", rpl->exts);
+ ypr_substmt(ctx, LY_STMT_MAX_ELEMENTS, 0, "unbounded", rpl->exts);
}
}
} else if (elem->mod == LYS_DEV_DELETE) {
@@ -1172,16 +1172,16 @@
ly_print_(ctx->out, "delete\">\n");
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, del->exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNITS, 0, del->units, del->exts);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, del->exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_UNITS, 0, del->units, del->exts);
LY_ARRAY_FOR(del->musts, u) {
yprp_restr(ctx, &del->musts[u], "must", "condition", NULL);
}
LY_ARRAY_FOR(del->uniques, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_UNIQUE, u, del->uniques[u].str, del->exts);
+ ypr_substmt(ctx, LY_STMT_UNIQUE, u, del->uniques[u].str, del->exts);
}
LY_ARRAY_FOR(del->dflts, u) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_DEFAULT, u, del->dflts[u].str, del->exts);
+ ypr_substmt(ctx, LY_STMT_DEFAULT, u, del->dflts[u].str, del->exts);
}
}
@@ -1243,7 +1243,7 @@
* @param[in] count Number of extensions to print, 0 to print them all.
*/
static void
-yprp_extension_instances(struct lys_ypr_ctx *ctx, LYEXT_SUBSTMT substmt, uint8_t substmt_index,
+yprp_extension_instances(struct lys_ypr_ctx *ctx, enum ly_stmt substmt, uint8_t substmt_index,
struct lysp_ext_instance *ext, int8_t *flag, LY_ARRAY_COUNT_TYPE count)
{
LY_ARRAY_COUNT_TYPE u;
@@ -1300,13 +1300,13 @@
ypr_open(ctx, "import", "module", modp->imports[u].name, 1);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->imports[u].exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, modp->imports[u].prefix, modp->imports[u].exts);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, modp->imports[u].exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_PREFIX, 0, modp->imports[u].prefix, modp->imports[u].exts);
if (modp->imports[u].rev[0]) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_REVISION_DATE, 0, modp->imports[u].rev, modp->imports[u].exts);
+ ypr_substmt(ctx, LY_STMT_REVISION_DATE, 0, modp->imports[u].rev, modp->imports[u].exts);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, modp->imports[u].dsc, modp->imports[u].exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, modp->imports[u].ref, modp->imports[u].exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, modp->imports[u].dsc, modp->imports[u].exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, modp->imports[u].ref, modp->imports[u].exts);
LEVEL--;
ypr_close(ctx, "import", 1);
}
@@ -1318,12 +1318,12 @@
if (modp->includes[u].rev[0] || modp->includes[u].dsc || modp->includes[u].ref || modp->includes[u].exts) {
ypr_open(ctx, "include", "module", modp->includes[u].name, 1);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->includes[u].exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, modp->includes[u].exts, NULL, 0);
if (modp->includes[u].rev[0]) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_REVISION_DATE, 0, modp->includes[u].rev, modp->includes[u].exts);
+ ypr_substmt(ctx, LY_STMT_REVISION_DATE, 0, modp->includes[u].rev, modp->includes[u].exts);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, modp->includes[u].dsc, modp->includes[u].exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, modp->includes[u].ref, modp->includes[u].exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, modp->includes[u].dsc, modp->includes[u].exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, modp->includes[u].ref, modp->includes[u].exts);
LEVEL--;
ly_print_(ctx->out, "%*s}\n", INDENT);
} else {
@@ -1348,7 +1348,7 @@
}
if (modp->exts) {
ly_print_(ctx->out, "\n");
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_SELF, 0, modp->exts, NULL, 0);
+ yprp_extension_instances(ctx, LY_STMT_NONE, 0, modp->exts, NULL, 0);
}
LY_ARRAY_FOR(modp->features, u) {
@@ -1405,10 +1405,10 @@
/* module-header-stmts */
if (modp->version) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_YANG_VERSION, 0, modp->version == LYS_VERSION_1_1 ? "1.1" : "1", modp->exts);
+ ypr_substmt(ctx, LY_STMT_YANG_VERSION, 0, modp->version == LYS_VERSION_1_1 ? "1.1" : "1", modp->exts);
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_NAMESPACE, 0, module->ns, modp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, module->prefix, modp->exts);
+ ypr_substmt(ctx, LY_STMT_NAMESPACE, 0, module->ns, modp->exts);
+ ypr_substmt(ctx, LY_STMT_PREFIX, 0, module->prefix, modp->exts);
/* linkage-stmts (import/include) */
yin_print_parsed_linkage(ctx, modp);
@@ -1417,10 +1417,10 @@
if (module->org || module->contact || module->dsc || module->ref) {
ly_print_(out, "\n");
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, module->org, modp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, module->contact, modp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, module->dsc, modp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, module->ref, modp->exts);
+ ypr_substmt(ctx, LY_STMT_ORGANIZATION, 0, module->org, modp->exts);
+ ypr_substmt(ctx, LY_STMT_CONTACT, 0, module->contact, modp->exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, module->dsc, modp->exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, module->ref, modp->exts);
/* revision-stmts */
if (modp->revs) {
@@ -1445,8 +1445,8 @@
{
ypr_open(ctx, "belongs-to", "module", submodp->mod->name, 1);
LEVEL++;
- yprp_extension_instances(ctx, LYEXT_SUBSTMT_BELONGS_TO, 0, submodp->exts, NULL, 0);
- ypr_substmt(ctx, LYEXT_SUBSTMT_PREFIX, 0, submodp->prefix, submodp->exts);
+ yprp_extension_instances(ctx, LY_STMT_BELONGS_TO, 0, submodp->exts, NULL, 0);
+ ypr_substmt(ctx, LY_STMT_PREFIX, 0, submodp->prefix, submodp->exts);
LEVEL--;
ypr_close(ctx, "belongs-to", 1);
}
@@ -1467,7 +1467,7 @@
/* submodule-header-stmts */
if (submodp->version) {
- ypr_substmt(ctx, LYEXT_SUBSTMT_YANG_VERSION, 0, submodp->version == LYS_VERSION_1_1 ? "1.1" : "1", submodp->exts);
+ ypr_substmt(ctx, LY_STMT_YANG_VERSION, 0, submodp->version == LYS_VERSION_1_1 ? "1.1" : "1", submodp->exts);
}
yprp_belongsto(ctx, submodp);
@@ -1478,10 +1478,10 @@
if (submodp->org || submodp->contact || submodp->dsc || submodp->ref) {
ly_print_(out, "\n");
}
- ypr_substmt(ctx, LYEXT_SUBSTMT_ORGANIZATION, 0, submodp->org, submodp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_CONTACT, 0, submodp->contact, submodp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_DESCRIPTION, 0, submodp->dsc, submodp->exts);
- ypr_substmt(ctx, LYEXT_SUBSTMT_REFERENCE, 0, submodp->ref, submodp->exts);
+ ypr_substmt(ctx, LY_STMT_ORGANIZATION, 0, submodp->org, submodp->exts);
+ ypr_substmt(ctx, LY_STMT_CONTACT, 0, submodp->contact, submodp->exts);
+ ypr_substmt(ctx, LY_STMT_DESCRIPTION, 0, submodp->dsc, submodp->exts);
+ ypr_substmt(ctx, LY_STMT_REFERENCE, 0, submodp->ref, submodp->exts);
/* revision-stmts */
if (submodp->revs) {
diff --git a/src/tree_schema.c b/src/tree_schema.c
index b64665c..4377cfd 100644
--- a/src/tree_schema.c
+++ b/src/tree_schema.c
@@ -999,7 +999,7 @@
ext_p->format = LY_PREF_SCHEMA;
ext_p->prefix_data = mod;
ext_p->flags = LYS_INTERNAL;
- ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
+ ext_p->insubstmt = LY_STMT_NONE;
ext_p->insubstmt_index = 0;
ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
@@ -1065,7 +1065,7 @@
ext_p->format = LY_PREF_SCHEMA;
ext_p->prefix_data = mod;
ext_p->flags = LYS_INTERNAL;
- ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
+ ext_p->insubstmt = LY_STMT_NONE;
ext_p->insubstmt_index = 0;
ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
@@ -1116,7 +1116,7 @@
ext_p->format = LY_PREF_SCHEMA;
ext_p->prefix_data = mod;
ext_p->flags = LYS_INTERNAL;
- ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
+ ext_p->insubstmt = LY_STMT_NONE;
ext_p->insubstmt_index = 0;
ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
@@ -1167,7 +1167,7 @@
ext_p->format = LY_PREF_SCHEMA;
ext_p->prefix_data = mod;
ext_p->flags = LYS_INTERNAL;
- ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
+ ext_p->insubstmt = LY_STMT_NONE;
ext_p->insubstmt_index = 0;
ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
diff --git a/src/tree_schema.h b/src/tree_schema.h
index 5198fcf..7a8233a 100644
--- a/src/tree_schema.h
+++ b/src/tree_schema.h
@@ -433,56 +433,6 @@
const char *lyext_parent2str(LYEXT_PARENT type);
/**
- * @brief Enum of substatements in which extension instances can appear.
- */
-typedef enum {
- LYEXT_SUBSTMT_SELF = 0, /**< extension of the structure itself, not substatement's */
- LYEXT_SUBSTMT_ARGUMENT = LY_STMT_ARGUMENT, /**< extension of the argument statement, can appear in lys_ext */
- LYEXT_SUBSTMT_BASE = LY_STMT_BASE, /**< extension of the base statement, can appear (repeatedly) in lys_type and lys_ident */
- LYEXT_SUBSTMT_BELONGS_TO = LY_STMT_BELONGS_TO, /**< extension of the belongs-to statement, can appear in lys_submodule */
- LYEXT_SUBSTMT_CONFIG = LY_STMT_CONFIG, /**< extension of the config statement, can appear in lys_node and lys_deviate */
- LYEXT_SUBSTMT_CONTACT = LY_STMT_CONTACT, /**< extension of the contact statement, can appear in lys_module */
- LYEXT_SUBSTMT_DEFAULT = LY_STMT_DEFAULT, /**< extension of the default statement, can appear in lys_node_leaf, lys_node_leaflist,
- lys_node_choice and lys_deviate */
- LYEXT_SUBSTMT_DESCRIPTION = LY_STMT_DESCRIPTION, /**< extension of the description statement, can appear in lys_module, lys_submodule,
- lys_node, lys_import, lys_include, lys_ext, lys_feature, lys_tpdf, lys_restr,
- lys_ident, lys_deviation, lys_type_enum, lys_type_bit, lys_when and lys_revision */
- LYEXT_SUBSTMT_ERROR_APP_TAG = LY_STMT_ERROR_APP_TAG, /**< extension of the error-app-tag statement, can appear in lys_restr */
- LYEXT_SUBSTMT_ERROR_MESSAGE = LY_STMT_ERROR_MESSAGE, /**< extension of the error-message statement, can appear in lys_restr */
- LYEXT_SUBSTMT_FRACTION_DIGITS = LY_STMT_FRACTION_DIGITS, /**< extension of the fraction-digits statement, can appear in lys_type */
- LYEXT_SUBSTMT_IF_FEATURE = LY_STMT_IF_FEATURE, /**< extension of the if-feature statement */
- LYEXT_SUBSTMT_KEY = LY_STMT_KEY, /**< extension of the key statement, can appear in lys_node_list */
- LYEXT_SUBSTMT_MANDATORY = LY_STMT_MANDATORY, /**< extension of the mandatory statement, can appear in lys_node_leaf, lys_node_choice,
- lys_node_anydata and lys_deviate */
- LYEXT_SUBSTMT_MAX_ELEMENTS = LY_STMT_MAX_ELEMENTS, /**< extension of the max-elements statement, can appear in lys_node_list,
- lys_node_leaflist and lys_deviate */
- LYEXT_SUBSTMT_MIN_ELEMENTS = LY_STMT_MIN_ELEMENTS, /**< extension of the min-elements statement, can appear in lys_node_list,
- lys_node_leaflist and lys_deviate */
- LYEXT_SUBSTMT_MODIFIER = LY_STMT_MODIFIER, /**< extension of the modifier statement, can appear in lys_restr */
- LYEXT_SUBSTMT_NAMESPACE = LY_STMT_NAMESPACE, /**< extension of the namespace statement, can appear in lys_module */
- LYEXT_SUBSTMT_ORDERED_BY = LY_STMT_ORDERED_BY, /**< extension of the ordered-by statement, can appear in lys_node_list and lys_node_leaflist */
- LYEXT_SUBSTMT_ORGANIZATION = LY_STMT_ORGANIZATION, /**< extension of the organization statement, can appear in lys_module and lys_submodule */
- LYEXT_SUBSTMT_PATH = LY_STMT_PATH, /**< extension of the path statement, can appear in lys_type */
- LYEXT_SUBSTMT_POSITION = LY_STMT_POSITION, /**< extension of the position statement, can appear in lys_type_bit */
- LYEXT_SUBSTMT_PREFIX = LY_STMT_PREFIX, /**< extension of the prefix statement, can appear in lys_module, lys_submodule (for
- belongs-to's prefix) and lys_import */
- LYEXT_SUBSTMT_PRESENCE = LY_STMT_PRESENCE, /**< extension of the presence statement, can appear in lys_node_container */
- LYEXT_SUBSTMT_REFERENCE = LY_STMT_REFERENCE, /**< extension of the reference statement, can appear in lys_module, lys_submodule,
- lys_node, lys_import, lys_include, lys_revision, lys_tpdf, lys_restr, lys_ident,
- lys_ext, lys_feature, lys_deviation, lys_type_enum, lys_type_bit and lys_when */
- LYEXT_SUBSTMT_REQUIRE_INSTANCE = LY_STMT_REQUIRE_INSTANCE, /**< extension of the require-instance statement, can appear in lys_type */
- LYEXT_SUBSTMT_REVISION_DATE = LY_STMT_REVISION_DATE, /**< extension of the revision-date statement, can appear in lys_import and lys_include */
- LYEXT_SUBSTMT_STATUS = LY_STMT_STATUS, /**< extension of the status statement, can appear in lys_tpdf, lys_node, lys_ident,
- lys_ext, lys_feature, lys_type_enum and lys_type_bit */
- LYEXT_SUBSTMT_UNIQUE = LY_STMT_UNIQUE, /**< extension of the unique statement, can appear in lys_node_list and lys_deviate */
- LYEXT_SUBSTMT_UNITS = LY_STMT_UNITS, /**< extension of the units statement, can appear in lys_tpdf, lys_node_leaf,
- lys_node_leaflist and lys_deviate */
- LYEXT_SUBSTMT_VALUE = LY_STMT_VALUE, /**< extension of the value statement, can appear in lys_type_enum */
- LYEXT_SUBSTMT_YANG_VERSION = LY_STMT_YANG_VERSION, /**< extension of the yang-version statement, can appear in lys_module and lys_submodule */
- LYEXT_SUBSTMT_YIN_ELEMENT = LY_STMT_YIN_ELEMENT /**< extension of the yin-element statement, can appear in lys_ext */
-} LYEXT_SUBSTMT;
-
-/**
* @brief YANG import-stmt
*/
struct lysp_import {
@@ -559,7 +509,7 @@
struct lysp_stmt *child; /**< list of the extension's substatements (linked list) */
struct lysc_ext_instance *compiled; /**< pointer to the compiled data if any - in case the source format is YIN,
some of the information (argument) are available only after compilation */
- LYEXT_SUBSTMT insubstmt; /**< value identifying placement of the extension instance */
+ enum ly_stmt insubstmt; /**< value identifying placement of the extension instance */
LY_ARRAY_COUNT_TYPE insubstmt_index; /**< in case the instance is in a substatement, this identifies
the index of that substatement */
uint16_t flags; /**< LYS_INTERNAL value (@ref snodeflags) */
@@ -1439,7 +1389,7 @@
void *parent; /**< pointer to the parent element holding the extension instance(s), use
::lysc_ext_instance#parent_type to access the schema element */
const char *argument; /**< optional value of the extension's argument */
- LYEXT_SUBSTMT insubstmt; /**< value identifying placement of the extension instance */
+ enum ly_stmt insubstmt; /**< value identifying placement of the extension instance in specific statement */
LYEXT_PARENT parent_type; /**< type of the parent structure */
struct lysc_ext_instance *exts; /**< list of the extension instances ([sized array](@ref sizedarrays)) */
diff --git a/src/tree_schema_helpers.c b/src/tree_schema_helpers.c
index 2f0bf43..717f2b9 100644
--- a/src/tree_schema_helpers.c
+++ b/src/tree_schema_helpers.c
@@ -1782,7 +1782,7 @@
}
LY_ARRAY_COUNT_TYPE
-lysp_ext_instance_iter(struct lysp_ext_instance *ext, LY_ARRAY_COUNT_TYPE index, LYEXT_SUBSTMT substmt)
+lysp_ext_instance_iter(struct lysp_ext_instance *ext, LY_ARRAY_COUNT_TYPE index, enum ly_stmt substmt)
{
LY_CHECK_ARG_RET(NULL, ext, LY_EINVAL);
diff --git a/src/tree_schema_internal.h b/src/tree_schema_internal.h
index 23cf9d7..d22125a 100644
--- a/src/tree_schema_internal.h
+++ b/src/tree_schema_internal.h
@@ -458,11 +458,10 @@
* @param[in] ext ([Sized array](@ref sizedarrays)) of extensions to explore
* @param[in] index Index in the \p ext array where to start searching (first call with 0, the consequent calls with
* the returned index increased by 1 (until the iteration is not terminated by returning LY_ARRAY_COUNT(ext).
- * @param[in] substmt Type of the extension (its belongins to the specific substatement) to iterate, use
- * #LYEXT_SUBSTMT_ALL to go through all the extensions in the array
+ * @param[in] substmt The statement the extension is supposed to belong to.
* @result index in the ext array, LY_ARRAY_COUNT(ext) value if not present.
*/
-LY_ARRAY_COUNT_TYPE lysp_ext_instance_iter(struct lysp_ext_instance *ext, LY_ARRAY_COUNT_TYPE index, LYEXT_SUBSTMT substmt);
+LY_ARRAY_COUNT_TYPE lysp_ext_instance_iter(struct lysp_ext_instance *ext, LY_ARRAY_COUNT_TYPE index, enum ly_stmt substmt);
/**
* @brief Get the covering schema module structure for the given parsed module structure.
diff --git a/tests/utests/schema/test_parser_yang.c b/tests/utests/schema/test_parser_yang.c
index 974f540..610bef9 100644
--- a/tests/utests/schema/test_parser_yang.c
+++ b/tests/utests/schema/test_parser_yang.c
@@ -784,7 +784,7 @@
/* extensions */
TEST_GENERIC("prefix:test;}", mod->exts,
assert_string_equal("prefix:test", mod->exts[0].name);
- assert_int_equal(LYEXT_SUBSTMT_SELF, mod->exts[0].insubstmt));
+ assert_int_equal(LY_STMT_NONE, mod->exts[0].insubstmt));
mod = mod_renew(YCTX);
/* invalid substatement */
diff --git a/tests/utests/schema/test_parser_yin.c b/tests/utests/schema/test_parser_yin.c
index 96bd8a2..29b1e7e 100644
--- a/tests/utests/schema/test_parser_yin.c
+++ b/tests/utests/schema/test_parser_yin.c
@@ -93,7 +93,7 @@
LY_ERR yin_validate_value(struct lys_yin_parser_ctx *ctx, enum yang_arg val_type);
enum ly_stmt yin_match_keyword(struct lys_yin_parser_ctx *ctx, const char *name, size_t name_len,
const char *prefix, size_t prefix_len, enum ly_stmt parrent);
-LY_ERR yin_parse_extension_instance(struct lys_yin_parser_ctx *ctx, LYEXT_SUBSTMT subelem, LY_ARRAY_COUNT_TYPE subelem_index,
+LY_ERR yin_parse_extension_instance(struct lys_yin_parser_ctx *ctx, enum ly_stmt subelem, LY_ARRAY_COUNT_TYPE subelem_index,
struct lysp_ext_instance **exts);
LY_ERR yin_parse_element_generic(struct lys_yin_parser_ctx *ctx, enum ly_stmt parent, struct lysp_stmt **element);
LY_ERR yin_parse_mod(struct lys_yin_parser_ctx *ctx, struct lysp_module *mod);
@@ -333,10 +333,10 @@
ly_in_new_memory(data, &UTEST_IN);
lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx);
- ret = yin_parse_extension_instance(YCTX, LYEXT_SUBSTMT_CONTACT, 0, &exts);
+ ret = yin_parse_extension_instance(YCTX, LY_STMT_CONTACT, 0, &exts);
assert_int_equal(ret, LY_SUCCESS);
CHECK_LYSP_EXT_INSTANCE(exts, NULL, 1, NULL,
- LYEXT_SUBSTMT_CONTACT, 0, "myext:ext", 0, LYS_CHOICE, LY_PREF_XML);
+ LY_STMT_CONTACT, 0, "myext:ext", 0, LYS_CHOICE, LY_PREF_XML);
CHECK_LYSP_STMT(exts->child, arg, 0, LYS_YIN_ATTR, 0, 1, stmt);
stmt = "value";
@@ -354,10 +354,10 @@
ly_in_new_memory(data, &UTEST_IN);
lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx);
- ret = yin_parse_extension_instance(YCTX, LYEXT_SUBSTMT_CONTACT, 0, &exts);
+ ret = yin_parse_extension_instance(YCTX, LY_STMT_CONTACT, 0, &exts);
assert_int_equal(ret, LY_SUCCESS);
CHECK_LYSP_EXT_INSTANCE(exts, NULL, 0, NULL,
- LYEXT_SUBSTMT_CONTACT, 0, "myext:extension-elem", 0, LYS_CHOICE, LY_PREF_XML);
+ LY_STMT_CONTACT, 0, "myext:extension-elem", 0, LYS_CHOICE, LY_PREF_XML);
lysp_ext_instance_free(UTEST_LYCTX, exts);
LY_ARRAY_FREE(exts);
exts = NULL;
@@ -376,11 +376,11 @@
ly_in_new_memory(data, &UTEST_IN);
lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx);
- ret = yin_parse_extension_instance(YCTX, LYEXT_SUBSTMT_CONTACT, 0, &exts);
+ ret = yin_parse_extension_instance(YCTX, LY_STMT_CONTACT, 0, &exts);
assert_int_equal(ret, LY_SUCCESS);
CHECK_LYSP_EXT_INSTANCE(exts, NULL, 1, NULL,
- LYEXT_SUBSTMT_CONTACT, 0, "myext:ext", 0, LYS_CHOICE, LY_PREF_XML);
+ LY_STMT_CONTACT, 0, "myext:ext", 0, LYS_CHOICE, LY_PREF_XML);
stmt = "attr1";
arg = "text1";
@@ -449,7 +449,7 @@
ly_in_new_memory(data, &UTEST_IN);
lyxml_ctx_new(UTEST_LYCTX, UTEST_IN, &YCTX->xmlctx);
- ret = yin_parse_extension_instance(YCTX, LYEXT_SUBSTMT_CONTACT, 0, &exts);
+ ret = yin_parse_extension_instance(YCTX, LY_STMT_CONTACT, 0, &exts);
assert_int_equal(ret, LY_SUCCESS);
assert_string_equal(exts->child->arg, "act-name");
assert_string_equal(exts->child->next->arg, "target");
@@ -548,7 +548,7 @@
const char *exts_arg = "totally amazing extension";
CHECK_LYSP_EXT_INSTANCE(exts, exts_arg, 0, NULL,
- LYEXT_SUBSTMT_PREFIX, 0, exts_name, 0, 0x1, LY_PREF_XML);
+ LY_STMT_PREFIX, 0, exts_name, 0, 0x1, LY_PREF_XML);
assert_string_equal(value, "wsefsdf");
assert_string_equal(units, "radians");
assert_string_equal(when_p->cond, "condition...");
@@ -798,7 +798,7 @@
CHECK_LYSP_TYPE_ENUM(type.enums, "desc...", 1, flags, 1, "enum-name", "ref...", 55);
assert_string_equal(type.enums->iffeatures[0].str, "feature");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(type.enums->exts, LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(type.enums->exts, LY_STMT_NONE);
lysp_type_free(UTEST_LYCTX, &type);
memset(&type, 0, sizeof type);
@@ -832,7 +832,7 @@
CHECK_LYSP_TYPE_ENUM(type.bits, "desc...", 1, flags, 1, "bit-name", "ref...", 55);
assert_string_equal(type.bits->iffeatures[0].str, "feature");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(type.bits->exts, LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(type.bits->exts, LY_STMT_NONE);
lysp_type_free(UTEST_LYCTX, &type);
memset(&type, 0, sizeof type);
@@ -857,8 +857,8 @@
"<organization><text>organization...</text>" EXT_SUBELEM EXT_SUBELEM "</organization>"
ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &value, NULL, &exts), LY_SUCCESS);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_ORGANIZATION);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[1]), LYEXT_SUBSTMT_ORGANIZATION);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_ORGANIZATION);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[1]), LY_STMT_ORGANIZATION);
assert_string_equal(value, "organization...");
lydict_remove(UTEST_LYCTX, value);
@@ -871,7 +871,7 @@
"<contact><text>contact...</text>" EXT_SUBELEM "</contact>"
ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &value, NULL, &exts), LY_SUCCESS);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_CONTACT);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_CONTACT);
assert_string_equal(value, "contact...");
lydict_remove(UTEST_LYCTX, value);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
@@ -883,7 +883,7 @@
"<description><text>description...</text>" EXT_SUBELEM "</description>"
ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &value, NULL, &exts), LY_SUCCESS);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_DESCRIPTION);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_DESCRIPTION);
assert_string_equal(value, "description...");
lydict_remove(UTEST_LYCTX, value);
value = NULL;
@@ -896,7 +896,7 @@
ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &value, NULL, &exts), LY_SUCCESS);
assert_string_equal(value, "reference...");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_REFERENCE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_REFERENCE);
lydict_remove(UTEST_LYCTX, value);
value = NULL;
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
@@ -952,7 +952,7 @@
assert_int_equal(test_element_helper(state, data, &imp_meta, NULL, NULL), LY_SUCCESS);
CHECK_LYSP_IMPORT(imports, "import description", 1, "a",
"a_mod", "import reference", "2015-01-01");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(imports->exts, LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(imports->exts, LY_STMT_NONE);
FREE_ARRAY(UTEST_LYCTX, imports, lysp_import_free);
imports = NULL;
@@ -1019,7 +1019,7 @@
data = ELEMENT_WRAPPER_START "<status value=\"obsolete\">"EXT_SUBELEM "</status>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &flags, NULL, &exts), LY_SUCCESS);
assert_true(flags & LYS_STATUS_OBSLT);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_STATUS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_STATUS);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
@@ -1048,7 +1048,7 @@
ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &ext, NULL, NULL), LY_SUCCESS);
CHECK_LYSP_EXT(ext, "arg", 0, "ext_desc", 1, LYS_STATUS_CURR, "ext_name", "ext_ref");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(ext->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(ext->exts[0]), LY_STMT_NONE);
lysp_ext_free(UTEST_LYCTX, ext);
LY_ARRAY_FREE(ext);
ext = NULL;
@@ -1076,7 +1076,7 @@
data = ELEMENT_WRAPPER_START "<yin-element value=\"false\">" EXT_SUBELEM "</yin-element>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &flags, NULL, &exts), LY_SUCCESS);
assert_true(flags & LYS_YINELEM_TRUE);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_YIN_ELEMENT);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_YIN_ELEMENT);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
data = ELEMENT_WRAPPER_START "<yin-element value=\"invalid\" />" ELEMENT_WRAPPER_END;
@@ -1101,7 +1101,7 @@
data = ELEMENT_WRAPPER_START "<yang-version value=\"1.1\">" EXT_SUBELEM "</yang-version>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &version, NULL, &exts), LY_SUCCESS);
assert_true(version & LYS_VERSION_1_1);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_YANG_VERSION);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_YANG_VERSION);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
/* invalid value */
@@ -1127,7 +1127,7 @@
data = ELEMENT_WRAPPER_START "<mandatory value=\"false\">" EXT_SUBELEM "</mandatory>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &man, NULL, &exts), LY_SUCCESS);
assert_int_equal(man, LYS_MAND_FALSE);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_MANDATORY);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_MANDATORY);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
data = ELEMENT_WRAPPER_START "<mandatory value=\"invalid\" />" ELEMENT_WRAPPER_END;
@@ -1155,7 +1155,7 @@
assert_int_equal(test_element_helper(state, data, &arg_meta, NULL, &exts), LY_SUCCESS);
assert_string_equal(arg, "arg-name");
assert_true(flags & LYS_YINELEM_TRUE);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_ARGUMENT);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_ARGUMENT);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
flags = 0;
@@ -1189,7 +1189,7 @@
"</identity>";
assert_int_equal(test_element_helper(state, data, &bases, NULL, &exts), LY_SUCCESS);
assert_string_equal(*bases, "base-name");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_BASE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_BASE);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, *bases);
@@ -1204,7 +1204,7 @@
assert_int_equal(test_element_helper(state, data, &type, NULL, &exts), LY_SUCCESS);
assert_string_equal(*type.bases, "base-name");
assert_true(type.flags & LYS_SET_BASE);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_BASE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_BASE);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, *type.bases);
@@ -1225,7 +1225,7 @@
ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &submod, NULL, &exts), LY_SUCCESS);
assert_string_equal(submod.prefix, "pref");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_BELONGS_TO);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_BELONGS_TO);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, submod.prefix);
@@ -1245,7 +1245,7 @@
data = ELEMENT_WRAPPER_START "<config value=\"true\">" EXT_SUBELEM "</config>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &flags, NULL, &exts), LY_SUCCESS);
assert_true(flags & LYS_CONFIG_W);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_CONFIG);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_CONFIG);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
flags = 0;
@@ -1271,7 +1271,7 @@
data = ELEMENT_WRAPPER_START "<default value=\"defaul-value\">"EXT_SUBELEM "</default>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &val, NULL, &exts), LY_SUCCESS);
assert_string_equal(val.str, "defaul-value");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_DEFAULT);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_DEFAULT);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, val.str);
@@ -1292,7 +1292,7 @@
data = ELEMENT_WRAPPER_START "<error-app-tag value=\"val\">"EXT_SUBELEM "</error-app-tag>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &val, NULL, &exts), LY_SUCCESS);
assert_string_equal(val, "val");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_ERROR_APP_TAG);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_ERROR_APP_TAG);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, val);
@@ -1313,7 +1313,7 @@
data = ELEMENT_WRAPPER_START "<error-message><value>val</value>"EXT_SUBELEM "</error-message>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &val, NULL, &exts), LY_SUCCESS);
assert_string_equal(val, "val");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_ERROR_MESSAGE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_ERROR_MESSAGE);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, val);
@@ -1336,7 +1336,7 @@
/* valid value */
data = ELEMENT_WRAPPER_START "<fraction-digits value=\"10\">"EXT_SUBELEM "</fraction-digits>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.exts[0]), LYEXT_SUBSTMT_FRACTION_DIGITS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.exts[0]), LY_STMT_FRACTION_DIGITS);
assert_int_equal(type.fraction_digits, 10);
assert_true(type.flags & LYS_SET_FRDIGITS);
FREE_ARRAY(UTEST_LYCTX, type.exts, lysp_ext_instance_free);
@@ -1373,7 +1373,7 @@
data = ELEMENT_WRAPPER_START "<if-feature name=\"local-storage\">"EXT_SUBELEM "</if-feature>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &iffeatures, NULL, &exts), LY_SUCCESS);
assert_string_equal(*iffeatures, "local-storage");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_IF_FEATURE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_IF_FEATURE);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, *iffeatures);
@@ -1407,7 +1407,7 @@
CHECK_LYSP_RESTR(type.length, "length-str", "desc",
"err-app-tag", "err-msg", 1, "ref");
assert_true(type.flags & LYS_SET_LENGTH);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.length->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.length->exts[0]), LY_STMT_NONE);
lysp_type_free(UTEST_LYCTX, &type);
memset(&type, 0, sizeof(type));
@@ -1441,7 +1441,7 @@
data = ELEMENT_WRAPPER_START "<modifier value=\"invert-match\">" EXT_SUBELEM "</modifier>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &pat, NULL, &exts), LY_SUCCESS);
assert_string_equal(pat, "\x015pattern");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_MODIFIER);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_MODIFIER);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, pat);
@@ -1464,7 +1464,7 @@
data = ELEMENT_WRAPPER_START "<namespace uri=\"ns\">" EXT_SUBELEM "</namespace>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &ns, NULL, &exts), LY_SUCCESS);
assert_string_equal(ns, "ns");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_NAMESPACE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_NAMESPACE);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, ns);
@@ -1495,7 +1495,7 @@
assert_true(type.flags & LYS_SET_PATTERN);
CHECK_LYSP_RESTR(type.patterns, "\x015super_pattern", "\"pattern-desc\"",
"err-app-tag-value", "err-msg-value", 1, "pattern-ref");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.patterns->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.patterns->exts[0]), LY_STMT_NONE);
lysp_type_free(UTEST_LYCTX, &type);
memset(&type, 0, sizeof(type));
@@ -1517,7 +1517,7 @@
data = ELEMENT_WRAPPER_START "<value value=\"55\">" EXT_SUBELEM "</value>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_SUCCESS);
CHECK_LYSP_TYPE_ENUM(&(en), NULL, 1, LYS_SET_VALUE, 0, NULL, NULL, 55);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(en.exts[0]), LYEXT_SUBSTMT_VALUE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(en.exts[0]), LY_STMT_VALUE);
FREE_ARRAY(UTEST_LYCTX, en.exts, lysp_ext_instance_free);
memset(&en, 0, sizeof(en));
@@ -1540,7 +1540,7 @@
data = ELEMENT_WRAPPER_START "<position value=\"55\">" EXT_SUBELEM "</position>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &en, NULL, NULL), LY_SUCCESS);
CHECK_LYSP_TYPE_ENUM(&(en), NULL, 1, LYS_SET_VALUE, 0, NULL, NULL, 55);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(en.exts[0]), LYEXT_SUBSTMT_POSITION);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(en.exts[0]), LY_STMT_POSITION);
FREE_ARRAY(UTEST_LYCTX, en.exts, lysp_ext_instance_free);
memset(&en, 0, sizeof(en));
@@ -1590,7 +1590,7 @@
data = ELEMENT_WRAPPER_START "<prefix value=\"pref\">" EXT_SUBELEM "</prefix>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &value, NULL, &exts), LY_SUCCESS);
assert_string_equal(value, "pref");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_PREFIX);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_PREFIX);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
exts = NULL;
lydict_remove(UTEST_LYCTX, value);
@@ -1621,7 +1621,7 @@
CHECK_LYSP_RESTR(type.range, "range-str", "desc",
"err-app-tag", "err-msg", 1, "ref");
assert_true(type.flags & LYS_SET_RANGE);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.range->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.range->exts[0]), LY_STMT_NONE);
lysp_type_free(UTEST_LYCTX, &type);
memset(&type, 0, sizeof(type));
@@ -1644,7 +1644,7 @@
assert_int_equal(test_element_helper(state, data, &type, NULL, NULL), LY_SUCCESS);
assert_int_equal(type.require_instance, 1);
assert_true(type.flags & LYS_SET_REQINST);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.exts[0]), LYEXT_SUBSTMT_REQUIRE_INSTANCE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.exts[0]), LY_STMT_REQUIRE_INSTANCE);
lysp_type_free(UTEST_LYCTX, &type);
memset(&type, 0, sizeof(type));
@@ -1671,7 +1671,7 @@
data = ELEMENT_WRAPPER_START "<revision-date date=\"2000-01-01\">"EXT_SUBELEM "</revision-date>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, rev, NULL, &exts), LY_SUCCESS);
assert_string_equal(rev, "2000-01-01");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_REVISION_DATE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_REVISION_DATE);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
data = ELEMENT_WRAPPER_START "<revision-date date=\"2000-01-01\"/>" ELEMENT_WRAPPER_END;
@@ -1693,7 +1693,7 @@
data = ELEMENT_WRAPPER_START "<unique tag=\"tag\">"EXT_SUBELEM "</unique>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &values, NULL, &exts), LY_SUCCESS);
assert_string_equal(*values, "tag");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_UNIQUE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_UNIQUE);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
lydict_remove(UTEST_LYCTX, *values);
LY_ARRAY_FREE(values);
@@ -1717,7 +1717,7 @@
data = ELEMENT_WRAPPER_START "<units name=\"name\">"EXT_SUBELEM "</units>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &values, NULL, &exts), LY_SUCCESS);
assert_string_equal(values, "name");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_UNITS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_UNITS);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
lydict_remove(UTEST_LYCTX, values);
values = NULL;
@@ -1744,7 +1744,7 @@
ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &when, NULL, NULL), LY_SUCCESS);
CHECK_LYSP_WHEN(when, "cond", "desc", 1, "ref");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(when->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(when->exts[0]), LY_STMT_NONE);
lysp_when_free(UTEST_LYCTX, when);
free(when);
when = NULL;
@@ -1816,7 +1816,7 @@
NULL, NULL, 0, NULL);
assert_int_equal(type.require_instance, 1);
assert_string_equal(type.types->name, "sub-type-name");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(type.exts[0]), LY_STMT_NONE);
assert_true(type.flags & LYS_SET_BASE);
assert_true(type.flags & LYS_SET_BIT);
assert_true(type.flags & LYS_SET_ENUM);
@@ -1849,21 +1849,21 @@
assert_int_equal(test_element_helper(state, data, &refine, NULL, NULL), LY_SUCCESS);
assert_int_equal(refine.max, 0);
assert_true(refine.flags & LYS_SET_MAX);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(refine.exts[0]), LYEXT_SUBSTMT_MAX_ELEMENTS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(refine.exts[0]), LY_STMT_MAX_ELEMENTS);
FREE_ARRAY(UTEST_LYCTX, refine.exts, lysp_ext_instance_free);
data = "<list xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\"> <max-elements value=\"5\">"EXT_SUBELEM "</max-elements> </list>";
assert_int_equal(test_element_helper(state, data, &list, NULL, NULL), LY_SUCCESS);
assert_int_equal(list.max, 5);
CHECK_LYSP_NODE(&list, NULL, 1, LYS_SET_MAX, 0, NULL, 0, LYS_UNKNOWN, NULL, NULL, 0);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(list.exts[0]), LYEXT_SUBSTMT_MAX_ELEMENTS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(list.exts[0]), LY_STMT_MAX_ELEMENTS);
FREE_ARRAY(UTEST_LYCTX, list.exts, lysp_ext_instance_free);
data = "<leaf-list xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\"> <max-elements value=\"85\">"EXT_SUBELEM "</max-elements> </leaf-list>";
assert_int_equal(test_element_helper(state, data, &llist, NULL, NULL), LY_SUCCESS);
assert_int_equal(llist.max, 85);
CHECK_LYSP_NODE(&llist, NULL, 1, LYS_SET_MAX, 0, NULL, 0, LYS_UNKNOWN, NULL, NULL, 0);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(llist.exts[0]), LYEXT_SUBSTMT_MAX_ELEMENTS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(llist.exts[0]), LY_STMT_MAX_ELEMENTS);
FREE_ARRAY(UTEST_LYCTX, llist.exts, lysp_ext_instance_free);
data = "<refine xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\"> <max-elements value=\"10\"/> </refine>";
@@ -1900,21 +1900,21 @@
assert_int_equal(test_element_helper(state, data, &refine, NULL, NULL), LY_SUCCESS);
assert_int_equal(refine.min, 0);
assert_true(refine.flags & LYS_SET_MIN);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(refine.exts[0]), LYEXT_SUBSTMT_MIN_ELEMENTS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(refine.exts[0]), LY_STMT_MIN_ELEMENTS);
FREE_ARRAY(UTEST_LYCTX, refine.exts, lysp_ext_instance_free);
data = "<list xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\"> <min-elements value=\"41\">"EXT_SUBELEM "</min-elements> </list>";
assert_int_equal(test_element_helper(state, data, &list, NULL, NULL), LY_SUCCESS);
assert_int_equal(list.min, 41);
assert_true(list.flags & LYS_SET_MIN);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(list.exts[0]), LYEXT_SUBSTMT_MIN_ELEMENTS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(list.exts[0]), LY_STMT_MIN_ELEMENTS);
FREE_ARRAY(UTEST_LYCTX, list.exts, lysp_ext_instance_free);
data = "<leaf-list xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\"> <min-elements value=\"50\">"EXT_SUBELEM "</min-elements> </leaf-list>";
assert_int_equal(test_element_helper(state, data, &llist, NULL, NULL), LY_SUCCESS);
assert_int_equal(llist.min, 50);
assert_true(llist.flags & LYS_SET_MIN);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(llist.exts[0]), LYEXT_SUBSTMT_MIN_ELEMENTS);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(llist.exts[0]), LY_STMT_MIN_ELEMENTS);
FREE_ARRAY(UTEST_LYCTX, llist.exts, lysp_ext_instance_free);
data = "<leaf-list xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\"> <min-elements value=\"-5\"/> </leaf-list>";
@@ -1944,7 +1944,7 @@
data = ELEMENT_WRAPPER_START "<ordered-by value=\"system\">"EXT_SUBELEM "</ordered-by>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &flags, NULL, &exts), LY_SUCCESS);
assert_true(flags & LYS_ORDBY_SYSTEM);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_ORDERED_BY);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_ORDERED_BY);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
data = ELEMENT_WRAPPER_START "<ordered-by value=\"user\"/>" ELEMENT_WRAPPER_END;
@@ -1987,7 +1987,7 @@
"any-name", 0, LYS_ANYXML, 0, "ref", 1);
CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL);
assert_string_equal(parsed->iffeatures[0].str, "feature");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
siblings = NULL;
@@ -2012,7 +2012,7 @@
"any-name", 0, LYS_ANYDATA, 0, "ref", 1);
CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL);
assert_string_equal(parsed->iffeatures[0].str, "feature");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
siblings = NULL;
@@ -2060,7 +2060,7 @@
"leaf", 0, LYS_LEAF, 0, "ref", 1);
CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL);
assert_string_equal(parsed->iffeatures[0].str, "feature");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
assert_string_equal(parsed->musts->arg.str, "must-cond");
assert_string_equal(parsed->type.name, "type");
assert_string_equal(parsed->units, "uni");
@@ -2118,7 +2118,7 @@
assert_string_equal(parsed->type.name, "type");
assert_string_equal(parsed->units, "uni");
CHECK_LYSP_WHEN(parsed->when, "when-cond", NULL, 0, NULL);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
siblings = NULL;
@@ -2149,7 +2149,7 @@
assert_int_equal(parsed->min, 5);
assert_string_equal(parsed->type.name, "type");
assert_string_equal(parsed->units, "uni");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
siblings = NULL;
@@ -2241,7 +2241,7 @@
data = ELEMENT_WRAPPER_START "<presence value=\"presence-val\">"EXT_SUBELEM "</presence>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &val, NULL, &exts), LY_SUCCESS);
assert_string_equal(val, "presence-val");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_PRESENCE);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_PRESENCE);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
lydict_remove(UTEST_LYCTX, val);
@@ -2265,7 +2265,7 @@
data = ELEMENT_WRAPPER_START "<key value=\"key-value\">"EXT_SUBELEM "</key>" ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &val, NULL, &exts), LY_SUCCESS);
assert_string_equal(val, "key-value");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LYEXT_SUBSTMT_KEY);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(exts[0]), LY_STMT_KEY);
FREE_ARRAY(UTEST_LYCTX, exts, lysp_ext_instance_free);
lydict_remove(UTEST_LYCTX, val);
@@ -2305,7 +2305,7 @@
assert_string_equal(tpdfs[0].type.name, "type");
assert_string_equal(tpdfs[0].units, "uni");
assert_true(tpdfs[0].flags & LYS_STATUS_CURR);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(tpdfs[0].exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(tpdfs[0].exts[0]), LY_STMT_NONE);
FREE_ARRAY(UTEST_LYCTX, tpdfs, lysp_tpdf_free);
tpdfs = NULL;
@@ -2355,7 +2355,7 @@
assert_string_equal(refines->musts->arg.str, "cond");
assert_string_equal(refines->presence, "presence");
assert_string_equal(refines->ref, "ref");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(refines->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(refines->exts[0]), LY_STMT_NONE);
FREE_ARRAY(UTEST_LYCTX, refines, lysp_refine_free);
refines = NULL;
@@ -2396,7 +2396,7 @@
assert_string_equal(parsed->iffeatures[0].str, "feature");
assert_string_equal(parsed->refines->nodeid, "target");
assert_string_equal(parsed->augments->nodeid, "target");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
siblings = NULL;
@@ -2426,7 +2426,7 @@
assert_string_equal(revs->date, "2018-12-25");
assert_string_equal(revs->dsc, "desc");
assert_string_equal(revs->ref, "ref");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(revs->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(revs->exts[0]), LY_STMT_NONE);
FREE_ARRAY(UTEST_LYCTX, revs, lysp_revision_free);
revs = NULL;
@@ -2467,7 +2467,7 @@
assert_string_equal(includes->dsc, "desc");
assert_string_equal(includes->ref, "ref");
assert_string_equal(includes->rev, "1999-09-09");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(includes->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(includes->exts[0]), LY_STMT_NONE);
FREE_ARRAY(UTEST_LYCTX, includes, lysp_include_free);
includes = NULL;
@@ -2577,7 +2577,7 @@
assert_int_equal(parsed->min, 10);
assert_string_equal(parsed->typedefs->name, "tpdf");
assert_string_equal(parsed->uniques->str, "utag");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
ly_set_erase(&YCTX->tpdfs_nodes, NULL);
siblings = NULL;
@@ -2649,7 +2649,7 @@
assert_null(notifs->parent);
assert_string_equal(notifs->ref, "ref");
assert_string_equal(notifs->typedefs->name, "tpdf");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(notifs->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(notifs->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, (struct lysp_node *)notifs);
notifs = NULL;
@@ -2711,7 +2711,7 @@
assert_int_equal(grps->child->next->next->next->next->next->next->nodetype, LYS_CONTAINER);
assert_string_equal(grps->child->next->next->next->next->next->next->next->name, "choice");
assert_int_equal(grps->child->next->next->next->next->next->next->next->nodetype, LYS_CHOICE);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(grps->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(grps->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, &grps->node);
grps = NULL;
@@ -2790,7 +2790,7 @@
assert_null(parsed->child->next->next->next->next->next->next->next->next);
assert_string_equal(parsed->notifs->name, "notf");
assert_string_equal(parsed->actions->name, "act");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
ly_set_erase(&YCTX->tpdfs_nodes, NULL);
siblings = NULL;
@@ -2858,7 +2858,7 @@
assert_string_equal(parsed->child->next->next->next->next->next->next->next->name, "choice");
assert_int_equal(parsed->child->next->next->next->next->next->next->next->nodetype, LYS_CHOICE);
assert_null(parsed->child->next->next->next->next->next->next->next->next);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
siblings = NULL;
@@ -2928,7 +2928,7 @@
assert_string_equal(parsed->child->next->next->next->next->next->next->next->name, "list");
assert_int_equal(parsed->child->next->next->next->next->next->next->next->nodetype, LYS_LIST);
assert_null(parsed->child->next->next->next->next->next->next->next->next);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(parsed->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, siblings);
siblings = NULL;
@@ -2990,7 +2990,7 @@
assert_string_equal(inout.child->next->next->next->next->next->next->next->name, "uses-name");
assert_int_equal(inout.child->next->next->next->next->next->next->next->nodetype, LYS_USES);
assert_null(inout.child->next->next->next->next->next->next->next->next);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(inout.exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(inout.exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, (struct lysp_node *)&inout);
memset(&inout, 0, sizeof inout);
@@ -3034,7 +3034,7 @@
assert_string_equal(inout.child->next->next->next->next->next->next->next->name, "uses-name");
assert_int_equal(inout.child->next->next->next->next->next->next->next->nodetype, LYS_USES);
assert_null(inout.child->next->next->next->next->next->next->next->next);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(inout.exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(inout.exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, (struct lysp_node *)&inout);
memset(&inout, 0, sizeof inout);
@@ -3098,7 +3098,7 @@
assert_string_equal(actions->groupings->name, "grouping");
assert_string_equal(actions->output.musts->arg.str, "cond");
assert_string_equal(actions->input.child->name, "uses-name");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(actions->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(actions->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, (struct lysp_node *)actions);
actions = NULL;
@@ -3131,7 +3131,7 @@
assert_string_equal(actions->groupings->name, "grouping");
assert_string_equal(actions->input.child->name, "uses-name");
assert_string_equal(actions->output.musts->arg.str, "cond");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(actions->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(actions->exts[0]), LY_STMT_NONE);
lysp_node_free(UTEST_LYCTX, (struct lysp_node *)actions);
actions = NULL;
@@ -3202,7 +3202,7 @@
assert_null(augments->child->next->next->next->next->next->next->next->next->next);
assert_string_equal(augments->actions->name, "action");
assert_string_equal(augments->notifs->name, "notif");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(augments->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(augments->exts[0]), LY_STMT_NONE);
lysp_node_free(YCTX->parsed_mod->mod->ctx, (struct lysp_node *)augments);
augments = NULL;
@@ -3259,7 +3259,7 @@
ELEMENT_WRAPPER_END;
assert_int_equal(test_element_helper(state, data, &deviates, NULL, NULL), LY_SUCCESS);
assert_int_equal(deviates->mod, LYS_DEV_NOT_SUPPORTED);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviates->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviates->exts[0]), LY_STMT_NONE);
lysp_deviate_free(UTEST_LYCTX, deviates);
free(deviates);
deviates = NULL;
@@ -3288,7 +3288,7 @@
assert_true((d_add->flags & LYS_MAND_TRUE) && (d_add->flags & LYS_CONFIG_W));
assert_int_equal(d_add->min, 5);
assert_int_equal(d_add->max, 15);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviates->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviates->exts[0]), LY_STMT_NONE);
lysp_deviate_free(UTEST_LYCTX, deviates);
free(deviates);
deviates = NULL;
@@ -3315,7 +3315,7 @@
assert_true((d_rpl->flags & LYS_MAND_TRUE) && (d_rpl->flags & LYS_CONFIG_W));
assert_int_equal(d_rpl->min, 5);
assert_int_equal(d_rpl->max, 15);
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviates->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviates->exts[0]), LY_STMT_NONE);
lysp_deviate_free(UTEST_LYCTX, deviates);
free(deviates);
deviates = NULL;
@@ -3337,7 +3337,7 @@
assert_string_equal(d_del->musts->arg.str, "c");
assert_string_equal(d_del->uniques[0].str, "tag");
assert_string_equal(d_del->dflts[0].str, "default");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviates->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviates->exts[0]), LY_STMT_NONE);
lysp_deviate_free(UTEST_LYCTX, deviates);
free(deviates);
deviates = NULL;
@@ -3408,7 +3408,7 @@
assert_int_equal(deviations->deviates->mod, LYS_DEV_ADD);
assert_string_equal(deviations->ref, "ref");
assert_string_equal(deviations->dsc, "desc");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviations->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(deviations->exts[0]), LY_STMT_NONE);
FREE_ARRAY(UTEST_LYCTX, deviations, lysp_deviation_free);
deviations = NULL;
@@ -3516,7 +3516,7 @@
assert_string_equal(lysp_mod->rpcs->name, "rpc-name");
assert_string_equal(lysp_mod->notifs->name, "notf");
assert_string_equal(lysp_mod->deviations->nodeid, "target");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(lysp_mod->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(lysp_mod->exts[0]), LY_STMT_NONE);
/* min subelems */
ly_in_free(UTEST_IN, 0);
@@ -3645,7 +3645,7 @@
assert_string_equal(lysp_submod->rpcs->name, "rpc-name");
assert_string_equal(lysp_submod->notifs->name, "notf");
assert_string_equal(lysp_submod->deviations->nodeid, "target");
- TEST_1_CHECK_LYSP_EXT_INSTANCE(&(lysp_submod->exts[0]), LYEXT_SUBSTMT_SELF);
+ TEST_1_CHECK_LYSP_EXT_INSTANCE(&(lysp_submod->exts[0]), LY_STMT_NONE);
/* min subelemnts */
ly_in_free(UTEST_IN, 0);