tree_schema.h

Go to the documentation of this file.

 
#ifndef LY_TREE_SCHEMA_H_
#define LY_TREE_SCHEMA_H_
 
#define PCRE2_CODE_UNIT_WIDTH 8
 
#include <pcre2.h>
 
#include <stdint.h>
#include <stdio.h>
 
#include "config.h"
#include "log.h"
#include "tree.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct ly_ctx;
struct ly_path;
struct ly_set;
struct lys_module;
struct lysc_node;
struct lyxp_expr;
 
/* *INDENT-OFF* */
 
#define LYSC_TREE_DFS_BEGIN(START, ELEM) \
    { ly_bool LYSC_TREE_DFS_continue = 0; struct lysc_node *LYSC_TREE_DFS_next; \
    for ((ELEM) = (LYSC_TREE_DFS_next) = (struct lysc_node *)(START); \
         (ELEM); \
         (ELEM) = (LYSC_TREE_DFS_next), LYSC_TREE_DFS_continue = 0)
 
#define LYSC_TREE_DFS_END(START, ELEM) \
    /* select element for the next run - children first */ \
    if (LYSC_TREE_DFS_continue) { \
        (LYSC_TREE_DFS_next) = NULL; \
    } else { \
        (LYSC_TREE_DFS_next) = (struct lysc_node *)lysc_node_child(ELEM); \
    } \
    if (!(LYSC_TREE_DFS_next)) { \
        /* no children, try siblings */ \
        _LYSC_TREE_DFS_NEXT(START, ELEM, LYSC_TREE_DFS_next); \
    } \
    while (!(LYSC_TREE_DFS_next)) { \
        /* parent is already processed, go to its sibling */ \
        (ELEM) = (ELEM)->parent; \
        _LYSC_TREE_DFS_NEXT(START, ELEM, LYSC_TREE_DFS_next); \
    } }
 
#define _LYSC_TREE_DFS_NEXT(START, ELEM, NEXT) \
    if ((ELEM) == (struct lysc_node *)(START)) { \
        /* we are done, no next element to process */ \
        break; \
    } \
    (NEXT) = (ELEM)->next;
 
/* *INDENT-ON* */
 
#define LY_REV_SIZE 11   
#define LYS_UNKNOWN     0x0000    
#define LYS_CONTAINER   0x0001    
#define LYS_CHOICE      0x0002    
#define LYS_LEAF        0x0004    
#define LYS_LEAFLIST    0x0008    
#define LYS_LIST        0x0010    
#define LYS_ANYXML      0x0020    
#define LYS_ANYDATA     0x0060    
#define LYS_CASE        0x0080    
#define LYS_RPC         0x0100    
#define LYS_ACTION      0x0200    
#define LYS_NOTIF       0x0400    
#define LYS_USES        0x0800    
#define LYS_INPUT       0x1000    
#define LYS_OUTPUT      0x2000    
#define LYS_GROUPING    0x4000
#define LYS_AUGMENT     0x8000
 
#define LYS_NODETYPE_MASK 0xffff  
struct lysp_import {
    struct lys_module *module;       
    const char *name;                
    const char *prefix;              
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
    uint16_t flags;                  
    char rev[LY_REV_SIZE];           
};
 
struct lysp_include {
    struct lysp_submodule *submodule;
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
    char rev[LY_REV_SIZE];           
    ly_bool injected;                
};
 
struct lysp_ext {
    const char *name;                
    const char *argname;             
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
    uint16_t flags;                  
    struct lysc_ext *compiled;       
};
 
struct lysp_feature {
    const char *name;                
    struct lysp_qname *iffeatures;   
    struct lysc_iffeature *iffeatures_c;    
    struct lysp_feature **depfeatures;  
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
    uint16_t flags;                  
};
 
struct lysc_iffeature {
    uint8_t *expr;                   
    struct lysp_feature **features;  
};
 
struct lysp_qname {
    const char *str;                 
    const struct lysp_module *mod;   
};
 
struct lysp_ident {
    const char *name;                
    struct lysp_qname *iffeatures;   
    const char **bases;              
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
    uint16_t flags;                  
};
 
struct lysp_restr {
#define LYSP_RESTR_PATTERN_ACK   0x06
#define LYSP_RESTR_PATTERN_NACK  0x15
    struct lysp_qname arg;           
    const char *emsg;                
    const char *eapptag;             
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
};
 
