val.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
 * Copyright (c) 2012 - 2021, YumaWorks, Inc., All Rights Reserved.
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
#ifndef _H_val
#define _H_val

/*  FILE: val.h
*********************************************************************
*                                                                   *
*                        P U R P O S E                              *
*                                                                   *
*********************************************************************/

/*********************************************************************
*                                                                   *
*                  C H A N G E   H I S T O R Y                      *
*                                                                   *
*********************************************************************

date         init     comment
----------------------------------------------------------------------
19-dec-05    abb      Begun
21jul08      abb      start obj-based rewrite

*/

#include <xmlstring.h>
#include <time.h>

#include "dlq.h"
#include "ncxconst.h"
#include "ncxtypes.h"
#include "op.h"
#include "plock_cb.h"
#include "status.h"
#include "typ.h"
#include "xml_util.h"
#include "xmlns.h"
#include "log.h"

#ifndef _H_ses
#include "ses.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif

/********************************************************************
*                                                                   *
*                        C O N S T A N T S                          *
*                                                                   *
*********************************************************************/


// Header only

#define VAL_MAX_PLOCKS  1   // was 4

#define VAL_MAX_DATARULES  1  // was 4

#define VAL_MAX_NUMLEN  NCX_MAX_NUMLEN

#define VAL_BINDEX_CH     '['    
#define VAL_EINDEX_CH     ']'    
#define VAL_BENUM_CH      '('
#define VAL_EENUM_CH      ')'
#define VAL_INST_SEPCH    '.'
#define VAL_INDEX_SEPCH   ','
#define VAL_INDEX_CLI_SEPCH   ' '
#define VAL_CLI_SEPCH     ' '
#define VAL_QUOTE_CH      '\''
#define VAL_DBLQUOTE_CH   '\"'
#define VAL_EQUAL_CH      '='
#define VAL_XPATH_SEPCH   '/'

#define VAL_XPATH_INDEX_SEPSTR (const xmlChar *)"]["
#define VAL_XPATH_INDEX_SEPLEN 2

#define VAL_PASSWORD_STRING  (const xmlChar *)"****"

#define VAL_FL_DUPDONE   bit0

#define VAL_FL_DUPOK     bit1

#define VAL_FL_DEFSET    bit2

#define VAL_FL_META      bit3

#define VAL_FL_DIRTY     bit4

#define VAL_FL_UNIDONE   bit5

#define VAL_FL_DEFVALSET bit6

#define VAL_FL_DEFVAL    bit7

#define VAL_FL_WITHDEF   bit8

#define VAL_FL_DELETED   bit9

#define VAL_FL_SUBTREE_DIRTY bit10

#define VAL_FL_CHILD_DELETED bit11

#define VAL_FL_IS_VAREXPR bit12

#define VAL_FL_FIXED_VALUE  bit13

#define VAL_FL_EDIT2_MERGE   bit14

#define VAL_FL_EXTERNAL   bit15

#define VAL_FL_FORCE_CONFIG  bit16

#define VAL_FL_FORCE_CONFIG_VALUE  bit17

#define VAL_FL_VALUE_SET   bit18

#define VAL_FL_TEMP_XPATH  bit19

#define VAL_FL_UNCMTD_DELETE  bit20

#define VAL_FL_RECREATED  bit21

#define VAL_FL_SUBTREE_RECREATED  bit22

#define VAL_FL_FROM_TEMPLATE bit23

#define VAL_FL_CANONICAL bit24

#define VAL_FL_IS_INDEX  bit25

#define VAL_FL_WILDCARD  bit26

#define VAL_FL_ANYXML_KEY  bit27

#define VAL_FL_ANYXML_CONFIG  bit28

#define VAL_FL_ANYXML_UNKNOWN  bit29

#define VAL_FL_DEFCON_DELETED  bit30


#define VAL_FL_ADDEDIT_DELETED  bit31


/********* val_child_hdr->flags fields ***************/


#define VAL_FL_GENERIC  bit0

#define VAL_FL_ROOT     bit1

#define VAL_FL_USE_QUE  bit2

#define VAL_FL_USE_TREE bit3

#define VAL_FL_HDR_DIRTY  bit4

#define VAL_FL_HDR_SUBTREE_DIRTY  bit5

#define VAL_FL_HDR_RECREATED  bit6

#define VAL_FL_HDR_NOT_INSERTED  bit7


#define VAL_VIRTUAL_CACHE_TIME   3

/* macros to access simple value types */

#define VAL_OBJ(V)    (V)->obj

#define VAL_OBJTYPE(V)    (V)->obj->objtype

#define VAL_TYPE(V)    (V)->btyp

#define VAL_HDR(V)    (V)->hdr

#define VAL_TYPDEF(V)    (V)->typdef

#define VAL_NSID(V)    (V)->nsid

#define VAL_NAME(V)    (V)->name

#define VAL_RES(V)    (V)->res

#define VAL_BOOL(V)    (V)->v.boo

#define VAL_EMPTY(V)    (V)->v.boo

#define VAL_DOUBLE(V)  (V)->v.num.d

#define VAL_STRING(V)    (V)->v.str

#define VAL_BINARY(V)    (V)->v.binary.ustr

#define VAL_BINARY_LEN(V)  (V)->v.binary.ustrlen

#define VAL_ENU(V)     (&(V)->v.enu)

#define VAL_ENUM(V)    (V)->v.enu.val

#define VAL_ENUM_NAME(V)    (V)->v.enu.name

#define VAL_FLAG(V)    (V)->v.boo

#define VAL_LONG(V)    (V)->v.num.l

#define VAL_INT(V)    (V)->v.num.i

#define VAL_INT8(V)    ((int8)((V)->v.num.i))

#define VAL_L_INT8(V)    (V)->v.num.i

