tree_schema.h

Go to the documentation of this file.

#ifndef LY_TREE_SCHEMA_H_
#define LY_TREE_SCHEMA_H_

#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/types.h>

#ifdef __cplusplus
extern "C" {
#endif

#define LY_TREE_FOR(START, ELEM) \
    for ((ELEM) = (START); \
         (ELEM); \
         (ELEM) = (ELEM)->next)

#define LY_TREE_FOR_SAFE(START, NEXT, ELEM) \
    for ((ELEM) = (START); \
         (ELEM) ? (NEXT = (ELEM)->next, 1) : 0; \
         (ELEM) = (NEXT))

#define LY_TREE_DFS_BEGIN(START, NEXT, ELEM)                                  \
    for ((ELEM) = (NEXT) = (START);                                           \
         (ELEM);                                                              \
         (ELEM) = (NEXT))

#ifdef __cplusplus
#define TYPES_COMPATIBLE(type1, type2) typeid(*(type1)) == typeid(type2)
#elif defined(__GNUC__) || defined(__clang__)
#define TYPES_COMPATIBLE(type1, type2) __builtin_types_compatible_p(__typeof__(*(type1)), type2)
#else
#define TYPES_COMPATIBLE(type1, type2) _Generic(*(type1), type2: 1, default: 0)
#endif

#define LY_TREE_DFS_END(START, NEXT, ELEM)                                    \
    /* select element for the next run - children first */                    \
    if (TYPES_COMPATIBLE(ELEM, struct lyd_node)) {                            \
        /* child exception for leafs, leaflists and anyxml without children */\
        if (((struct lyd_node *)(ELEM))->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_ANYDATA)) { \
            (NEXT) = NULL;                                                    \
        } else {                                                              \
            (NEXT) = (ELEM)->child;                                           \
        }                                                                     \
    } else if (TYPES_COMPATIBLE(ELEM, struct lys_node)) {                     \
        /* child exception for leafs, leaflists and anyxml without children */\
        if (((struct lys_node *)(ELEM))->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_ANYDATA)) { \
            (NEXT) = NULL;                                                    \
        } else {                                                              \
            (NEXT) = (ELEM)->child;                                           \
        }                                                                     \
    } else {                                                                  \
        (NEXT) = (ELEM)->child;                                               \
    }                                                                         \
                                                                              \
    if (!(NEXT)) {                                                            \
        /* no children */                                                     \
        if ((ELEM) == (START)) {                                              \
            /* we are done, (START) has no children */                        \
            break;                                                            \
        }                                                                     \
        /* try siblings */                                                    \
        (NEXT) = (ELEM)->next;                                                \
    }                                                                         \
    while (!(NEXT)) {                                                         \
        /* parent is already processed, go to its sibling */                  \
        if (TYPES_COMPATIBLE(ELEM, struct lys_node)                           \
                && (((struct lys_node *)(ELEM)->parent)->nodetype == LYS_AUGMENT)) {  \
            (ELEM) = (ELEM)->parent->prev;                                    \
        } else {                                                              \
            (ELEM) = (ELEM)->parent;                                          \
        }                                                                     \
        /* no siblings, go back through parents */                            \
        if (TYPES_COMPATIBLE(ELEM, struct lys_node)) {                        \
            /* due to possible augments */                                    \
            if (lys_parent((struct lys_node *)(ELEM)) == lys_parent((struct lys_node *)(START))) { \
                /* we are done, no next element to process */                 \
                break;                                                        \
            }                                                                 \
        } else if ((ELEM)->parent == (START)->parent) {                       \
            /* we are done, no next element to process */                     \
            break;                                                            \
        }                                                                     \
        (NEXT) = (ELEM)->next;                                                \
    }

#define LY_ARRAY_MAX(var) (sizeof(var) == 8 ? ULLONG_MAX : ((1ULL << (sizeof(var) * 8)) - 1)) 
#define LY_REV_SIZE 11   
typedef enum {
    LYS_IN_UNKNOWN = 0,  
    LYS_IN_YANG = 1,     
    LYS_IN_YIN = 2       
} LYS_INFORMAT;

typedef enum {
    LYS_OUT_UNKNOWN = 0, 
    LYS_OUT_YANG = 1,    
    LYS_OUT_YIN = 2,     
    LYS_OUT_TREE,        
    LYS_OUT_INFO,        
    LYS_OUT_JSON,        
} LYS_OUTFORMAT;

