zxsd.h

Go to the documentation of this file.

/*
 * Copyright (c) 2026 Sixtaupi
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZXSD_H
#define ZXSD_H
 
#include <stddef.h>
#include <stdint.h>
 
#include "zxsd_version.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef ZXSD_MAX_INPUT
#define ZXSD_MAX_INPUT (1024u * 1024u)
#endif
#ifndef ZXSD_MAX_DEPTH
#define ZXSD_MAX_DEPTH 32u
#endif
#ifndef ZXSD_MAX_PARTICLES
#define ZXSD_MAX_PARTICLES 32u
#endif
#if ZXSD_MAX_PARTICLES > 65536u
#error "ZXSD_MAX_PARTICLES exceeds the 16-bit streaming particle-token space"
#endif
#ifndef ZXSD_MAX_ATTRIBUTES
#define ZXSD_MAX_ATTRIBUTES 32u
#endif
#ifndef ZXSD_MAX_NAMESPACES
#define ZXSD_MAX_NAMESPACES 16u
#endif
#ifndef ZXSD_MAX_IDENTITY_ROWS
#define ZXSD_MAX_IDENTITY_ROWS 64u
#endif
#ifndef ZXSD_MAX_IDENTITY_VALUES
#define ZXSD_MAX_IDENTITY_VALUES ZXSD_MAX_IDENTITY_ROWS
#endif
#ifndef ZXSD_MAX_IDENTITY_TEXT
#define ZXSD_MAX_IDENTITY_TEXT 4096u
#endif
#ifndef ZXSD_MAX_IDENTITY_CONSTRAINTS
#define ZXSD_MAX_IDENTITY_CONSTRAINTS 16u
#endif
#ifndef ZXSD_MAX_IDENTITY_FIELDS
#define ZXSD_MAX_IDENTITY_FIELDS 8u
#endif
#ifndef ZXSD_MAX_XPATH_DEPTH
#define ZXSD_MAX_XPATH_DEPTH 8u
#endif
#ifndef ZXSD_MAX_XPATH_ALTERNATIVES
#define ZXSD_MAX_XPATH_ALTERNATIVES 8u
#endif
#ifndef ZXSD_STREAM_TEXT_CAPACITY
#define ZXSD_STREAM_TEXT_CAPACITY ZXSD_MAX_TEXT_LENGTH
#endif
#ifndef ZXSD_MAX_TEXT_LENGTH
#define ZXSD_MAX_TEXT_LENGTH 1024u
#endif
#ifndef ZXSD_MAX_PATTERN_LENGTH
#define ZXSD_MAX_PATTERN_LENGTH 4096u
#endif
#ifndef ZXSD_MAX_REGEX_NODES
#define ZXSD_MAX_REGEX_NODES 512u
#endif
#ifndef ZXSD_MAX_REGEX_DEPTH
#define ZXSD_MAX_REGEX_DEPTH 32u
#endif
#ifndef ZXSD_MAX_SCHEMA_COMPLEXITY
#define ZXSD_MAX_SCHEMA_COMPLEXITY 4096u
#endif
#ifndef ZXSD_STREAM_NAME_CAPACITY
#define ZXSD_STREAM_NAME_CAPACITY 128u
#endif
#ifndef ZXSD_STREAM_CHILD_CAPACITY
#define ZXSD_STREAM_CHILD_CAPACITY 64u
#endif
#ifndef ZXSD_STREAM_MODEL_CAPACITY
#define ZXSD_STREAM_MODEL_CAPACITY 128u
#endif
#ifndef ZXSD_XML_TOKEN_CAPACITY
#define ZXSD_XML_TOKEN_CAPACITY 4096u
#endif
 
typedef enum {
    ZXSD_OK = 0,                   
    ZXSD_ERR_ARGUMENT,             
    ZXSD_ERR_INPUT_TOO_LARGE,      
    ZXSD_ERR_MALFORMED_XML,        
    ZXSD_ERR_EXCESSIVE_NESTING,    
    ZXSD_ERR_WRONG_ROOT,           
    ZXSD_ERR_MISSING_ELEMENT,      
    ZXSD_ERR_UNEXPECTED_ELEMENT,   
    ZXSD_ERR_ELEMENT_ORDER,        
    ZXSD_ERR_OCCURRENCE,           
    ZXSD_ERR_MISSING_ATTRIBUTE,    
    ZXSD_ERR_UNEXPECTED_ATTRIBUTE, 
    ZXSD_ERR_INVALID_VALUE,        
    ZXSD_ERR_TEXT_NOT_ALLOWED,     
    ZXSD_ERR_IDENTITY_CONSTRAINT,  
    ZXSD_ERR_STREAM_LIMIT,         
    ZXSD_ERR_RESOURCE_LIMIT,       
    ZXSD_ERR_OUTPUT,               
    ZXSD_ERR_UNSUPPORTED,          
    ZXSD_ERR_INCOMPATIBLE_ABI      
} zxsd_error_t;
 
typedef struct {
    zxsd_error_t code;   
    size_t offset;       
    const char *path;    
    const char *message; 
} zxsd_result_t;
 
typedef void *(*zxsd_allocate_fn)(void *context, size_t size);
 
typedef void (*zxsd_deallocate_fn)(void *context, void *pointer);
 
typedef struct {
    zxsd_allocate_fn allocate;     
    zxsd_deallocate_fn deallocate; 
    void *context;                 
} zxsd_allocator_t;
 
typedef enum {
    ZXSD_T_STRING,               
    ZXSD_T_BOOLEAN,              
    ZXSD_T_INT,                  
    ZXSD_T_UNSIGNED_INT,         
    ZXSD_T_INTEGER,              
    ZXSD_T_DECIMAL,              
    ZXSD_T_FLOAT,                
    ZXSD_T_DOUBLE,               
    ZXSD_T_LONG,                 
    ZXSD_T_SHORT,                
    ZXSD_T_BYTE,                 
    ZXSD_T_NON_POSITIVE_INTEGER, 
    ZXSD_T_NEGATIVE_INTEGER,     
    ZXSD_T_NON_NEGATIVE_INTEGER, 
    ZXSD_T_POSITIVE_INTEGER,     
    ZXSD_T_UNSIGNED_LONG,        
    ZXSD_T_UNSIGNED_SHORT,       
    ZXSD_T_UNSIGNED_BYTE,        
    ZXSD_T_NORMALIZED_STRING,    
    ZXSD_T_TOKEN,                
    ZXSD_T_LANGUAGE,             
    ZXSD_T_NAME,                 
    ZXSD_T_NCNAME,               
    ZXSD_T_NMTOKEN,              
    ZXSD_T_QNAME,                
    ZXSD_T_ANY_URI,              
    ZXSD_T_DURATION,             
    ZXSD_T_DATE,                 
    ZXSD_T_DATE_TIME,            
    ZXSD_T_TIME,                 
    ZXSD_T_GYEAR,                
    ZXSD_T_GYEAR_MONTH,          
    ZXSD_T_GMONTH,               
    ZXSD_T_GMONTH_DAY,           
    ZXSD_T_GDAY,                 
    ZXSD_T_HEX_BINARY,           
    ZXSD_T_BASE64_BINARY,        
    ZXSD_T_ID,                   
    ZXSD_T_IDREF,                
    ZXSD_T_ENTITY,               
    ZXSD_T_NOTATION,             
    ZXSD_T_COMPLEX               
} zxsd_type_t;
 
typedef enum {
    ZXSD_WS_PRESERVE = 0, 
    ZXSD_WS_REPLACE,      
    ZXSD_WS_COLLAPSE      
} zxsd_whitespace_t;
 
typedef enum {
    ZXSD_SIMPLE_ATOMIC = 0, 
    ZXSD_SIMPLE_LIST,       
    ZXSD_SIMPLE_UNION       
} zxsd_simple_variety_t;
 
typedef enum {
    ZXSD_SEQUENCE = 0, 
    ZXSD_CHOICE,       
    ZXSD_ALL           
} zxsd_model_t;
 
typedef enum {
    ZXSD_PROCESS_STRICT = 0, 
    ZXSD_PROCESS_LAX,        
    ZXSD_PROCESS_SKIP        
} zxsd_process_t;
 
typedef enum {
    ZXSD_PARTICLE_ELEMENT = 0, 
    ZXSD_PARTICLE_SEQUENCE,    
    ZXSD_PARTICLE_CHOICE,      
    ZXSD_PARTICLE_ALL,         
    ZXSD_PARTICLE_ANY          
} zxsd_particle_kind_t;
 
enum {
    ZXSD_F_LENGTH = 1u << 0,         
    ZXSD_F_MIN_LENGTH = 1u << 1,     
    ZXSD_F_MAX_LENGTH = 1u << 2,     
    ZXSD_F_MIN_INCLUSIVE = 1u << 3,  
    ZXSD_F_MAX_INCLUSIVE = 1u << 4,  
    ZXSD_F_MIN_EXCLUSIVE = 1u << 5,  
    ZXSD_F_MAX_EXCLUSIVE = 1u << 6,  
    ZXSD_F_PATTERN = 1u << 7,        
    ZXSD_F_TOTAL_DIGITS = 1u << 8,   
    ZXSD_F_FRACTION_DIGITS = 1u << 9 
};
 
enum {
    ZXSD_DERIVATION_EXTENSION = 1u << 0,    
    ZXSD_DERIVATION_RESTRICTION = 1u << 1,  
    ZXSD_DERIVATION_SUBSTITUTION = 1u << 2, 
    ZXSD_DERIVATION_LIST = 1u << 3,         
    ZXSD_DERIVATION_UNION = 1u << 4,        
    ZXSD_DERIVATION_ALL = 0x1fu             
};
 
struct zxsd_simple;
 
typedef struct {
    zxsd_type_t type;                 
    const struct zxsd_simple *simple; 
} zxsd_simple_ref_t;
 
typedef struct zxsd_simple {
    zxsd_type_t base;                          
    unsigned facets;                           
    size_t length;                             
    size_t min_length;                         
    size_t max_length;                         
    const char *min_inclusive;                 
    const char *max_inclusive;                 
    const char *min_exclusive;                 
    const char *max_exclusive;                 
    const char *pattern;                       
    const char *const *enumeration;            
    size_t enumeration_count;                  
    zxsd_whitespace_t whitespace;              
    zxsd_simple_variety_t variety;             
    zxsd_simple_ref_t item_type;               
    const zxsd_simple_ref_t *member_types;     
    size_t member_type_count;                  
    const struct zxsd_simple *base_definition; 
    unsigned derivation_method;                
    unsigned final_methods;                    
    const char *type_name;                     
    const char *type_namespace;                
    const char *const *patterns; 
    size_t pattern_count;        
    const char *const *enumeration_namespaces;
    size_t total_digits;    
    size_t fraction_digits; 
} zxsd_simple_t;
 
struct zxsd_complex;
struct zxsd_particle;
 
typedef struct {
    const char *name;                        
    zxsd_type_t type;                        
    const struct zxsd_complex *complex_type; 
    unsigned long min_occurs;                
    unsigned long max_occurs;                
    const zxsd_simple_t *simple_type;        
    const char *namespace_uri;               
    const char *default_value;               
    const char *fixed_value;                 
    int nillable;                            
    int abstract_element;                    
    unsigned block_methods;                  
    const char *substitution_head_name;      
    const char *substitution_head_namespace; 
} zxsd_element_t;
 
typedef struct {
    const char *name;                 
    zxsd_type_t type;                 
    int required;                     
    const zxsd_simple_t *simple_type; 
    const char *namespace_uri;        
    const char *default_value;        
    const char *fixed_value;          
} zxsd_attribute_t;
 
typedef struct {
    const char *namespace_constraint; 
    const char *target_namespace;     
    zxsd_process_t process_contents;  
} zxsd_wildcard_t;
 
typedef struct zxsd_particle {
    zxsd_particle_kind_t kind;            
    unsigned long min_occurs;             
    unsigned long max_occurs;             
    const zxsd_element_t *element;        
    const struct zxsd_particle *children; 
    size_t child_count;                   
    const zxsd_wildcard_t *wildcard;      
} zxsd_particle_t;
 
typedef struct zxsd_complex {
    const zxsd_element_t *elements;             
    size_t element_count;                       
    const zxsd_attribute_t *attributes;         
    size_t attribute_count;                     
    zxsd_model_t model;                         
    unsigned long min_occurs;                   
    unsigned long max_occurs;                   
    const zxsd_simple_t *simple_content;        
    zxsd_type_t simple_content_type;            
    int has_simple_content;                     
    int abstract_type;                          
    const zxsd_particle_t *particle;            
    const zxsd_wildcard_t *any_attribute;       
    const struct zxsd_complex *base_definition; 
    unsigned derivation_method;                 
    unsigned final_methods;                     
    const char *type_name;                      
    const char *type_namespace;                 
    int mixed_content;                          
    int any_type;                               
    unsigned block_methods; 
} zxsd_complex_t;
 
typedef struct {
    const char *name;          
    const char *namespace_uri; 
} zxsd_xpath_step_t;
 
typedef struct zxsd_xpath {
    const zxsd_xpath_step_t *steps;        
    size_t step_count;                     
    int descendant;                        
    int attribute;                         
    const struct zxsd_xpath *alternatives; 
    size_t alternative_count;              
} zxsd_xpath_t;
 
typedef enum {
    ZXSD_ID_UNIQUE = 0, 
    ZXSD_ID_KEY,        
    ZXSD_ID_KEYREF      
} zxsd_identity_kind_t;
 
typedef struct {
    const char *name;           
    zxsd_identity_kind_t kind;  
    zxsd_xpath_t scope;         
    zxsd_xpath_t selector;      
    const zxsd_xpath_t *fields; 
    size_t field_count;         
    size_t refer_index;         
} zxsd_identity_t;
 
typedef struct {
    const char *name;                        
    const char *namespace_uri;               
    zxsd_type_t type;                        
    const struct zxsd_complex *complex_type; 
    const zxsd_simple_t *simple_type;        
    const char *default_value;               
    const char *fixed_value;                 
    int nillable;                            
    int abstract_element;                    
    unsigned block_methods;                  
    const char *substitution_head_name;      
    const char *substitution_head_namespace; 
} zxsd_global_element_t;
 
typedef struct {
    const char *name;                 
    const char *namespace_uri;        
    zxsd_type_t type;                 
    const zxsd_simple_t *simple_type; 
    const char *default_value;        
    const char *fixed_value;          
} zxsd_global_attribute_t;
 
typedef struct {
    const char *name;                        
    const char *namespace_uri;               
    zxsd_type_t type;                        
    const struct zxsd_complex *complex_type; 
    const zxsd_simple_t *simple_type;        
} zxsd_named_type_t;
 
typedef struct {
    const char *name;              
    const char *namespace_uri;     
    const char *public_identifier; 
    const char *system_identifier; 
} zxsd_notation_t;
 
typedef struct {
    const char *root_name;                            
    zxsd_type_t root_type;                            
    const zxsd_complex_t *root_complex;               
    const zxsd_simple_t *root_simple;                 
    const char *root_namespace_uri;                   
    const zxsd_identity_t *identities;                
    size_t identity_count;                            
    const zxsd_global_element_t *global_elements;     
    size_t global_element_count;                      
    const zxsd_global_attribute_t *global_attributes; 
    size_t global_attribute_count;                    
    const zxsd_named_type_t *named_types;             
    size_t named_type_count;                          
    const char *default_value;                        
    const char *fixed_value;                          
    int nillable;                     
    int abstract_element;             
    unsigned block_methods;           
    const zxsd_notation_t *notations; 
    size_t notation_count;            
} zxsd_schema_t;
 
typedef struct {
    const struct zxsd_particle *particle; 
    unsigned long count;                  
    size_t index;                         
    uint32_t references;                  
    uint16_t parent;                      
    uint16_t next;                        
    unsigned char phase;                  
    unsigned char started;                
} zxsd_stream_model_node_t;
 
typedef struct {
    const char *expected_name;          
    const char *expected_namespace;     
    zxsd_type_t type;                   
    const zxsd_complex_t *complex_type; 
    const zxsd_simple_t *simple_type;   
    const char *default_value;          
    const char *fixed_value;            
    unsigned char seen_attributes[ZXSD_MAX_ATTRIBUTES]; 
    unsigned long child_counts[ZXSD_MAX_PARTICLES];     
    size_t sequence_index;                              
    int incremental_model; 
    uint16_t model_states; 
    unsigned long
        model_occurrences; 
    const struct zxsd_particle *child_particle_table[ZXSD_MAX_PARTICLES];
    size_t child_particle_table_count; 
    uint16_t child_particle_ids[ZXSD_STREAM_CHILD_CAPACITY];
    size_t text_length;                         
    size_t child_count;                         
    int nillable;                               
    int nilled;                                 
    int content_started;                        
    int skip_validation;                        
    size_t namespace_base;                      
    char local_name[ZXSD_STREAM_NAME_CAPACITY]; 
    char namespace_uri[ZXSD_STREAM_NAME_CAPACITY]; 
    char text[ZXSD_STREAM_TEXT_CAPACITY + 1u];     
} zxsd_stream_frame_t;
 
typedef struct {
    char prefix[ZXSD_STREAM_NAME_CAPACITY]; 
    char uri[ZXSD_STREAM_NAME_CAPACITY];    
} zxsd_stream_namespace_t;
 
typedef struct {
    const zxsd_schema_t *schema;         
    zxsd_result_t result;                
    size_t depth;                        
    size_t event_offset;                 
    int finished;                        
    zxsd_allocator_t identity_allocator; 
    char *identity_xml;                  
    size_t identity_xml_length;          
    size_t identity_xml_capacity;        
    zxsd_stream_namespace_t namespaces[ZXSD_MAX_NAMESPACES]; 
    size_t namespace_count; 
#if ZXSD_STREAM_MODEL_CAPACITY > 0
    zxsd_stream_model_node_t model_nodes[ZXSD_STREAM_MODEL_CAPACITY];
    uint16_t model_free;        
    uint16_t model_high_water;  
    int model_pool_initialized; 
#endif
    zxsd_stream_frame_t frames[ZXSD_MAX_DEPTH]; 
} zxsd_stream_t;
 
typedef enum {
    ZXSD_XML_EVENT_START_ELEMENT, 
    ZXSD_XML_EVENT_ATTRIBUTE,     
    ZXSD_XML_EVENT_TEXT,          
    ZXSD_XML_EVENT_END_ELEMENT    
} zxsd_xml_event_t;
 
typedef void (*zxsd_xml_event_fn)(void *user_data, zxsd_xml_event_t event,
                  const char *namespace_uri, const char *local_name,
                  const char *value, size_t value_length);
 
typedef struct {
    zxsd_stream_t validator; 
    zxsd_result_t result;    
    size_t offset;           
    size_t token_offset;     
    size_t token_length;     
    unsigned char markup;    
    unsigned char quote;     
    zxsd_xml_event_fn event_callback;         
    void *event_user_data;                    
    char token[ZXSD_XML_TOKEN_CAPACITY + 1u]; 
    char decoded[ZXSD_MAX_TEXT_LENGTH + 1u];  
} zxsd_xml_reader_t;
 
#ifdef ZXSD_NO_HEAP
#define ZXSD_CONFIG_NO_HEAP 1u
#else
#define ZXSD_CONFIG_NO_HEAP 0u
#endif
typedef struct {
    unsigned int runtime_abi;    
    unsigned int descriptor_abi; 
    unsigned int no_heap;        
    size_t limits[22];           
    size_t layouts[12];          
} zxsd_runtime_config_t;
 
#define ZXSD_RUNTIME_CONFIG_INIT                                                                   \
    {                                                                                          \
        ZXSD_RUNTIME_ABI_VERSION, ZXSD_DESCRIPTOR_ABI_VERSION, ZXSD_CONFIG_NO_HEAP,        \
            {ZXSD_MAX_INPUT,                                                           \
             ZXSD_MAX_DEPTH,                                                           \
             ZXSD_MAX_PARTICLES,                                                       \
             ZXSD_MAX_ATTRIBUTES,                                                      \
             ZXSD_MAX_NAMESPACES,                                                      \
             ZXSD_MAX_IDENTITY_ROWS,                                                   \
             ZXSD_MAX_IDENTITY_VALUES,                                                 \
             ZXSD_MAX_IDENTITY_TEXT,                                                   \
             ZXSD_MAX_IDENTITY_CONSTRAINTS,                                            \
             ZXSD_MAX_IDENTITY_FIELDS,                                                 \
             ZXSD_MAX_XPATH_DEPTH,                                                     \
             ZXSD_MAX_XPATH_ALTERNATIVES,                                              \
             ZXSD_STREAM_TEXT_CAPACITY,                                                \
             ZXSD_MAX_TEXT_LENGTH,                                                     \
             ZXSD_MAX_PATTERN_LENGTH,                                                  \
             ZXSD_MAX_REGEX_NODES,                                                     \
             ZXSD_MAX_REGEX_DEPTH,                                                     \
             ZXSD_MAX_SCHEMA_COMPLEXITY,                                               \
             ZXSD_STREAM_NAME_CAPACITY,                                                \
             ZXSD_STREAM_CHILD_CAPACITY,                                               \
             ZXSD_STREAM_MODEL_CAPACITY,                                               \
             ZXSD_XML_TOKEN_CAPACITY},                                                 \
        {                                                                                  \
            sizeof(zxsd_stream_t), sizeof(zxsd_stream_frame_t),                        \
                sizeof(zxsd_xml_reader_t), sizeof(zxsd_schema_t),                  \
                sizeof(zxsd_particle_t), sizeof(zxsd_complex_t),                   \
                sizeof(zxsd_simple_t), sizeof(zxsd_result_t),                      \
                sizeof(zxsd_allocator_t), sizeof(void *), sizeof(size_t),          \
                sizeof(unsigned long)                                              \
        }                                                                                  \
    }
 
zxsd_result_t zxsd_check_runtime(const zxsd_runtime_config_t *expected);
 
zxsd_result_t zxsd_validate(const zxsd_schema_t *schema, const char *xml);
 
zxsd_result_t zxsd_validate_with_allocator(const zxsd_schema_t *schema, const char *xml,
                       const zxsd_allocator_t *allocator);
 
zxsd_result_t zxsd_stream_init(zxsd_stream_t *stream, const zxsd_schema_t *schema);
 
zxsd_result_t zxsd_stream_init_with_allocator(zxsd_stream_t *stream, const zxsd_schema_t *schema,
                          const zxsd_allocator_t *allocator);
 
void zxsd_stream_dispose(zxsd_stream_t *stream);
 
zxsd_result_t zxsd_start_element(zxsd_stream_t *stream, const char *namespace_uri,
                 const char *local_name);
 
zxsd_result_t zxsd_namespace(zxsd_stream_t *stream, const char *prefix, const char *namespace_uri);
 
zxsd_result_t zxsd_attribute(zxsd_stream_t *stream, const char *namespace_uri,
                 const char *local_name, const char *value);
 
zxsd_result_t zxsd_xsi_type(zxsd_stream_t *stream, const char *type_namespace_uri,
                const char *type_local_name);
 
zxsd_result_t zxsd_start_content(zxsd_stream_t *stream);
 
zxsd_result_t zxsd_text(zxsd_stream_t *stream, const char *text, size_t length);
 
zxsd_result_t zxsd_end_element(zxsd_stream_t *stream, const char *namespace_uri,
                   const char *local_name);
 
zxsd_result_t zxsd_stream_finish(zxsd_stream_t *stream);
 
zxsd_result_t zxsd_xml_reader_init(zxsd_xml_reader_t *reader, const zxsd_schema_t *schema);
 
zxsd_result_t zxsd_xml_reader_init_with_allocator(zxsd_xml_reader_t *reader,
                          const zxsd_schema_t *schema,
                          const zxsd_allocator_t *allocator);
 
void zxsd_xml_reader_set_event_callback(zxsd_xml_reader_t *reader, zxsd_xml_event_fn callback,
                    void *user_data);
 
zxsd_result_t zxsd_xml_reader_feed(zxsd_xml_reader_t *reader, const void *data, size_t length);
 
zxsd_result_t zxsd_xml_reader_finish(zxsd_xml_reader_t *reader);
 
void zxsd_xml_reader_dispose(zxsd_xml_reader_t *reader);
 
const char *zxsd_error_string(zxsd_error_t error);
 
#ifdef __cplusplus
}
#endif
#endif