#define VAL_INT16(V)   ((int16)((V)->v.num.i))

#define VAL_L_INT16(V)   (V)->v.num.i

#define VAL_INT32(V)   (V)->v.num.i

#define VAL_INT64(V)  (V)->v.num.l

#define VAL_STR(V)     (V)->v.str

#define VAL_INSTANCE_ID(V) (V)->v.str

#define VAL_IDREF(V)    (&(V)->v.idref)

#define VAL_IDREF_NSID(V)    (V)->v.idref.nsid

#define VAL_IDREF_NAME(V)    (V)->v.idref.name

#define VAL_IDREF_IDENTITY(V)    (V)->v.idref.identity

#define VAL_UINT(V)    (V)->v.num.u

#define VAL_UINT8(V)    ((uint8)((V)->v.num.u))

#define VAL_L_UINT8(V)    (V)->v.num.u

#define VAL_UINT16(V)   ((uint16)((V)->v.num.u))

#define VAL_L_UINT16(V)   (V)->v.num.u

#define VAL_UINT32(V)   (V)->v.num.u

#define VAL_L_UINT32(V)   (V)->v.num.u

#define VAL_UINT64(V)   (V)->v.num.ul

#define VAL_ULONG(V)    (V)->v.num.ul

#define VAL_DEC64(V)   (V)->v.num.dec.val

#define VAL_DEC64_DIGITS(V)   (V)->v.num.dec.digits

#define VAL_DEC64_ZEROES(V)   (V)->v.num.dec.zeroes

#define VAL_LIST(V)    (V)->v.list

#define VAL_BITS VAL_LIST

#define VAL_EXTERN(V)  (V)->v.fname

#define VAL_IS_DELETED(V) ((V)->flags & VAL_FL_DELETED)

#define VAL_MARK_DELETED(V) val_mark_deleted(V)

#define VAL_UNMARK_DELETED(V) val_mark_undeleted(V)

#define VAL_LAST_MODIFIED(V) (V)->last_modified

#define VAL_ETAG(V) (V)->etag

#define VAL_BTYPE(V) (V)->btyp

#define VAL_SET_VAREXPR(V)  (V)->flags |= VAL_FL_IS_VAREXPR

#define VAL_CLR_VAREXPR(V)  (V)->flags &= ~VAL_FL_IS_VAREXPR

#define VAL_IS_VAREXPR(V)  ((V)->flags & VAL_FL_IS_VAREXPR)

#define VAL_VAREXPR(V)  val_get_varexpr(V)

#define VAL_SET_META(V)    (V)->flags |= VAL_FL_META

#define VAL_REMOVE_META(M)  dlq_remove(M)

#define VAL_SET_FIXED_VALUE(V)  (V)->flags |= VAL_FL_FIXED_VALUE

#define VAL_CLR_FIXED_VALUE(V)  (V)->flags &= ~VAL_FL_FIXED_VALUE

#define VAL_IS_FIXED_VALUE(V)  ((V)->flags & VAL_FL_FIXED_VALUE)

#define VAL_SET_EDIT2_MERGE(V)  (V)->flags |= VAL_FL_EDIT2_MERGE

#define VAL_CLR_EDIT2_MERGE(V)  (V)->flags &= ~VAL_FL_EDIT2_MERGE

#define VAL_IS_EDIT2_MERGE(V)  ((V)->flags & VAL_FL_EDIT2_MERGE)

#define VAL_SET_EXTERNAL(V)  (V)->flags |= VAL_FL_EXTERNAL

#define VAL_CLR_EXTERNAL(V)  (V)->flags &= ~VAL_FL_EXTERNAL

#define VAL_IS_EXTERNAL(V)  ((V)->flags & VAL_FL_EXTERNAL)

#define VAL_SET_VALUE_SET(V) (V)->flags |= VAL_FL_VALUE_SET

#define VAL_CLR_VALUE_SET(V) (V)->flags &= ~VAL_FL_VALUE_SET

#define VAL_IS_VALUE_SET(V) ((V)->flags & VAL_FL_VALUE_SET)

#define VAL_SET_TEMP_XPATH(V) (V)->flags |= VAL_FL_TEMP_XPATH

#define VAL_CLR_TEMP_XPATH(V) (V)->flags &= ~VAL_FL_TEMP_XPATH

#define VAL_IS_TEMP_XPATH(V) ((V)->flags & VAL_FL_TEMP_XPATH)

#define VAL_SET_UNCOMMITTED_DELETE(V) (V)->flags |= VAL_FL_UNCMTD_DELETE

#define VAL_CLR_UNCOMMITTED_DELETE(V) (V)->flags &= ~VAL_FL_UNCMTD_DELETE

#define VAL_IS_UNCOMMITTED_DELETE(V) ((V)->flags & VAL_FL_UNCMTD_DELETE)

#define VAL_SET_RECREATED(V) (V)->flags |= VAL_FL_RECREATED

#define VAL_CLR_RECREATED(V) (V)->flags &= ~VAL_FL_RECREATED

#define VAL_IS_RECREATED(V) ((V)->flags & VAL_FL_RECREATED)

#define VAL_SET_FROM_TEMPLATE(V) (V)->flags |= VAL_FL_FROM_TEMPLATE

#define VAL_CLR_FROM_TEMPLATE(V) (V)->flags &= ~VAL_FL_FROM_TEMPLATE

#define VAL_IS_FROM_TEMPLATE(V) ((V)->flags & VAL_FL_FROM_TEMPLATE)

#define VAL_XPATHPCB(V) val_get_xpathpcb(V)

#define VAL_SET_CANONICAL(V) (V)->flags |= VAL_FL_CANONICAL

#define VAL_CLR_CANONICAL(V) (V)->flags &= ~VAL_FL_CANONICAL