#define LYS_OUTOPT_TREE_RFC        0x01 
#define LYS_OUTOPT_TREE_GROUPING   0x02 
#define LYS_OUTOPT_TREE_USES       0x04 
#define LYS_OUTOPT_TREE_NO_LEAFREF 0x08 
/* shortcuts for common in and out formats */
#define LYS_YANG 1       
#define LYS_YIN 2        
typedef enum lys_nodetype {
    LYS_UNKNOWN = 0x0000,        
    LYS_CONTAINER = 0x0001,      
    LYS_CHOICE = 0x0002,         
    LYS_LEAF = 0x0004,           
    LYS_LEAFLIST = 0x0008,       
    LYS_LIST = 0x0010,           
    LYS_ANYXML = 0x0020,         
    LYS_CASE = 0x0040,           
    LYS_NOTIF = 0x0080,          
    LYS_RPC = 0x0100,            
    LYS_INPUT = 0x0200,          
    LYS_OUTPUT = 0x0400,         
    LYS_GROUPING = 0x0800,       
    LYS_USES = 0x1000,           
    LYS_AUGMENT = 0x2000,        
    LYS_ACTION = 0x4000,         
    LYS_ANYDATA = 0x8020,        
    LYS_EXT = 0x10000            
} LYS_NODE;

/* all nodes sharing the node namespace except RPCs and notifications */
#define LYS_NO_RPC_NOTIF_NODE 0x807F

#define LYS_ANY 0xFFFF

typedef enum {
    LY_STMT_NODE = -1,    
    LY_STMT_UNKNOWN = 0,  
    LY_STMT_ARGUMENT = 1, 
    LY_STMT_BASE,         
    LY_STMT_BELONGSTO,    
    LY_STMT_CONTACT,      
    LY_STMT_DEFAULT,      
    LY_STMT_DESCRIPTION,  
    LY_STMT_ERRTAG,       
    LY_STMT_ERRMSG,       
    LY_STMT_KEY,          
    LY_STMT_NAMESPACE,    
    LY_STMT_ORGANIZATION, 
    LY_STMT_PATH,         
    LY_STMT_PREFIX,       
    LY_STMT_PRESENCE,     
    LY_STMT_REFERENCE,    
    LY_STMT_REVISIONDATE, 
    LY_STMT_UNITS,        
    LY_STMT_VALUE,        
    LY_STMT_VERSION,      
    LY_STMT_MODIFIER,     
    LY_STMT_REQINSTANCE,  
    LY_STMT_YINELEM,      
    LY_STMT_CONFIG,       
    LY_STMT_MANDATORY,    
    LY_STMT_ORDEREDBY,    
    LY_STMT_STATUS,       
    LY_STMT_DIGITS,       
    LY_STMT_MAX,          
    LY_STMT_MIN,          
    LY_STMT_POSITION,     
    LY_STMT_UNIQUE,       
    LY_STMT_MODULE,       
    LY_STMT_ACTION,       
    LY_STMT_ANYDATA,      
    LY_STMT_ANYXML,       
    LY_STMT_CASE,         
    LY_STMT_CHOICE,       
    LY_STMT_CONTAINER,    
    LY_STMT_GROUPING,     
    LY_STMT_INPUT,        
    LY_STMT_LEAF,         
    LY_STMT_LEAFLIST,     
    LY_STMT_LIST,         
    LY_STMT_NOTIFICATION, 
    LY_STMT_OUTPUT,       
    LY_STMT_USES,         
    LY_STMT_TYPEDEF,      
    LY_STMT_TYPE,         
    LY_STMT_IFFEATURE,    
    LY_STMT_LENGTH,       
    LY_STMT_MUST,         
    LY_STMT_PATTERN,      
    LY_STMT_RANGE,        
    LY_STMT_WHEN,         
    LY_STMT_REVISION,     
    LY_STMT_SUBMODULE,    
    LY_STMT_RPC,          
    LY_STMT_BIT,          
    LY_STMT_ENUM,         
    LY_STMT_REFINE,       
    LY_STMT_AUGMENT,      
    LY_STMT_DEVIATE,      
    LY_STMT_DEVIATION,    
    LY_STMT_EXTENSION,    
    LY_STMT_FEATURE,      
    LY_STMT_IDENTITY,     
    LY_STMT_IMPORT,       
    LY_STMT_INCLUDE,      
} LY_STMT;

typedef enum {
    LY_STMT_CARD_OPT,    /* 0..1 */
    LY_STMT_CARD_MAND,   /* 1 */
    LY_STMT_CARD_SOME,   /* 1..n */
    LY_STMT_CARD_ANY     /* 0..n */
} LY_STMT_CARD;

typedef enum {
    LYEXT_ERR = -1,                
    LYEXT_FLAG = 0,                
    LYEXT_COMPLEX                  
} LYEXT_TYPE;