struct lysp_revision {
    char date[LY_REV_SIZE];          
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
};
 
struct lysp_type_enum {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    int64_t value;                   
    struct lysp_qname *iffeatures;   
    struct lysp_ext_instance *exts;  
    uint16_t flags;                  
};
 
struct lysp_type {
    const char *name;                
    struct lysp_restr *range;        
    struct lysp_restr *length;       
    struct lysp_restr *patterns;     
    struct lysp_type_enum *enums;    
    struct lysp_type_enum *bits;     
    struct lyxp_expr *path;          
    const char **bases;              
    struct lysp_type *types;         
    struct lysp_ext_instance *exts;  
    const struct lysp_module *pmod;  
    struct lysc_type *compiled;      
    uint8_t fraction_digits;         
    uint8_t require_instance;        
    uint16_t flags;                  
};
 
struct lysp_tpdf {
    const char *name;                
    const char *units;               
    struct lysp_qname dflt;          
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
    struct lysp_type type;           
    uint16_t flags;                  
};
 
struct lysp_when {
    const char *cond;                
    const char *dsc;                 
    const char *ref;                 
    struct lysp_ext_instance *exts;  
};
 
struct lysp_refine {
    const char *nodeid;              
    const char *dsc;                 
    const char *ref;                 
    struct lysp_qname *iffeatures;   
    struct lysp_restr *musts;        
    const char *presence;            
    struct lysp_qname *dflts;        
    uint32_t min;                    
    uint32_t max;                    
    struct lysp_ext_instance *exts;  
    uint16_t flags;                  
};
 
#define LYS_DEV_NOT_SUPPORTED 1      
#define LYS_DEV_ADD 2                
#define LYS_DEV_DELETE 3             
#define LYS_DEV_REPLACE 4            
struct lysp_deviate {
    uint8_t mod;                     
    struct lysp_deviate *next;       
    struct lysp_ext_instance *exts;  
};
 
struct lysp_deviate_add {
    uint8_t mod;                     
    struct lysp_deviate *next;       
    struct lysp_ext_instance *exts;  
    const char *units;               
    struct lysp_restr *musts;        
    struct lysp_qname *uniques;      
    struct lysp_qname *dflts;        
    uint16_t flags;                  
    uint32_t min;                    
    uint32_t max;                    
};
 
struct lysp_deviate_del {
    uint8_t mod;                     
    struct lysp_deviate *next;       
    struct lysp_ext_instance *exts;  
    const char *units;               
    struct lysp_restr *musts;        
    struct lysp_qname *uniques;      
    struct lysp_qname *dflts;        
};
 
struct lysp_deviate_rpl {
    uint8_t mod;                     
    struct lysp_deviate *next;       
    struct lysp_ext_instance *exts;  
    struct lysp_type *type;          
    const char *units;               
    struct lysp_qname dflt;          
    uint16_t flags;                  
    uint32_t min;                    
    uint32_t max;                    
};
 
struct lysp_deviation {
    const char *nodeid;              
    const char *dsc;                 
    const char *ref;                 
    struct lysp_deviate *deviates;   
    struct lysp_ext_instance *exts;  
};
 