#define VAL_IS_CANONICAL(V) ((V)->flags & VAL_FL_CANONICAL)

#define VAL_NMDA_ORIGIN(V) (V)->nmda_origin

#define VAL_IS_INDEX(V) ((V)->flags & VAL_FL_IS_INDEX)

#define VAL_SET_IS_INDEX(V) (V)->flags |= VAL_FL_IS_INDEX

#define VAL_CHILD_HDR_OBJ(H) (H)->obj

#define VAL_CHILD_HDR_COUNT(H) (H)->count

#define VAL_SET_DEFCON_DELETED(V) (V)->flags |= VAL_FL_DEFCON_DELETED

#define VAL_CLR_DEFCON_DELETED(V) (V)->flags &= ~VAL_FL_DEFCON_DELETED

#define VAL_IS_DEFCON_DELETED(V) ((V)->flags & VAL_FL_DEFCON_DELETED)


#define VAL_SET_ADDEDIT_DELETED(V) (V)->flags |= VAL_FL_ADDEDIT_DELETED

#define VAL_IS_ADDEDIT_DELETED(V) ((V)->flags & VAL_FL_ADDEDIT_DELETED)


#define VAL_EDITOP(V) (V)->editop

/********************************************************************
*                                                                   *
*                            T Y P E S                              *
*                                                                   *
*********************************************************************/

typedef void (*dumpfn_t) (log_debug_t level, const char *fstr, ...);


typedef void (*errfn_t) (const char *fstr, ...);


/* pick a log indent function for dump_value */
typedef void (*indentfn_t) (log_debug_t level, int32 indentcnt);


typedef struct logfns_t_ {
    dumpfn_t dumpfn;              
    errfn_t errorfn;              
    indentfn_t indentfn;          
    boolean suppressVariableNames;  
    FILE *outputFile;            
} logfns_t;


typedef struct val_idref_t_ {
    xmlns_id_t  nsid;          
    xmlChar    *name;
    ncx_identity_t  *identity;  
} YPACK val_idref_t;


typedef enum val_insert_mode_t_ {
    VAL_INS_MODE_NONE,          
    VAL_INS_MODE_KEY,           
    VAL_INS_MODE_VALUE,         
    VAL_INS_MODE_POINT          
} YPACK val_insert_mode_t;


typedef enum val_dumpvalue_mode_t_ {
    DUMP_VAL_NONE,        
    DUMP_VAL_STDOUT,      
    DUMP_VAL_LOG,         
    DUMP_VAL_ALT_LOG,     
    DUMP_VAL_AUDIT_LOG,   
} val_dumpvalue_mode_t;


typedef struct val_editvars_t_ {
    struct val_value_t_  *curparent;   
    op_insertop_t  insertop;           
    xmlChar       *insertstr;          
    struct xpath_pcb_t_ *insertxpcb;   
    struct val_value_t_ *insertval;    
    val_insert_mode_t insert_mode;     
    uint8          silprio;            
    boolean        operset;            
    void          *pcookie;            
    int            icookie;            
    boolean        is_move;            
    boolean        skip_sil_partial;   
} YPACK val_editvars_t;


typedef struct val_extra_t_ {

    xmlChar         *dname;          
    void *getcb;

    struct val_value_t_ *virtualval;

    time_t               cachetime;

    struct xpath_pcb_t_            *xpathpcb;


    plock_cb_t  *plock[VAL_MAX_PLOCKS];


    dlq_hdr_t *dataruleQ;   
    xmlChar *varexpr;

} YPACK val_extra_t;


typedef struct val_value_t_ {
    dlq_hdr_t      qhdr;

    struct obj_template_t_ *obj;             
    typ_def_t *typdef;                   
    const xmlChar *name;                 
    struct val_value_t_ *parent;       
    struct val_child_hdr_t_ *hdr;      
    val_extra_t *val_extra;

    uint32         flags;                  
    xmlns_id_t     nsid;              
    ncx_btype_t    btyp;                 
    ncx_data_class_t dataclass;             
    time_t         last_modified;
    ncx_etag_t     etag;    
    dlq_hdr_t        *metaQ;                     
    val_editvars_t  *editvars;               
    op_editop_t      editop;                 
    status_t         res;                     
    /* GET1 getcb moved to val_extra */
    /* GET1 virtualval moved to val_extra */
    /* GET1 cachetime moved to val_extra */

    dlq_hdr_t  *indexQ;    
    /* this field is used for NCX_BT_CHOICE
     * If set, the object path for this node is really:
     *    $this --> casobj --> casobj.parent --> $this.parent
     * the OBJ_TYP_CASE and OBJ_TYP_CHOICE nodes are skipped
     * inside an XML instance document
     *
     * replaced by val_get_casobj() function in val_util.h
     * struct obj_template_t_   *casobj;
     */

    /* xpathpcb moved to val_extra_t */

    /* back-ptr to the partial locks that are held
     * against this node
     * plock moved to val_extra
     */

    /* back-ptr to the data access control rules that
     * reference this node
     * dataruleQ moved to val_extra
     */

    /* malloced pointer to the variable expression found
     * if this val node is part of a data template.
     * The actual value in union v_ MUST be ignored if
     * varexpr string is non-NULL!!
     * varexpr moved to val_extra
     */

    ncx_owner_id_t owner_id;

    ncx_nmda_origin_t nmda_origin;

    union v_ {
        dlq_hdr_t   child_hdrQ;

        ncx_num_t   num;

        ncx_str_t  str;

        val_idref_t idref;                 
        ncx_binary_t binary;              
        ncx_list_t list;      
        boolean    boo;    
        ncx_enum_t enu;       
        xmlChar   *fname;                 
        xmlChar   *intbuff;               
    } YPACK v;
} YPACK val_value_t;