#define LYEXT_OPT_INHERIT    0x01    
#define LYEXT_OPT_YANG       0x02    
#define LYEXT_OPT_CONTENT    0x04    
#define LYEXT_OPT_VALID      0x08    
#define LYEXT_OPT_VALID_SUBTREE 0x10 
#define LYEXT_OPT_PLUGIN1    0x0100  
#define LYEXT_OPT_PLUGIN2    0x0200  
#define LYEXT_OPT_PLUGIN3    0x0400  
#define LYEXT_OPT_PLUGIN4    0x0800  
#define LYEXT_OPT_PLUGIN5    0x1000  
#define LYEXT_OPT_PLUGIN6    0x2000  
#define LYEXT_OPT_PLUGIN7    0x4000  
#define LYEXT_OPT_PLUGIN8    0x8000  
struct lyext_substmt {
    LY_STMT stmt;              
    size_t offset;             
    LY_STMT_CARD cardinality;  
};

struct lys_ext {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t padding[5];              
    struct lys_ext_instance **ext;   
    const char *argument;            
    struct lys_module *module;       
    struct lyext_plugin *plugin;     
};

struct lys_ext_instance {
    struct lys_ext *def;             
    void *parent;                    
    const char *arg_value;           
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t insubstmt_index;         
    uint8_t insubstmt;               
    uint8_t parent_type;             
    uint8_t ext_type;                
    uint8_t padding;                 
    struct lys_ext_instance **ext;   
    void *priv;                      
    struct lys_module *module;       
    LYS_NODE nodetype;               
};

struct lys_ext_instance_complex {
    struct lys_ext *def;             
    void *parent;                    
    const char *arg_value;           
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t insubstmt_index;         
    uint8_t insubstmt;               
    uint8_t parent_type;             
    uint8_t ext_type;                
    uint8_t padding;                 
    struct lys_ext_instance **ext;   
    void *priv;                      
    struct lys_module *module;       
    LYS_NODE nodetype;               
    /* to this point the structure is compatible with the generic ::lys_ext_instance structure */
    struct lyext_substmt *substmt;   
    char content[1];                 
};

const void *lys_ext_instance_substmt(const struct lys_ext_instance *ext);

int lys_ext_instance_presence(struct lys_ext *def, struct lys_ext_instance **ext, uint8_t ext_size);

void *lys_ext_complex_get_substmt(LY_STMT stmt, struct lys_ext_instance_complex *ext, struct lyext_substmt **info);

const char * const *ly_get_loaded_plugins(void);

void ly_load_plugins(void);

/* don't need the contents of these types, just forward-declare them for the next 2 functions. */
struct lyext_plugin_list;
struct lytype_plugin_list;

int ly_register_exts(struct lyext_plugin_list *plugin, const char *log_name);

int ly_register_types(struct lytype_plugin_list *plugin, const char *log_name);

int ly_clean_plugins(void);

typedef enum LYS_VERSION {
    LYS_VERSION_UNDEF = 0,  
    LYS_VERSION_1 = 1,      
    LYS_VERSION_1_1 = 2     
} LYS_VERSION;

struct lys_module {
    struct ly_ctx *ctx;              
    const char *name;                
    const char *prefix;              
    const char *dsc;                 
    const char *ref;                 
    const char *org;                 
    const char *contact;             
    const char *filepath;            
    uint8_t type:1;                  
    uint8_t version:3;               
    uint8_t deviated:2;              
    uint8_t disabled:1;              
    uint8_t implemented:1;           
    uint8_t latest_revision:1;       
    uint8_t padding1:7;              
    uint8_t padding2[2];

    /* array sizes */
    uint8_t rev_size;                
    uint8_t imp_size;                
    uint8_t inc_size;                
    uint16_t ident_size;             
    uint16_t tpdf_size;              
    uint8_t features_size;           
    uint8_t augment_size;            
    uint8_t deviation_size;          
    uint8_t extensions_size;         
    uint8_t ext_size;                
    struct lys_revision *rev;        
    struct lys_import *imp;          
    struct lys_include *inc;         
    struct lys_tpdf *tpdf;           
    struct lys_ident *ident;         
    struct lys_feature *features;    
    struct lys_node_augment *augment;
    struct lys_deviation *deviation; 
    struct lys_ext *extensions;      
    struct lys_ext_instance **ext;   
    /* specific module's items in comparison to submodules */
    struct lys_node *data;           
    const char *ns;                  
};