#define LYS_CONFIG_W     0x01        
#define LYS_CONFIG_R     0x02        
#define LYS_CONFIG_MASK  0x03        
#define LYS_STATUS_CURR  0x04        
#define LYS_STATUS_DEPRC 0x08        
#define LYS_STATUS_OBSLT 0x10        
#define LYS_STATUS_MASK  0x1C        
#define LYS_MAND_TRUE    0x20        
#define LYS_MAND_FALSE   0x40        
#define LYS_MAND_MASK    0x60        
#define LYS_PRESENCE     0x80        
#define LYS_UNIQUE       0x80        
#define LYS_KEY          0x0100      
#define LYS_KEYLESS      0x0200      
#define LYS_DISABLED     0x0100      
#define LYS_FENABLED     0x20        
#define LYS_ORDBY_SYSTEM 0x80        
#define LYS_ORDBY_USER   0x40        
#define LYS_ORDBY_MASK   0x60        
#define LYS_YINELEM_TRUE 0x80        
#define LYS_YINELEM_FALSE 0x0100     
#define LYS_YINELEM_MASK 0x0180      
#define LYS_USED_GRP     0x0400      
#define LYS_SET_VALUE    0x0200      
#define LYS_SET_MIN      0x0200      
#define LYS_SET_MAX      0x0400      
#define LYS_SET_BASE     0x0001      
#define LYS_SET_BIT      0x0002      
#define LYS_SET_ENUM     0x0004      
#define LYS_SET_FRDIGITS 0x0008      
#define LYS_SET_LENGTH   0x0010      
#define LYS_SET_PATH     0x0020      
#define LYS_SET_PATTERN  0x0040      
#define LYS_SET_RANGE    0x0080      
#define LYS_SET_TYPE     0x0100      
#define LYS_SET_REQINST  0x0200      
#define LYS_SET_DFLT     0x0200      
#define LYS_SET_UNITS    0x0400      
#define LYS_SET_CONFIG   0x0800      
#define LYS_SINGLEQUOTED 0x0100      
#define LYS_DOUBLEQUOTED 0x0200      
#define LYS_YIN_ATTR     0x0400      
#define LYS_YIN_ARGUMENT 0x0800      
#define LYS_INTERNAL     0x1000      
#define LYS_IS_ENUM      0x0200      
#define LYS_IS_INPUT     0x1000      
#define LYS_IS_OUTPUT    0x2000      
#define LYS_IS_NOTIF     0x4000      
#define LYS_FLAGS_COMPILED_MASK 0xff 
struct lysp_node {
    struct lysp_node *parent;        
    uint16_t nodetype;               
    uint16_t flags;                  
    struct lysp_node *next;          
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    struct lysp_qname *iffeatures;   
    struct lysp_ext_instance *exts;  
};
 