typedef struct val_child_hdr_t_ {
    dlq_hdr_t qhdr;           
    struct obj_template_t_ *obj;

    struct val_tree_t_ *tree;

    dlq_hdr_t que;

    uint32 count;

    uint8 flags;
} YPACK val_child_hdr_t;


typedef struct val_index_t_ {
    dlq_hdr_t     qhdr;    
    val_value_t  *val;     
} YPACK val_index_t;


typedef struct val_unique_t_ {
    dlq_hdr_t     qhdr;    
    struct xpath_pcb_t_ *pcb;  
} YPACK val_unique_t;


typedef boolean
    (*val_test_fn_t) (const val_value_t *val);


typedef boolean
    (*val_walker_fn_t) (val_value_t *val,
                        void *cookie1,
                        void *cookie2);



typedef boolean
    (*val_walker2_fn_t) (val_child_hdr_t *valhdr,
                         void *cookie1,
                         void *cookie2);



typedef boolean
    (*val_hdr_test_fn_t) (val_child_hdr_t *hdr,
                          void *cookie);


typedef boolean
    (*val_test2_fn_t) (val_value_t *val,
                       void *cookie);


/********************************************************************
*                                                                   *
*                       F U N C T I O N S                           *
*                                                                   *
*********************************************************************/

extern val_value_t *
    val_new_value (void);


extern void
    val_init_value (val_value_t *val);


extern void
    val_init_complex (val_value_t *val,
                      ncx_btype_t btyp);


extern void
    val_init_virtual (val_value_t *val,
                      void *cbfn,
                      struct obj_template_t_ *obj);


extern void
    val_init_from_template (val_value_t *val,
                            struct obj_template_t_ *obj);


extern void
    val_reinit_from_template (val_value_t *val,
                              struct obj_template_t_ *obj);


extern void
    val_free_value (val_value_t *val);


extern void
    val_set_name (val_value_t *val,
                  const xmlChar *name,
                  uint32 namelen);


extern status_t
    val_force_dname (val_value_t *val);


extern void
    val_set_qname (val_value_t *val,
                   xmlns_id_t   nsid,
                   const xmlChar *name,
                   uint32 namelen);


extern status_t
    val_string_ok (typ_def_t *typdef,
                   ncx_btype_t  btyp,
                   const xmlChar *strval);


extern status_t
    val_string_ok_errinfo (typ_def_t *typdef,
                           ncx_btype_t  btyp,
                           const xmlChar *strval,
                           ncx_errinfo_t **errinfo);


status_t
    val_binary_ok_errinfo (typ_def_t *typdef,
                           const xmlChar *strval,
                           val_value_t *val,
                           ncx_errinfo_t **errinfo);


extern status_t
    val_string_ok_ex (ses_cb_t *scb,
                      typ_def_t *typdef,
                      ncx_btype_t btyp,
                      const xmlChar *strval,
                      ncx_errinfo_t **errinfo,
                      boolean logerrors);


extern status_t
    val_string_ok_ex2 (ses_cb_t *scb,
                      typ_def_t *typdef,
                      ncx_btype_t btyp,
                      const xmlChar *strval,
                      ncx_errinfo_t **errinfo,
                      boolean logerrors,
                      boolean is_defval);


extern status_t
    val_list_ok (typ_def_t *typdef,
                 ncx_btype_t btyp,
                 ncx_list_t *list);


extern status_t
    val_list_ok_errinfo (typ_def_t *typdef,
                         ncx_btype_t btyp,
                         ncx_list_t *list,
                         ncx_errinfo_t **errinfo);


extern status_t
    val_enum_ok (typ_def_t *typdef,
                 const xmlChar *enumval,
                 int32 *retval,
                 const xmlChar **retstr);


extern status_t
    val_bit_ok (typ_def_t *typdef,
                const xmlChar *bitname,
                uint32 *position);


extern status_t
    val_idref_ok (typ_def_t *typdef,
                  const xmlChar *qname,
                  xmlns_id_t nsid,
                  const xmlChar **name,
                  ncx_identity_t **id);


extern status_t
    val_idref_ok_ex (typ_def_t *typdef,
                     const xmlChar *qname,
                     xmlns_id_t nsid,
                     boolean is_json,
                     ncx_module_t *impmod,
                     boolean or_self,
                     const xmlChar **name,
                     ncx_identity_t **id);


extern status_t
    val_parse_idref (ncx_module_t *mod,
                     const xmlChar *qname,
                     xmlns_id_t  *nsid,
                     const xmlChar **name,
                     ncx_identity_t **id);


extern status_t
    val_range_ok (typ_def_t *typdef,
                  ncx_btype_t  btyp,
                  const ncx_num_t *num);


extern status_t
    val_range_ok_errinfo (typ_def_t *typdef,
                          ncx_btype_t  btyp,
                          const ncx_num_t *num,
                          ncx_errinfo_t **errinfo);


extern status_t
    val_pattern_ok (typ_def_t *typdef,
                    const xmlChar *strval);


extern status_t
    val_pattern_ok_errinfo (typ_def_t *typdef,
                            const xmlChar *strval,
                            ncx_errinfo_t **errinfo);


extern status_t
    val_simval_ok (typ_def_t *typdef,
                   const xmlChar *simval);



extern status_t
    val_simval_ok_errinfo (typ_def_t *typdef,
                           const xmlChar *simval,
                           ncx_errinfo_t **errinfo);


extern status_t
    val_simval_ok_ex (typ_def_t *typdef,
                      const xmlChar *simval,
                      ncx_errinfo_t **errinfo,
                      ncx_module_t *mod);


extern status_t
    val_simval_ok_max (typ_def_t *typdef,
                       const xmlChar *simval,
                       ncx_errinfo_t **errinfo,
                       ncx_module_t *mod,
                       boolean logerrors);