struct lys_submodule {
    struct ly_ctx *ctx;              
    const char *name;                
    const char *prefix;              
    const char *dsc;                 
    const char *ref;                 
    const char *org;                 
    const char *contact;             
    const char *filepath;            
    uint8_t type:1;                  
    uint8_t version:3;               
    uint8_t deviated:2;              
    uint8_t disabled:1;              
    uint8_t implemented:1;           
    uint8_t padding[3];              
    /* array sizes */
    uint8_t rev_size;                
    uint8_t imp_size;                
    uint8_t inc_size;                
    uint16_t ident_size;             
    uint16_t tpdf_size;              
    uint8_t features_size;           
    uint8_t augment_size;            
    uint8_t deviation_size;          
    uint8_t extensions_size;         
    uint8_t ext_size;                
    struct lys_revision *rev;        
    struct lys_import *imp;          
    struct lys_include *inc;         
    struct lys_tpdf *tpdf;           
    struct lys_ident *ident;         
    struct lys_feature *features;    
    struct lys_node_augment *augment;
    struct lys_deviation *deviation; 
    struct lys_ext *extensions;      
    struct lys_ext_instance **ext;   
    /* specific submodule's items in comparison to modules */
    struct lys_module *belongsto;    
};

typedef enum {
    LY_TYPE_DER = 0,      
    LY_TYPE_BINARY,       
    LY_TYPE_BITS,         
    LY_TYPE_BOOL,         
    LY_TYPE_DEC64,        
    LY_TYPE_EMPTY,        
    LY_TYPE_ENUM,         
    LY_TYPE_IDENT,        
    LY_TYPE_INST,         
    LY_TYPE_LEAFREF,      
    LY_TYPE_STRING,       
    LY_TYPE_UNION,        
    LY_TYPE_INT8,         
    LY_TYPE_UINT8,        
    LY_TYPE_INT16,        
    LY_TYPE_UINT16,       
    LY_TYPE_INT32,        
    LY_TYPE_UINT32,       
    LY_TYPE_INT64,        
    LY_TYPE_UINT64,       
    LY_TYPE_UNKNOWN,      
} LY_DATA_TYPE;
#define LY_DATA_TYPE_COUNT 20 
struct lys_type_info_binary {
    struct lys_restr *length;    
};

struct lys_type_bit {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* 32b padding for compatibility with ::lys_node */
    uint32_t pos;                    
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
};

struct lys_type_info_bits {
    struct lys_type_bit *bit;
    unsigned int count;      
};

struct lys_type_info_dec64 {
    struct lys_restr *range; 
    uint8_t dig;             
    uint64_t div;            
};

struct lys_type_enum {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* 32b padding for compatibility with ::lys_node */
    int32_t value;                   
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
};

struct lys_type_info_enums {
    struct lys_type_enum *enm;
    unsigned int count;       
};

struct lys_type_info_ident {
    struct lys_ident **ref;   
    unsigned int count;       
};

struct lys_type_info_inst {
    int8_t req;              
};

struct lys_type_info_num {
    struct lys_restr *range; 
};

struct lys_type_info_lref {
    const char *path;        
    struct lys_node_leaf* target; 
    int8_t req;              
};

struct lys_type_info_str {
    struct lys_restr *length;
    struct lys_restr *patterns; 
    unsigned int pat_count;  
#ifdef LY_ENABLED_CACHE
    void **patterns_pcre;    
#endif
};

struct lys_type_info_union {
    struct lys_type *types;  
    unsigned int count;      
    int has_ptr_type;        
};

union lys_type_info {
    struct lys_type_info_binary binary; 
    struct lys_type_info_bits bits;     
    struct lys_type_info_dec64 dec64;   
    struct lys_type_info_enums enums;   
    struct lys_type_info_ident ident;   
    struct lys_type_info_inst inst;     
    struct lys_type_info_num num;       
    struct lys_type_info_lref lref;     
    struct lys_type_info_str str;       
    struct lys_type_info_union uni;     
};