struct lysp_node_container {
    union {
        struct lysp_node node;        
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* container */
    struct lysp_restr *musts;        
    struct lysp_when *when;          
    const char *presence;            
    struct lysp_tpdf *typedefs;      
    struct lysp_node_grp *groupings; 
    struct lysp_node *child;         
    struct lysp_node_action *actions;
    struct lysp_node_notif *notifs;  
};
 
struct lysp_node_leaf {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* leaf */
    struct lysp_restr *musts;        
    struct lysp_when *when;          
    struct lysp_type type;           
    const char *units;               
    struct lysp_qname dflt;          
};
 
struct lysp_node_leaflist {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* leaf-list */
    struct lysp_restr *musts;        
    struct lysp_when *when;          
    struct lysp_type type;           
    const char *units;               
    struct lysp_qname *dflts;        
    uint32_t min;                    
    uint32_t max;                    
};
 
struct lysp_node_list {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* list */
    struct lysp_restr *musts;        
    struct lysp_when *when;          
    const char *key;                 
    struct lysp_tpdf *typedefs;      
    struct lysp_node_grp *groupings; 
    struct lysp_node *child;         
    struct lysp_node_action *actions;
    struct lysp_node_notif *notifs;  
    struct lysp_qname *uniques;      
    uint32_t min;                    
    uint32_t max;                    
};
 
struct lysp_node_choice {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* choice */
    struct lysp_node *child;         
    struct lysp_when *when;          
    struct lysp_qname dflt;          
};
 
struct lysp_node_case {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* case */
    struct lysp_node *child;         
    struct lysp_when *when;          
};
 
struct lysp_node_anydata {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* anyxml/anydata */
    struct lysp_restr *musts;        
    struct lysp_when *when;          
};
 
struct lysp_node_uses {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* uses */
    struct lysp_refine *refines;     
    struct lysp_node_augment *augments; 
    struct lysp_when *when;          
};
 
struct lysp_node_action_inout {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node *next;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* inout */
    struct lysp_restr *musts;        
    struct lysp_tpdf *typedefs;      
    struct lysp_node_grp *groupings; 
    struct lysp_node *child;         
};
 
struct lysp_node_action {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node_action *next; 
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* action */
    struct lysp_tpdf *typedefs;      
    struct lysp_node_grp *groupings; 
    struct lysp_node_action_inout input;  
    struct lysp_node_action_inout output; 
};
 
struct lysp_node_notif {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent; 
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node_notif *next; 
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                            
    /* notif */
    struct lysp_restr *musts;        
    struct lysp_tpdf *typedefs;      
    struct lysp_node_grp *groupings; 
    struct lysp_node *child;         
};
 
struct lysp_node_grp {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent;
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node_grp *next; 
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                                
    /* grp */
    struct lysp_tpdf *typedefs;       
    struct lysp_node_grp *groupings;  
    struct lysp_node *child;          
    struct lysp_node_action *actions; 
    struct lysp_node_notif *notifs;   
};
 
struct lysp_node_augment {
    union {
        struct lysp_node node;       
        struct {
            struct lysp_node *parent;
            uint16_t nodetype;       
            uint16_t flags;          
            struct lysp_node_augment *next; 
            const char *nodeid;      
            const char *dsc;         
            const char *ref;         
            struct lysp_qname *iffeatures; 
            struct lysp_ext_instance *exts; 
        };
    };                                
    struct lysp_node *child;         
    struct lysp_when *when;          
    struct lysp_node_action *actions;
    struct lysp_node_notif *notifs;  
};
 
typedef enum LYS_VERSION {
    LYS_VERSION_UNDEF = 0,  
    LYS_VERSION_1_0 = 1,    
    LYS_VERSION_1_1 = 2     
} LYS_VERSION;
 
struct lysp_module {
    struct lys_module *mod;          
    struct lysp_revision *revs;      
    struct lysp_import *imports;     
    struct lysp_include *includes;   
    struct lysp_ext *extensions;     
    struct lysp_feature *features;   
    struct lysp_ident *identities;   
    struct lysp_tpdf *typedefs;      
    struct lysp_node_grp *groupings; 
    struct lysp_node *data;          
    struct lysp_node_augment *augments; 
    struct lysp_node_action *rpcs;   
    struct lysp_node_notif *notifs;  
    struct lysp_deviation *deviations; 
    struct lysp_ext_instance *exts;  
    uint8_t version;                 
    uint8_t parsing : 1;             
    uint8_t is_submod : 1;           
};
 
struct lysp_submodule {
    struct lys_module *mod;          
    struct lysp_revision *revs;      
    struct lysp_import *imports;     
    struct lysp_include *includes;   
    struct lysp_ext *extensions;     
    struct lysp_feature *features;   
    struct lysp_ident *identities;   
    struct lysp_tpdf *typedefs;      
    struct lysp_node_grp *groupings; 
    struct lysp_node *data;          
    struct lysp_node_augment *augments; 
    struct lysp_node_action *rpcs;   
    struct lysp_node_notif *notifs;  
    struct lysp_deviation *deviations; 
    struct lysp_ext_instance *exts;  
    uint8_t version;                 
    uint8_t parsing : 1;             
    uint8_t is_submod : 1;           
    uint8_t latest_revision : 2;     
    const char *name;                
    const char *filepath;            
    const char *prefix;              
    const char *org;                 
    const char *contact;             
    const char *dsc;                 
    const char *ref;                 
};
 
#define LYSP_MODULE_NAME(PMOD) (PMOD->is_submod ? ((struct lysp_submodule *)PMOD)->name : ((struct lysp_module *)PMOD)->mod->name)
 
struct lysc_prefix {
    char *prefix;                   
    const struct lys_module *mod;   
};
 
struct lysc_ext {
    const char *name;                
    const char *argname;             
    struct lysc_ext_instance *exts;  
    struct lyplg_ext *plugin;        
    struct lys_module *module;       
    uint32_t refcount;               
    uint16_t flags;                  
};
 
struct lysc_when {
    struct lyxp_expr *cond;          
    struct lysc_node *context;       
    struct lysc_prefix *prefixes;    
    const char *dsc;                 
    const char *ref;                 
    struct lysc_ext_instance *exts;  
    uint32_t refcount;               
    uint16_t flags;                  
};
 
struct lysc_ident {
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    struct lys_module *module;       
    struct lysc_ident **derived;     
    struct lysc_ext_instance *exts;  
    uint16_t flags;                  
};
 
#define LYS_IFF_NOT  0x00 
#define LYS_IFF_AND  0x01 
#define LYS_IFF_OR   0x02 
#define LYS_IFF_F    0x03 
struct lysc_revision {
    char date[LY_REV_SIZE];          
    struct lysc_ext_instance *exts;  
};
 
struct lysc_range {
    struct lysc_range_part {
        union {                      
            int64_t min_64;          
            uint64_t min_u64;        
        };
        union {                      
            int64_t max_64;          
            uint64_t max_u64;        
        };
    } *parts;                        
    const char *dsc;                 
    const char *ref;                 
    const char *emsg;                
    const char *eapptag;             
    struct lysc_ext_instance *exts;  
};
 
struct lysc_pattern {
    const char *expr;                
    pcre2_code *code;                
    const char *dsc;                 
    const char *ref;                 
    const char *emsg;                
    const char *eapptag;             
    struct lysc_ext_instance *exts;  
    uint32_t inverted : 1;             
    uint32_t refcount : 31;            
};
 
struct lysc_must {
    struct lyxp_expr *cond;          
    struct lysc_prefix *prefixes;    
    const char *dsc;                 
    const char *ref;                 
    const char *emsg;                
    const char *eapptag;             
    struct lysc_ext_instance *exts;  
};
 
struct lysc_type {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
};
 
struct lysc_type_num {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    struct lysc_range *range;        
};
 
struct lysc_type_dec {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    uint8_t fraction_digits;         
    struct lysc_range *range;        
};
 
struct lysc_type_str {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    struct lysc_range *length;       
    struct lysc_pattern **patterns;  
};
 
struct lysc_type_bitenum_item {
    const char *name;            
    const char *dsc;             
    const char *ref;             
    struct lysc_ext_instance *exts;    
    union {
        int32_t value;           
        uint32_t position;       
    };
    uint16_t flags;              
};
 
struct lysc_type_enum {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    struct lysc_type_bitenum_item *enums; 
};
 
struct lysc_type_bits {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    struct lysc_type_bitenum_item *bits; 
};
 
struct lysc_type_leafref {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    struct lyxp_expr *path;          
    struct lysc_prefix *prefixes;    
    const struct lys_module *cur_mod;
    struct lysc_type *realtype;      
    uint8_t require_instance;        
};
 
struct lysc_type_identityref {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    struct lysc_ident **bases;       
};
 
struct lysc_type_instanceid {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    uint8_t require_instance;        
};
 
struct lysc_type_union {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    struct lysc_type **types;        
};
 
struct lysc_type_bin {
    struct lysc_ext_instance *exts;  
    struct lyplg_type *plugin;       
    LY_DATA_TYPE basetype;           
    uint32_t refcount;               
    struct lysc_range *length;       
};
 
#define LYS_NODE_HASH_COUNT 4
 
struct lysc_node {
    uint16_t nodetype;               
    uint16_t flags;                  
    uint8_t hash[LYS_NODE_HASH_COUNT]; 
    struct lys_module *module;       
    struct lysc_node *parent;        
    struct lysc_node *next;          
    struct lysc_node *prev;          
    const char *name;                
    const char *dsc;                 
    const char *ref;                 
    struct lysc_ext_instance *exts;  
    void *priv;                      
};
 
struct lysc_node_action_inout {
    union {
        struct lysc_node node;       
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent;
            struct lysc_node *next;  
            struct lysc_node *prev;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_node *child;         
    struct lysc_must *musts;         
};
 
struct lysc_node_action {
    union {
        struct lysc_node node;               
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node_action *next; 
            struct lysc_node_action *prev; 
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_when **when;         
    struct lysc_node_action_inout input;  
    struct lysc_node_action_inout output; 
};
 
struct lysc_node_notif {
    union {
        struct lysc_node node;                       
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node_notif *next; 
            struct lysc_node_notif *prev; 
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_node *child;         
    struct lysc_must *musts;         
    struct lysc_when **when;         
};
 
struct lysc_node_container {
    union {
        struct lysc_node node;       
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node *next;  
            struct lysc_node *prev;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_node *child;         
    struct lysc_must *musts;         
    struct lysc_when **when;         
    struct lysc_node_action *actions;
    struct lysc_node_notif *notifs;  
};
 
struct lysc_node_case {
    union {
        struct lysc_node node;       
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node *next;  
            struct lysc_node *prev;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_node *child;         
    struct lysc_when **when;         
};
 
struct lysc_node_choice {
    union {
        struct lysc_node node;       
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node *next;  
            struct lysc_node *prev;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_node_case *cases;    
    struct lysc_when **when;         
    struct lysc_node_case *dflt;     
};
 
struct lysc_node_leaf {
    union {
        struct lysc_node node;               
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node *next;  
            struct lysc_node *prev;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_must *musts;         
    struct lysc_when **when;         
    struct lysc_type *type;          
    const char *units;               
    struct lyd_value *dflt;          
};
 
struct lysc_node_leaflist {
    union {
        struct lysc_node node;       
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node *next;  
            struct lysc_node *prev;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_must *musts;         
    struct lysc_when **when;         
    struct lysc_type *type;          
    const char *units;               
    struct lyd_value **dflts;        
    uint32_t min;                    
    uint32_t max;                    
};
 
struct lysc_node_list {
    union {
        struct lysc_node node;       
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node *next;  
            struct lysc_node *prev;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_node *child;         
    struct lysc_must *musts;         
    struct lysc_when **when; 
    struct lysc_node_action *actions;
    struct lysc_node_notif *notifs;  
    struct lysc_node_leaf ***uniques;
    uint32_t min;                    
    uint32_t max;                    
};
 
struct lysc_node_anydata {
    union {
        struct lysc_node node;       
        struct {
            uint16_t nodetype;       
            uint16_t flags;          
            uint8_t hash[LYS_NODE_HASH_COUNT]; 
            struct lys_module *module; 
            struct lysc_node *parent; 
            struct lysc_node *next;  
            struct lysc_node *prev;  
            const char *name;        
            const char *dsc;         
            const char *ref;         
            struct lysc_ext_instance *exts; 
            void *priv;              
        };
    };
 