extern status_t
    val_simval_ok_max2 (typ_def_t *typdef,
                        const xmlChar *simval,
                        ncx_errinfo_t **errinfo,
                        ncx_module_t *mod,
                        boolean logerrors,
                        boolean nocond);


status_t
    val_simval_ok_max3 (typ_def_t *typdef,
                        const xmlChar *simval,
                        ncx_errinfo_t **errinfo,
                        ncx_module_t *mod,
                        boolean logerrors,
                        boolean nocond,
                        boolean is_defval);


extern status_t
    val_union_ok (typ_def_t *typdef,
                  const xmlChar *strval,
                  val_value_t *retval);


extern status_t
    val_union_ok_errinfo (typ_def_t *typdef,
                          const xmlChar *strval,
                          val_value_t *retval,
                          ncx_errinfo_t **errinfo);


extern status_t
    val_union_ok_ex (typ_def_t *typdef,
                     const xmlChar *strval,
                     val_value_t *retval,
                     ncx_errinfo_t **errinfo,
                     ncx_module_t *mod,
                     typ_def_t **match_typdef);


extern status_t
    val_union_ok_binary (typ_def_t *typdef,
                         const xmlChar *binstr,
                         uint32 binstrlen,
                         val_value_t *retval,
                         ncx_errinfo_t **errinfo,
                         typ_def_t **match_typdef);


extern status_t
    val_union_ok_full (typ_def_t *typdef,
                       const xmlChar *strval,
                       val_value_t *contextval,
                       val_value_t *rootval,
                       val_value_t *retval,
                       ncx_errinfo_t **errinfo);


extern dlq_hdr_t *
    val_get_metaQ (val_value_t  *val);


extern val_value_t *
    val_get_first_meta (dlq_hdr_t *queue);


extern val_value_t *
    val_get_first_meta_val (val_value_t *val);


extern val_value_t *
    val_get_next_meta (val_value_t *curnode);


extern boolean
    val_meta_empty (val_value_t *val);


extern val_value_t *
    val_find_meta (val_value_t *val,
                   xmlns_id_t   nsid,
                   const xmlChar *name);


extern boolean
    val_meta_match (val_value_t *val,
                    val_value_t *metaval);


extern uint32
    val_metadata_inst_count (val_value_t  *val,
                             xmlns_id_t nsid,
                             const xmlChar *name);


extern void
    val_dump_value (val_value_t *val,
                    int32 startindent,
                    log_debug_t lvl);


extern void
    val_dump_value_ex (val_value_t *val,
                       int32 startindent,
                       ncx_display_mode_t display_mode,
                       log_debug_t lvl);


extern void
    val_dump_alt_value (val_value_t *val,
                        int32 startindent,
                        log_debug_t lvl);


extern void
    val_stdout_value (val_value_t *val,
                      int32 startindent,
                      log_debug_t lvl);


extern void
    val_stdout_value_ex (val_value_t *val,
                         int32 startindent,
                         ncx_display_mode_t display_mode,
                         log_debug_t lvl);


extern void
    val_dump_value_max (val_value_t *val,
                        int32 startindent,
                        int32 indent_amount,
                        val_dumpvalue_mode_t dumpmode,
                        ncx_display_mode_t display_mode,
                        boolean with_meta,
                        boolean configonly,
                        log_debug_t lvl);


extern void
    val_dump_value_full (val_value_t *val,
                         int32 startindent,
                         int32 indent_amount,
                         val_dumpvalue_mode_t dumpmode,
                         ncx_display_mode_t display_mode,
                         boolean with_meta,
                         boolean configonly,
                         boolean conf_mode,
                         boolean expand_varexpr,
                         log_debug_t lvl,
                         logfns_t *overrideOutput);


extern void
    val_dump_value_full2 (val_value_t *val,
                          int32 startindent,
                          int32 indent_amount,
                          val_dumpvalue_mode_t dumpmode,
                          ncx_display_mode_t display_mode,
                          boolean with_meta,
                          boolean configonly,
                          boolean conf_mode,
                          boolean expand_varexpr,
                          boolean withdef,
                          log_debug_t lvl,
                          logfns_t *overrideOutput);


extern status_t
    val_set_string (val_value_t  *val,
                    const xmlChar *valname,
                    const xmlChar *valstr);


extern status_t
    val_set_string2 (val_value_t  *val,
                     const xmlChar *valname,
                     typ_def_t *typdef,
                     const xmlChar *valstr,
                     uint32 valstrlen);


extern status_t
    val_set_binary (const xmlChar *valstr,
                    uint32 valstrlen,
                    val_value_t *val);



extern status_t
    val_reset_empty (val_value_t  *val);


extern status_t
    val_set_simval (val_value_t  *val,
                    typ_def_t *typdef,
                    xmlns_id_t    nsid,
                    const xmlChar *valname,
                    const xmlChar *valstr);


extern status_t
    val_set_simval_str (val_value_t  *val,
                        typ_def_t *typdef,
                        xmlns_id_t    nsid,
                        const xmlChar *valname,
                        uint32 valnamelen,
                        const xmlChar *valstr);


extern status_t
    val_set_simval_binary (val_value_t  *val,
                           const xmlChar *binstr,
                           uint32 binstrlen);


extern status_t
    val_set_simval_max (val_value_t  *val,
                        typ_def_t *typdef,
                        xmlns_id_t    nsid,
                        const xmlChar *valname,
                        uint32 valnamelen,
                        const xmlChar *valstr,
                        uint32 valstrlen);


extern val_value_t *
    val_make_simval (typ_def_t *typdef,
                     xmlns_id_t    nsid,
                     const xmlChar *valname,
                     const xmlChar *valstr,
                     status_t  *res);