struct lys_type {
    LY_DATA_TYPE _PACKED base;       
    uint8_t value_flags;             
    uint8_t ext_size;                
    struct lys_ext_instance **ext;   
    struct lys_tpdf *der;            
    struct lys_tpdf *parent;         
    union lys_type_info info;        
    /*
     * here is an overview of the info union:
     * LY_TYPE_BINARY (binary)
     * struct lys_restr *binary.length;   length restriction (optional), see
     *                                    [RFC 6020 sec. 9.4.4](http://tools.ietf.org/html/rfc6020#section-9.4.4)
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_BITS (bits)
     * struct lys_type_bit *bits.bit;     array of bit definitions
     *   const char *bits.bit[i].name;    bit's name (mandatory)
     *   const char *bits.bit[i].dsc;     bit's description (optional)
     *   const char *bits.bit[i].ref;     bit's reference (optional)
     *   uint8_t bits.bit[i].flags;       bit's flags, whether the position was auto-assigned
     *                                    and the status(one of LYS_NODE_STATUS_* values or 0 for default)
     *   uint8_t bits.bit[i].iffeature_size;            number of elements in the bit's #iffeature array
     *   uint8_t bits.bit[i].ext_size;                  number of elements in the bit's #ext array
     *   uint32_t bits.bit[i].pos;        bit's position (mandatory)
     *   struct lys_iffeature *bits.bit[i].iffeature;   array of bit's if-feature expressions
     *   struct lys_ext_instance **bits.bit[i].ext;     array of pointers to the bit's extension instances (optional)
     * unsigned int bits.count;           number of bit definitions in the bit array
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_DEC64 (dec64)
     * struct lys_restr *dec64.range;     range restriction (optional), see
     *                                    [RFC 6020 sec. 9.2.4](http://tools.ietf.org/html/rfc6020#section-9.2.4)
     * struct lys_ext_instance **dec64.ext;             array of pointers to the bit's extension instances (optional)
     * uint8_t dec64.ext_size;                          number of elements in the bit's #ext array
     * uint8_t dec64.dig;                 fraction-digits restriction (mandatory)
     * uint64_t dec64.div;                auxiliary value for moving decimal point (dividing the stored value to get
     *                                    the real value) (mandatory, corresponds to the fraction-digits)
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_ENUM (enums)
     * struct lys_type_enum *enums.enm;   array of enum definitions
     *   const char *enums.enm[i].name;   enum's name (mandatory)
     *   const char *enums.enm[i].dsc;    enum's description (optional)
     *   const char *enums.enm[i].ref;    enum's reference (optional)
     *   uint8_t enums.enm[i].flags;      enum's flags, whether the value was auto-assigned
     *                                    and the status(one of LYS_NODE_STATUS_* values or 0 for default)
     *   uint8_t enums.enum[i].iffeature_size;          number of elements in the bit's #iffeature array
     *   uint8_t enums.enum[i].ext_size;                number of elements in the bit's #ext array
     *   int32_t enums.enm[i].value;      enum's value (mandatory)
     *   struct lys_iffeature *enums.enum[i].iffeature; array of bit's if-feature expressions
     *   struct lys_ext_instance **enums.enum[i].ext;   array of pointers to the bit's extension instances (optional)
     * unsigned int enums.count;          number of enum definitions in the enm array
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_IDENT (ident)
     * struct lys_ident **ident.ref;      array of pointers (reference) to the identity definition (mandatory)
     * unsigned int ident.count;          number of base identity references
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_INST (inst)
     * int8_t inst.req;                   require-identifier restriction, see
     *                                    [RFC 6020 sec. 9.13.2](http://tools.ietf.org/html/rfc6020#section-9.13.2):
     *                                    - -1 = false,
     *                                    - 0 not defined,
     *                                    - 1 = true
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_*INT* (num)
     * struct lys_restr *num.range;       range restriction (optional), see
     *                                    [RFC 6020 sec. 9.2.4](http://tools.ietf.org/html/rfc6020#section-9.2.4)
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_LEAFREF (lref)
     * const char *lref.path;             path to the referred leaf or leaf-list node (mandatory), see
     *                                    [RFC 6020 sec. 9.9.2](http://tools.ietf.org/html/rfc6020#section-9.9.2)
     * struct lys_node_leaf *lref.target; target schema node according to path
     * int8_t lref.req;                   require-instance restriction: -1 = false; 0 not defined (true); 1 = true
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_STRING (str)
     * struct lys_restr *str.length;      length restriction (optional), see
     *                                    [RFC 6020 sec. 9.4.4](http://tools.ietf.org/html/rfc6020#section-9.4.4)
     * struct lys_restr *str.patterns;    array of pattern restrictions (optional), see
     *                                    [RFC 6020 sec. 9.4.6](http://tools.ietf.org/html/rfc6020#section-9.4.6)
     * unsigned int str.pat_count;        number of pattern definitions in the patterns array
     * -----------------------------------------------------------------------------------------------------------------
     * LY_TYPE_UNION (uni)
     * struct lys_type *uni.types;        array of union's subtypes
     * unsigned int uni.count;            number of subtype definitions in types array
     * int uni.has_ptr_type;              types recursively include an instance-identifier or leafref (union must always
     *                                    be resolved after it is parsed)
     */
};

#define LYS_IFF_NOT  0x00
#define LYS_IFF_AND  0x01
#define LYS_IFF_OR   0x02
#define LYS_IFF_F    0x03

struct lys_iffeature {
    uint8_t *expr;                   
    uint8_t ext_size;                
    struct lys_feature **features;   
    struct lys_ext_instance **ext;   
};