    struct lysc_must *musts;         
    struct lysc_when **when; 
};
 
struct lysc_module {
    struct lys_module *mod;          
    struct lysc_node *data;          
    struct lysc_node_action *rpcs;   
    struct lysc_node_notif *notifs;  
    struct lysc_ext_instance *exts;  
};
 
#define lysc_is_userordered(lysc_node) \
    ((!lysc_node || !(lysc_node->nodetype & (LYS_LEAFLIST | LYS_LIST)) || !(lysc_node->flags & LYS_ORDBY_USER)) ? 0 : 1)
 
#define lysc_is_key(lysc_node) \
    ((!lysc_node || (lysc_node->nodetype != LYS_LEAF) || !(lysc_node->flags & LYS_KEY)) ? 0 : 1)
 
#define lysc_is_np_cont(lysc_node) \
    ((!lysc_node || (lysc_node->nodetype != LYS_CONTAINER) || (lysc_node->flags & LYS_PRESENCE)) ? 0 : 1)
 
#define lysc_is_dup_inst_list(lysc_node) \
    ((lysc_node && (((lysc_node->nodetype == LYS_LIST) && (lysc_node->flags & LYS_KEYLESS)) || \
            ((lysc_node->nodetype == LYS_LEAFLIST) && !(lysc_node->flags & LYS_CONFIG_W)))) ? 1 : 0)
 
LIBYANG_API_DECL const struct lysc_node *lysc_data_node(const struct lysc_node *schema);
 
#define lysc_data_parent(SCHEMA) lysc_data_node((SCHEMA) ? (SCHEMA)->parent : NULL)
 
LIBYANG_API_DECL const struct lysc_when *lysc_has_when(const struct lysc_node *node);
 
LIBYANG_API_DECL const struct lys_module *lysc_owner_module(const struct lysc_node *node);
 
LIBYANG_API_DECL const struct lysp_node_grp *lysp_node_groupings(const struct lysp_node *node);
 
LIBYANG_API_DECL const struct lysp_tpdf *lysp_node_typedefs(const struct lysp_node *node);
 
LIBYANG_API_DECL const struct lysp_node_action *lysp_node_actions(const struct lysp_node *node);
 
LIBYANG_API_DECL const struct lysp_node_notif *lysp_node_notifs(const struct lysp_node *node);
 
LIBYANG_API_DECL const struct lysp_node *lysp_node_child(const struct lysp_node *node);
 
LIBYANG_API_DECL const struct lysc_node_action *lysc_node_actions(const struct lysc_node *node);
 
LIBYANG_API_DECL const struct lysc_node_notif *lysc_node_notifs(const struct lysc_node *node);
 
LIBYANG_API_DECL const struct lysc_node *lysc_node_child(const struct lysc_node *node);
 
LIBYANG_API_DECL struct lysc_must *lysc_node_musts(const struct lysc_node *node);
 
LIBYANG_API_DECL struct lysc_when **lysc_node_when(const struct lysc_node *node);
 
LIBYANG_API_DECL const struct lysc_node *lysc_node_lref_target(const struct lysc_node *node);
 
typedef LY_ERR (*lysc_dfs_clb)(struct lysc_node *node, void *data, ly_bool *dfs_continue);
 
LIBYANG_API_DECL LY_ERR lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data);
 
LIBYANG_API_DECL LY_ERR lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data);
 
LIBYANG_API_DECL LY_ERR lysc_iffeature_value(const struct lysc_iffeature *iff);
 
LIBYANG_API_DECL LY_ERR lys_identity_iffeature_value(const struct lysc_ident *ident);
 
LIBYANG_API_DECL struct lysp_feature *lysp_feature_next(const struct lysp_feature *last, const struct lysp_module *pmod,
        uint32_t *idx);
 
#define LYS_FIND_XP_SCHEMA  0x08    
#define LYS_FIND_XP_OUTPUT  0x10    
#define LYS_FIND_NO_MATCH_ERROR 0x40    
#define LYS_FIND_SCHEMAMOUNT    0x0200  
LIBYANG_API_DECL LY_ERR lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath,
        uint32_t options, struct ly_set **set);
 
LIBYANG_API_DECL LY_ERR lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod,
        const struct lyxp_expr *expr, const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set);
 
LIBYANG_API_DECL LY_ERR lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath,
        uint32_t options, struct ly_set **set);
 
LIBYANG_API_DECL LY_ERR lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set);
 
LIBYANG_API_DECL LY_ERR lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path,
        ly_bool output, struct ly_set **set);
 
LIBYANG_API_DECL const struct lysc_node *lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node,
        const char *path, ly_bool output);
 
typedef enum {
    LYSC_PATH_LOG,  
    LYSC_PATH_DATA, 
    LYSC_PATH_DATA_PATTERN  
} LYSC_PATH_TYPE;
 
LIBYANG_API_DECL char *lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen);
 
struct lys_module {
    struct ly_ctx *ctx;              
    const char *name;                
    const char *revision;            
    const char *ns;                  
    const char *prefix;              
    const char *filepath;            
    const char *org;                 
    const char *contact;             
    const char *dsc;                 
    const char *ref;                 
    struct lysp_module *parsed;      
    struct lysc_module *compiled;    
    struct lysc_ident *identities;   
    struct lys_module **augmented_by;
    struct lys_module **deviated_by; 
    ly_bool implemented;             
    ly_bool to_compile;              
    uint8_t latest_revision;         
};
 
#define LYS_MOD_LATEST_REV          0x01 
#define LYS_MOD_LATEST_SEARCHDIRS   0x02 
#define LYS_MOD_IMPORTED_REV        0x04 
#define LYS_MOD_LATEST_IMPCLB       0x08 
LIBYANG_API_DECL LY_ERR lys_feature_value(const struct lys_module *module, const char *feature);
 
LIBYANG_API_DECL const struct lysc_node *lys_getnext(const struct lysc_node *last, const struct lysc_node *parent,
        const struct lysc_module *module, uint32_t options);
 
LIBYANG_API_DECL const struct lysc_node *lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent,
        const struct lysc_ext_instance *ext, uint32_t options);
 
#define LYS_GETNEXT_WITHCHOICE   0x01 
#define LYS_GETNEXT_NOCHOICE     0x02 
#define LYS_GETNEXT_WITHCASE     0x04 
#define LYS_GETNEXT_INTONPCONT   0x08 
#define LYS_GETNEXT_OUTPUT       0x10 
#define LYS_GETNEXT_WITHSCHEMAMOUNT 0x20    
LIBYANG_API_DECL const struct lysc_node *lys_find_child(const struct lysc_node *parent, const struct lys_module *module,
        const char *name, size_t name_len, uint16_t nodetype, uint32_t options);
 
LIBYANG_API_DECL LY_ERR lys_set_implemented(struct lys_module *mod, const char **features);
 
LIBYANG_API_DECL const char *lys_nodetype2str(uint16_t nodetype);
 
LIBYANG_API_DECL const char *lyxp_get_expr(const struct lyxp_expr *path);
 
#ifdef __cplusplus
}
#endif
 
#endif /* LY_TREE_SCHEMA_H_ */