extern val_value_t *
    val_make_string (xmlns_id_t nsid,
                     const xmlChar *valname,
                     const xmlChar *valstr);


extern val_value_t *
    val_make_binary (xmlns_id_t nsid,
                     const xmlChar *valname,
                     const xmlChar *valstr,
                     uint32 valstrlen);


extern status_t
    val_merge (const val_value_t *src,
               val_value_t *dest);


extern val_value_t *
    val_clone (const val_value_t *val);


extern val_value_t *
    val_clone2 (const val_value_t *val);


extern val_value_t *
    val_clone_config_data (const val_value_t *val,
                           status_t *res);


extern val_value_t *
    val_clone_config_save (const val_value_t *val,
                           status_t *res);


extern status_t
    val_replace (val_value_t *val,
                 val_value_t *copy);


extern status_t
    val_replace_str (const xmlChar *str,
                     uint32 stringlen,
                     val_value_t *copy);


extern status_t
    val_fast_replace_string (const xmlChar *str,
                             uint32 stringlen,
                             val_value_t *copy);


extern void
    val_replace_stringval (val_value_t *val,
                           const xmlChar *str);


extern void
    val_add_child (val_value_t *child,
                   val_value_t *parent);


extern void
    val_add_child_sorted (val_value_t *child,
                          val_value_t *parent);


extern void
    val_insert_child (val_value_t *child,
                      val_value_t *current,
                      val_value_t *parent);


extern void
    val_remove_child (val_value_t *child);


extern void
    val_swap_child (val_value_t *newchild,
                    val_value_t *curchild);


extern val_value_t *
    val_first_child_match (const val_value_t *parent,
                           const val_value_t *child);


extern val_value_t *
    val_first_child_match_fast (const val_value_t *parent,
                                const val_value_t *child,
                                val_value_t *lastmatch);


extern val_value_t *
    val_next_child_match (val_value_t *parent,
                          val_value_t *child,
                          val_value_t *curmatch);


extern val_value_t *
    val_next_child_same (val_value_t *curchild);


extern val_value_t *
    val_get_first_child (const val_value_t *parent);


extern val_value_t *
    val_get_next_child (const val_value_t *curchild);


extern val_value_t *
    val_get_first_terminal_child (const val_value_t  *parent);


extern val_value_t *
    val_get_next_terminal_child (const val_value_t  *curchild);


extern val_value_t *
    val_find_child (const val_value_t  *parent,
                    const xmlChar  *modname,
                    const xmlChar *childname);


extern val_value_t *
    val_find_child_fast (const val_value_t  *parent,
                         xmlns_id_t nsid,
                         const xmlChar *childname);


extern val_value_t *
    val_find_child_obj (const val_value_t *parent,
                        const struct obj_template_t_ *chobj);


extern val_value_t *
    val_find_child_que (const dlq_hdr_t *childQ,
                        xmlns_id_t nsid,
                        const xmlChar *childname);


extern val_value_t *
    val_match_child (const val_value_t  *parent,
                     const xmlChar  *modname,
                     const xmlChar *childname);


extern val_value_t *
    val_match_child_count (const val_value_t  *parent,
                           const xmlChar *modname,
                           const xmlChar *childname,
                           uint32 *matchcount);


extern val_value_t *
    val_find_next_child (const val_value_t  *parent,
                         const xmlChar  *modname,
                         const xmlChar *childname,
                         const val_value_t *curchild);


extern val_value_t *
    val_find_next_child_fast (const val_value_t *parent,
                              const val_value_t *curchild);


extern val_value_t *
    val_first_child_name (val_value_t *parent,
                          const xmlChar *name);


extern val_value_t *
    val_first_child_qname (val_value_t *parent,
                           xmlns_id_t   nsid,
                           const xmlChar *name);


extern val_value_t *
    val_next_child_qname (val_value_t *parent,
                          xmlns_id_t   nsid,
                          const xmlChar *name,
                          val_value_t *curchild);


extern val_value_t *
    val_first_child_string (val_value_t *parent,
                            const xmlChar *name,
                            const xmlChar *strval);


extern uint32
    val_child_cnt (val_value_t *parent);


extern uint32
    val_child_inst_cnt (const val_value_t *parent,
                        const xmlChar *modname,
                        const xmlChar *name);


extern uint32
    val_get_child_inst_id (const val_value_t *parent,
                           const val_value_t *child);


extern uint32
    val_liststr_count (const val_value_t *val);


extern boolean
    val_index_match (const val_value_t *val1,
                     const val_value_t *val2);


extern int
    val_index_compare (const val_value_t *val1,
                       const val_value_t *val2);


extern int32
    val_compare_max (const val_value_t *val1,
                     const val_value_t *val2,
                     boolean configonly,
                     boolean childonly,
                     boolean editing);


extern int32
    val_compare_max_def (const val_value_t *val1,
                         const val_value_t *val2,
                         boolean configonly,
                         boolean childonly,
                         boolean editing,
                         boolean ignore_defaults);


extern int32
    val_compare_ex (const val_value_t *val1,
                    const val_value_t *val2,
                    boolean configonly);


extern int32
    val_compare (const val_value_t *val1,
                 const val_value_t *val2);


extern int32
    val_compare_to_string (const val_value_t *val1,
                           const xmlChar *strval2,
                           status_t *res);


extern int32
    val_compare_to_string_len (const val_value_t *val1,
                               const xmlChar *strval2,
                               uint32 strval2len,
                               status_t *res);


extern int32
    val_compare_for_replace (const val_value_t *val1,
                             const val_value_t *val2);


extern int32
    val_compare_for_edit (const val_value_t *val1,
                          const val_value_t *val2,
                          boolean ismerge);


extern int32
    val_compare_as_string (const val_value_t *val1,
                           const val_value_t *val2,
                           status_t *res);