#define LYS_CONFIG_W     0x01        
#define LYS_CONFIG_R     0x02        
#define LYS_CONFIG_SET   0x04        
#define LYS_CONFIG_MASK  0x03        
#define LYS_STATUS_CURR  0x08        
#define LYS_STATUS_DEPRC 0x10        
#define LYS_STATUS_OBSLT 0x20        
#define LYS_STATUS_MASK  0x38        
#define LYS_RFN_MAXSET   0x08        
#define LYS_RFN_MINSET   0x10        
#define LYS_MAND_TRUE    0x40        
#define LYS_MAND_FALSE   0x80        
#define LYS_INCL_STATUS  0x80        
#define LYS_MAND_MASK    0xc0        
#define LYS_USERORDERED  0x100       
#define LYS_FENABLED     0x100       
#define LYS_UNIQUE       0x100       
#define LYS_AUTOASSIGNED 0x01        
#define LYS_USESGRP      0x01        
#define LYS_IMPLICIT     0x40        
#define LYS_XPCONF_DEP   0x200       
#define LYS_XPSTATE_DEP  0x400       
#define LYS_LEAFREF_DEP  0x800       
#define LYS_DFLTJSON     0x1000       
#define LYS_NOTAPPLIED   0x01        
#define LYS_YINELEM      0x01        
#define LYS_VALID_EXT    0x2000      
#define LYS_VALID_EXT_SUBTREE 0x4000 
#ifdef LY_ENABLED_CACHE

#define LYS_NODE_HASH_COUNT 4

#endif

struct lys_node {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    uint8_t padding[4];              
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
#ifdef LY_ENABLED_CACHE
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
#endif
};

struct lys_node_container {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[1];              
    uint8_t must_size;               
    uint16_t tpdf_size;              
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
#ifdef LY_ENABLED_CACHE
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
#endif

    /* specific container's data */
    struct lys_when *when;           
    struct lys_restr *must;          
    struct lys_tpdf *tpdf;           
    const char *presence;            
};

struct lys_node_choice {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[4];              
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
    /* specific choice's data */
    struct lys_when *when;           
    struct lys_node *dflt;           
};

struct lys_node_leaf {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[3];              
    uint8_t must_size;               
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    void *child;                     
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
#ifdef LY_ENABLED_CACHE
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
#endif

    /* specific leaf's data */
    struct lys_when *when;           
    struct lys_restr *must;          
    struct lys_type type;            
    const char *units;               
    /* to this point, struct lys_node_leaf is compatible with struct lys_node_leaflist */
    const char *dflt;                
};

struct lys_node_leaflist {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[2];              
    uint8_t dflt_size;               
    uint8_t must_size;               
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct ly_set *backlinks;        
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
#ifdef LY_ENABLED_CACHE
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
#endif

    /* specific leaf-list's data */
    struct lys_when *when;           
    struct lys_restr *must;          
    struct lys_type type;            
    const char *units;               
    /* to this point, struct lys_node_leaflist is compatible with struct lys_node_leaf
     * on the other hand, the min and max are compatible with struct lys_node_list */
    const char **dflt;               
    uint32_t min;                    
    uint32_t max;                    
};

struct lys_node_list {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t must_size;               
    uint8_t tpdf_size;               
    uint8_t keys_size;               
    uint8_t unique_size;             
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
#ifdef LY_ENABLED_CACHE
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
#endif

    /* specific list's data */
    struct lys_when *when;           
    struct lys_restr *must;          
    struct lys_tpdf *tpdf;           
    struct lys_node_leaf **keys;     
    struct lys_unique *unique;       
    uint32_t min;                    
    uint32_t max;                    
    const char *keys_str;            
};

struct lys_node_anydata {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[3];              
    uint8_t must_size;               
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
#ifdef LY_ENABLED_CACHE
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
#endif

    /* specific anyxml's data */
    struct lys_when *when;           
    struct lys_restr *must;          
};

struct lys_node_uses {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[2];              
    uint8_t refine_size;             
    uint8_t augment_size;            
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
    /* specific uses's data */
    struct lys_when *when;           
    struct lys_refine *refine;       
    struct lys_node_augment *augment;
    struct lys_node_grp *grp;        
};

struct lys_node_grp {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t padding_iffsize;         
    /* non compatible 32b with ::lys_node */
    uint16_t unres_count;            
    uint16_t tpdf_size;              
    struct lys_ext_instance **ext;   
    void *padding_iff;               
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
    /* specific grouping's data */
    struct lys_tpdf *tpdf;           
};

struct lys_node_case {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[4];              
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
    /* specific case's data */
    struct lys_when *when;           
};

struct lys_node_inout {
    const char *name;
    void *fill1[2];                  
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t padding_iffsize;         
    /* non compatible 32b with ::lys_node */
    uint8_t padding[1];              
    uint8_t must_size;               
    uint16_t tpdf_size;              
    struct lys_ext_instance **ext;   
    void *padding_iff;               
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
    /* specific inout's data */
    struct lys_tpdf *tpdf;           
    struct lys_restr *must;          
};

struct lys_node_notif {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[1];              
    uint8_t must_size;               
    uint16_t tpdf_size;              
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
#ifdef LY_ENABLED_CACHE
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
#endif

    /* specific rpc's data */
    struct lys_tpdf *tpdf;           
    struct lys_restr *must;          
};

struct lys_node_rpc_action {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[2];              
    uint16_t tpdf_size;              
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    struct lys_node *next;           
    struct lys_node *prev;           
    void *priv;                      
#ifdef LY_ENABLED_CACHE
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
#endif

    /* specific rpc's data */
    struct lys_tpdf *tpdf;           
};

struct lys_node_augment {
    const char *target_name;         
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* non compatible 32b with ::lys_node */
    uint8_t padding[4];              
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    LYS_NODE nodetype;               
    struct lys_node *parent;         
    struct lys_node *child;          
    /* replaces #next and #prev members of ::lys_node */
    struct lys_when *when;           
    struct lys_node *target;         
    /* again compatible members with ::lys_node */
    void *priv;                      
};

struct lys_refine_mod_list {
    uint32_t min;            
    uint32_t max;            
};

union lys_refine_mod {
    const char *presence;        
    struct lys_refine_mod_list list;  
};

struct lys_refine {
    const char *target_name;         
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* 32b padding for compatibility with ::lys_node */
    uint16_t target_type;            
    uint8_t must_size;               
    uint8_t dflt_size;               
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    struct lys_restr *must;          
    const char **dflt;               
    union lys_refine_mod mod;        
};


typedef enum lys_deviate_type {
    LY_DEVIATE_NO,                   
    LY_DEVIATE_ADD,                  
    LY_DEVIATE_RPL,                  
    LY_DEVIATE_DEL                   
} LYS_DEVIATE_TYPE;

struct lys_deviate {
    LYS_DEVIATE_TYPE mod;            
    uint8_t flags;                   
    uint8_t dflt_size;               
    uint8_t ext_size;                 
    uint8_t min_set;                 
    uint8_t max_set;                 
    uint8_t must_size;               
    uint8_t unique_size;             
    uint32_t min;                    
    uint32_t max;                    
    struct lys_restr *must;          
    struct lys_unique *unique;       
    struct lys_type *type;           
    const char *units;               
    const char **dflt;               
    struct lys_ext_instance **ext;    
};

struct lys_deviation {
    const char *target_name;          
    const char *dsc;                  
    const char *ref;                  
    struct lys_node *orig_node;       
    uint8_t deviate_size;             
    uint8_t ext_size;                 
    struct lys_deviate *deviate;      
    struct lys_ext_instance **ext;    
};

struct lys_import {
    struct lys_module *module;       
    const char *prefix;              
    char rev[LY_REV_SIZE];           
    uint8_t ext_size;                
    struct lys_ext_instance **ext;   
    const char *dsc;                 
    const char *ref;                 
};

struct lys_include {
    struct lys_submodule *submodule; 
    char rev[LY_REV_SIZE];           
    uint8_t ext_size;                
    struct lys_ext_instance **ext;   
    const char *dsc;                 
    const char *ref;                 
};

struct lys_revision {
    char date[LY_REV_SIZE];          
    uint8_t ext_size;                
    struct lys_ext_instance **ext;   
    const char *dsc;                 
    const char *ref;                 
};

struct lys_tpdf {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t padding_iffsize;         
    uint8_t has_union_leafref;       
    /* 24b padding for compatibility with ::lys_node */
    uint8_t padding[3];              
    struct lys_ext_instance **ext;   
    const char *units;               
    struct lys_module *module;       
    struct lys_type type;            
    const char *dflt;                
};

struct lys_unique {
    const char **expr;               
    uint8_t expr_size;               
    uint8_t trg_type;                
};

struct lys_feature {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* 32b padding for compatibility with ::lys_node */
    uint8_t padding[4];              
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    struct ly_set *depfeatures;      
};

struct lys_restr {
    const char *expr;                
    const char *dsc;                 
    const char *ref;                 
    const char *eapptag;             
    const char *emsg;                
    struct lys_ext_instance **ext;   
    uint8_t ext_size;                
    uint16_t flags;                  
};

struct lys_when {
    const char *cond;                
    const char *dsc;                 
    const char *ref;                 
    struct lys_ext_instance **ext;   
    uint8_t ext_size;                
    uint16_t flags;                  
};

struct lys_ident {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    uint16_t flags;                  
    uint8_t ext_size;                
    uint8_t iffeature_size;          
    /* 32b padding for compatibility with ::lys_node */
    uint8_t padding[3];              
    uint8_t base_size;               
    struct lys_ext_instance **ext;   
    struct lys_iffeature *iffeature; 
    struct lys_module *module;       
    struct lys_ident **base;         
    struct ly_set *der;              
};