extern status_t
    val_sprintf_simval_nc (xmlChar *buff,
                           const val_value_t  *val,
                           uint32  *len);


extern status_t
    val_sprintf_simval_nc_ex (xmlChar *buff,
                              const val_value_t *val,
                              boolean url_encode,
                              uint32 *len);


extern xmlChar *
    val_make_sprintf_string (const val_value_t *val);


extern status_t
    val_resolve_scoped_name (val_value_t *val,
                             const xmlChar *name,
                             val_value_t **chval);


extern ncx_iqual_t
    val_get_iqualval (const val_value_t *val);


extern boolean
    val_duplicates_allowed (val_value_t *val);


extern boolean
    val_has_content (const val_value_t *val);


extern boolean
    val_has_content_ex (const val_value_t *val);


extern boolean
    val_has_index (const val_value_t *val);


extern val_index_t *
    val_get_first_index (const val_value_t *val);


extern val_index_t *
    val_get_next_index (const val_index_t *valindex);


extern uint32
    val_get_index_count (const val_value_t *val);


extern status_t
    val_parse_meta (ses_cb_t *scb,
                    typ_def_t *typdef,
                    xml_attr_t *attr,
                    val_value_t *retval);


extern void
    val_set_extern (val_value_t  *val,
                    xmlChar *fname);


extern void
    val_set_intern (val_value_t  *val,
                    xmlChar *intbuff);


extern boolean
    val_fit_oneline (const val_value_t *val,
                     uint32 linesize,
                     boolean isxml);


extern boolean
    val_create_allowed (const val_value_t *val);


extern boolean
    val_delete_allowed (const val_value_t *val);


extern boolean
    val_is_config_data (const val_value_t *val);


extern boolean
    val_is_config_save (const val_value_t *val);


extern boolean
    val_is_virtual (const val_value_t *val);


extern val_value_t *
    val_get_virtual_value (ses_cb_t *scb,
                           val_value_t *val,
                           status_t *res);


extern boolean
    val_is_default (val_value_t *val);


extern boolean
    val_is_real (const val_value_t *val);


extern xmlns_id_t
    val_get_parent_nsid (const val_value_t *val);


extern uint32
    val_instance_count (val_value_t  *val,
                        const xmlChar *modname,
                        const xmlChar *objname);


extern uint32
    val_instance_count_fast (val_value_t  *val,
                             xmlns_id_t nsid,
                             const xmlChar *objname,
                             val_value_t **firstval);


extern uint32
    val_instance_count_fast2 (val_value_t *val,
                              val_value_t *startval);


extern void
    val_set_extra_instance_errors (val_value_t  *val,
                                   const xmlChar *modname,
                                   const xmlChar *objname,
                                   uint32 maxelems);


extern boolean
    val_need_quotes (const xmlChar *str);


extern boolean
    val_all_whitespace (const xmlChar *str);


extern boolean
    val_any_whitespace (const xmlChar *str,
                        uint32 len);


extern boolean
    val_match_metaval (const xml_attr_t *attr,
                       xmlns_id_t  nsid,
                       const xmlChar *name);


extern boolean
    val_get_dirty_flag (const val_value_t *val);


extern boolean
    val_get_subtree_dirty_flag (const val_value_t *val);


extern void
    val_set_subtree_dirty_up (val_value_t *val);


extern void
    val_set_dirty_flag (val_value_t *val,
                        boolean clear_def);


extern void
    val_set_child_deleted_flag (val_value_t *val);


extern boolean
    val_get_child_deleted_flag (val_value_t *val);



extern void
    val_clear_dirty_flag (val_value_t *val,
                          time_t *timestamp,
                          ncx_transaction_id_t txid,
                          boolean is_delete,
                          boolean do_clear_default);


extern boolean
    val_dirty_subtree (const val_value_t *val);


extern void
    val_clean_tree (val_value_t *val);


extern uint32
    val_get_nest_level (val_value_t *val);


extern val_value_t *
    val_get_first_leaf (val_value_t *val);


extern const xmlChar *
    val_get_mod_name (const val_value_t *val);


extern const xmlChar *
    val_get_mod_prefix (const val_value_t *val);


extern xmlns_id_t
    val_get_nsid (const val_value_t *val);


extern void
    val_change_nsid (val_value_t *val,
                     xmlns_id_t nsid);


extern void
    val_change_nsid2 (val_value_t *val,
                      xmlns_id_t nsid);


extern void
    val_change_nsid3 (val_value_t *val,
                      xmlns_id_t nsid);


extern val_value_t *
    val_make_from_insertxpcb (val_value_t  *sourceval,
                              status_t *res);


extern val_unique_t *
    val_new_unique (void);


extern void
    val_free_unique (val_unique_t *valuni);


extern const typ_def_t *
    val_get_typdef (const val_value_t *val);


extern boolean
    val_set_by_default (const val_value_t *val);


extern boolean
    val_has_withdef_default (const val_value_t *val);


extern void
    val_set_withdef_default (val_value_t *val);


extern boolean
    val_is_metaval (const val_value_t *val);


extern void
    val_move_children (val_value_t *srcval,
                       val_value_t *destval);


extern void
    val_move_nonconfig_children (val_value_t *srcval,
                                 val_value_t *destval);

extern status_t
    val_cvt_generic (val_value_t *val);


extern status_t
    val_set_pcookie (val_value_t *val,
                     void *pcookie);


extern status_t
    val_set_icookie (val_value_t *val,
                     int icookie);


extern void *
    val_get_pcookie (val_value_t *val);


extern int
    val_get_icookie (val_value_t *val);


extern status_t
    val_delete_default_leaf (val_value_t *val);


extern status_t
    val_delete_default_leaf_list (val_value_t *val);