const struct lys_module *lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format);

const struct lys_module *lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format);

const struct lys_module *lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format);

int lys_search_localfile(const char * const *searchpaths, int cwd, const char *name, const char *revision, char **localfile, LYS_INFORMAT *format);

const char **lys_features_list(const struct lys_module *module, uint8_t **states);

int lys_features_enable(const struct lys_module *module, const char *feature);

int lys_features_disable(const struct lys_module *module, const char *feature);

int lys_features_enable_force(const struct lys_module *module, const char *feature);

int lys_features_disable_force(const struct lys_module *module, const char *feature);

int lys_features_state(const struct lys_module *module, const char *feature);

const struct lys_node *lys_is_disabled(const struct lys_node *node, int recursive);

int lys_iffeature_value(const struct lys_iffeature *iff);

const struct lys_node_list *lys_is_key(const struct lys_node_leaf *node, uint8_t *index);

const struct lys_node *lys_getnext(const struct lys_node *last, const struct lys_node *parent,
                                   const struct lys_module *module, int options);

#define LYS_GETNEXT_WITHCHOICE   0x01 
#define LYS_GETNEXT_WITHCASE     0x02 
#define LYS_GETNEXT_WITHGROUPING 0x04 
#define LYS_GETNEXT_WITHINOUT    0x08 
#define LYS_GETNEXT_WITHUSES     0x10 
#define LYS_GETNEXT_INTOUSES     0x20 
#define LYS_GETNEXT_INTONPCONT   0x40 
#define LYS_GETNEXT_PARENTUSES   0x80 
#define LYS_GETNEXT_NOSTATECHECK 0x100 
const struct lys_type *lys_getnext_union_type(const struct lys_type *last, const struct lys_type *type);

struct ly_set *lys_find_path(const struct lys_module *cur_module, const struct lys_node *cur_node, const char *path);

enum lyxp_node_type {
    /* XML document roots */
    LYXP_NODE_ROOT,             /* access to all the data (node value first top-level node) */
    LYXP_NODE_ROOT_CONFIG,      /* <running> data context, no state data (node value first top-level node) */

    /* XML elements */
    LYXP_NODE_ELEM,             /* XML element (most common) */
    LYXP_NODE_TEXT,             /* XML text element (extremely specific use, unlikely to be ever needed) */
    LYXP_NODE_ATTR,             /* XML attribute (in YANG cannot happen, do not use for the context node) */

    LYXP_NODE_NONE              /* invalid node type, do not use */
};

struct ly_set *lys_xpath_atomize(const struct lys_node *ctx_node, enum lyxp_node_type ctx_node_type,
                                 const char *expr, int options);

#define LYXP_MUST 0x01 
#define LYXP_WHEN 0x02 
struct ly_set *lys_node_xpath_atomize(const struct lys_node *node, int options);

#define LYXP_RECURSIVE 0x01 
#define LYXP_NO_LOCAL 0x02  
char *lys_path(const struct lys_node *node, int options);

#define LYS_PATH_FIRST_PREFIX 0x01 
char *lys_data_path(const struct lys_node *node);

char *lys_data_path_pattern(const struct lys_node *node, const char *placeholder);

struct lys_node *lys_parent(const struct lys_node *node);

struct lys_module *lys_node_module(const struct lys_node *node);

struct lys_module *lys_main_module(const struct lys_module *module);

struct lys_module *lys_implemented_module(const struct lys_module *mod);

int lys_set_implemented(const struct lys_module *module);

int lys_set_disabled(const struct lys_module *module);

int lys_set_enabled(const struct lys_module *module);

void *lys_set_private(const struct lys_node *node, void *priv);

int lys_print_mem(char **strp, const struct lys_module *module, LYS_OUTFORMAT format, const char *target_node,
                  int line_length, int options);

int lys_print_fd(int fd, const struct lys_module *module, LYS_OUTFORMAT format, const char *target_node,
                 int line_length, int options);

int lys_print_file(FILE *f, const struct lys_module *module, LYS_OUTFORMAT format, const char *target_node,
                   int line_length, int options);

int lys_print_path(const char *path, const struct lys_module *module, LYS_OUTFORMAT format, const char *target_node,
                   int line_length, int options);

int lys_print_clb(ssize_t (*writeclb)(void *arg, const void *buf, size_t count), void *arg,
                  const struct lys_module *module, LYS_OUTFORMAT format, const char *target_node, int line_length, int options);

#ifdef __cplusplus
}
#endif

#endif /* LY_TREE_SCHEMA_H_ */