extern void
    val_force_empty (val_value_t *val);


extern status_t
    val_delete_default_npcon (val_value_t *val);


extern void
    val_move_fields_for_xml (val_value_t *srcval,
                             val_value_t *destval,
                             boolean movemeta);


extern void
    val_move_metadata (val_value_t *srcval,
                       val_value_t *destval);


extern val_index_t *
    val_get_first_key (val_value_t *val);


extern val_index_t *
    val_get_last_key (val_value_t *val);


extern val_index_t *
    val_get_next_key (val_index_t *curkey);


extern val_index_t *
    val_get_prev_key (val_index_t *curkey);


extern void
    val_remove_key (val_value_t *keyval);


extern val_value_t *
    val_new_deleted_value (void);


extern status_t
    val_new_editvars (val_value_t *val);


extern void
    val_free_editvars (val_value_t *val);


extern void
    val_free_solo_editvars (val_editvars_t *editvars);


extern boolean
    val_all_np_containers (val_value_t *val);


extern status_t
    val_sprintf_etag (val_value_t *val,
                      xmlChar *buff,
                      int32 buffsize);


extern time_t *
    val_get_last_modified (val_value_t *val);


extern void
    val_force_default (val_value_t *val);

extern void
    val_set_all_tags (val_value_t *val,
                      time_t *timestamp,
                      ncx_transaction_id_t txid);


extern const xmlChar *
    val_get_owner (val_value_t *val);


extern ncx_owner_id_t
    val_get_owner_id (val_value_t *val);


extern boolean
    val_need_owner_string (val_value_t *val);


extern void
    val_delete_children (val_value_t *val);


extern void
    val_clean_value (val_value_t *val);


extern boolean
    val_find_bit (val_value_t *val,
                  const xmlChar *bitname);


extern boolean
    val_has_children (const val_value_t *val);


extern status_t
    val_add_test_valindex (val_value_t *parentval,
                           val_value_t *keyval);


extern const xmlChar *
    val_get_yang_typename (val_value_t *val);


extern void
    val_set_force_config (val_value_t *val,
                          boolean is_config);


extern void
    val_clear_defvalset_flag (val_value_t *val);


extern status_t
    val_clone_valQ (dlq_hdr_t *valQ,
                    dlq_hdr_t *return_valQ);


extern void
    val_clean_valQ (dlq_hdr_t *valQ);


extern boolean
    val_is_value_set (val_value_t *val);


extern uint32
    val_url_encode_string (const xmlChar *str,
                           xmlChar *buff);


extern void
    val_convert_any_to_container (val_value_t *val);


extern void
    val_clean_index_chain (val_value_t *val);


extern boolean
    val_pattern_match (const xmlRegexpPtr pattern,
                       const xmlChar *strval);


extern boolean
    val_ocpattern_match (const regex_t *ocpattern,
                         const xmlChar *strval);


extern boolean
    val_idref_derived_from (ncx_module_t *impmod,
                            val_value_t *testval,
                            const xmlChar *qname,
                            boolean or_self);


extern status_t
    val_set_sil_priority (val_value_t *val,
                          uint8 silprio);


extern uint8
    val_get_sil_priority (val_value_t *val);


extern const xmlChar *
    val_find_bit_name (val_value_t *val,
                       uint32 bitpos);


extern const xmlChar *
    val_find_enum_name (val_value_t *val,
                        int32 enunum);


extern const xmlChar *
    val_find_enum_name2 (ncx_btype_t btyp,
                         typ_def_t *typdef,
                         int32 enunum);


extern void
    val_mark_deleted (val_value_t *val);


extern void
    val_mark_undeleted (val_value_t *val);


extern boolean
    val_has_conditional_value (val_value_t  *val);


extern val_value_t *
    val_convert_leafref (const val_value_t  *val);


extern int32
    val_compare_for_topreplace (const val_value_t *val1,
                                const val_value_t *val2);


extern int32
    val_compare_for_topreplace_simple (const val_value_t *val1,
                                       const val_value_t *val2);


extern boolean
    val_has_complex_child (const val_value_t  *val);


extern status_t
    val_add_meta (val_value_t *metaval,
                   val_value_t *val);


extern val_value_t *
    val_find_root (val_value_t *val);


extern status_t
    val_set_canonical (val_value_t *val);


extern typ_def_t *
    val_get_leafref_typdef (val_value_t  *val);


extern boolean
    val_ascendant_compare (val_value_t *val1,
                           val_value_t *val2);


extern const xmlChar *
    val_get_dname (const val_value_t *val);


extern status_t
    val_set_dname (val_value_t *val,
                   const xmlChar *dname);


extern status_t
    val_set_dname2 (val_value_t *val,
                    const xmlChar *dname,
                    uint32 dnamelen);


extern status_t
    val_new_extra (val_value_t *val);


extern const xmlChar *
    val_get_varexpr (const val_value_t *val);


extern status_t
    val_set_varexpr (val_value_t *val,
                     const xmlChar *varexpr);


extern void
    val_clear_varexpr (val_value_t *val);


extern void
    val_set_wildcard_string (val_value_t *val);


#define val_is_wildcard_string(V) (((V)->flags & VAL_FL_WILDCARD) ? TRUE : FALSE)


extern status_t
    val_copy_editvars (const val_value_t *val,
                       val_value_t *copy);


extern status_t
    val_set_skip_sil_partial (val_value_t *val);


extern boolean
    val_get_skip_sil_partial (const val_value_t *val);


extern typ_def_t *
    val_get_leafref_typdef_ex (val_value_t *val,
                               boolean union_check);



extern boolean
    val_is_default_npcon (val_value_t *val);


#ifdef __cplusplus
}  /* end extern 'C' */
#endif

#endif      /* _H_val */