include/procTypes.h

Go to the documentation of this file.

/*==================================================================*\
|                EXIP - Embeddable EXI Processor in C                |
|--------------------------------------------------------------------|
|          This work is licensed under BSD 3-Clause License          |
|  The full license terms and conditions are located in LICENSE.txt  |
\===================================================================*/

#ifndef PROCTYPES_H_
#define PROCTYPES_H_

#include "errorHandle.h"
#include <stdint.h>
#include <time.h>
#include <string.h>
#include "exipConfig.h"
#include <limits.h>

enum boolean
{
    FALSE = 0,
    TRUE  = 1
};

typedef enum boolean boolean;

#ifndef NULL
#define NULL ((void *)0)
#endif

struct stackNode
{
    void* item;
    struct stackNode* nextInStack;
};

typedef struct stackNode GenericStack;

#define REVERSE_BIT_POSITION(p) (7 - p)

#define BIT_PACKED      0x00 // 0b00000000
#define BYTE_ALIGNMENT  0x40 // 0b01000000
#define PRE_COMPRESSION 0x80 // 0b10000000
#define ALIGNMENT       0xc0 // 0b11000000

#define COMPRESSION     0x01 // 0b00000001
#define STRICT          0x02 // 0b00000010
#define FRAGMENT        0x04 // 0b00000100
#define SELF_CONTAINED  0x08 // 0b00001000

#define GET_ALIGNMENT(p)       ((p) & ALIGNMENT)
#define WITH_COMPRESSION(p)    (((p) & COMPRESSION) != 0)
#define WITH_STRICT(p)         (((p) & STRICT) != 0)
#define WITH_FRAGMENT(p)       (((p) & FRAGMENT) != 0)
#define WITH_SELF_CONTAINED(p) (((p) & SELF_CONTAINED) != 0)

#define SET_ALIGNMENT(p, align_const) ((p) = (p) | align_const)
#define SET_COMPRESSION(p)            ((p) = (p) | COMPRESSION)
#define SET_STRICT(p)                 ((p) = (p) | STRICT)
#define SET_FRAGMENT(p)               ((p) = (p) | FRAGMENT)
#define SET_SELF_CONTAINED(p)         ((p) = (p) | SELF_CONTAINED)

enum SchemaIdMode
{
    SCHEMA_ID_ABSENT = 0,
    SCHEMA_ID_SET    = 1,
    SCHEMA_ID_NIL    = 2,
    SCHEMA_ID_EMPTY  = 3
};

typedef enum SchemaIdMode SchemaIdMode;

#define PRESERVE_COMMENTS  0x01 // 0b00000001
#define PRESERVE_PIS       0x02 // 0b00000010
#define PRESERVE_DTD       0x04 // 0b00000100
#define PRESERVE_PREFIXES  0x08 // 0b00001000
#define PRESERVE_LEXVALUES 0x10 // 0b00010000

#define IS_PRESERVED(p, mask) (((p) & (mask)) != 0)
#define SET_PRESERVED(p, preserve_const) ((p) = (p) | (preserve_const))

struct fractionalSecs
{
    unsigned char offset;
    unsigned int value;
};

typedef struct fractionalSecs FractionalSecs;

struct EXIPDateTime
{
    struct tm dateTime;
    FractionalSecs fSecs;
    int16_t TimeZone;

    uint8_t presenceMask;
};

typedef struct EXIPDateTime EXIPDateTime;

#define TZONE_PRESENCE     0x01 // 0b00000001
#define FRACT_PRESENCE     0x02 // 0b00000010

#define IS_PRESENT(p, mask) (((p) & (mask)) != 0)

#ifndef EXIP_UNSIGNED_INTEGER
# define EXIP_UNSIGNED_INTEGER uint64_t
#endif

typedef EXIP_UNSIGNED_INTEGER UnsignedInteger;

#ifndef EXIP_INTEGER
# define EXIP_INTEGER int64_t
#endif

typedef EXIP_INTEGER Integer;

struct EXIFloat
{
    int64_t mantissa;
    int16_t exponent;
};

#ifndef EXIP_FLOAT
# define EXIP_FLOAT struct EXIFloat
#endif

typedef EXIP_FLOAT Float;

#ifndef EXIP_DECIMAL
# define EXIP_DECIMAL Float
#endif

typedef EXIP_DECIMAL Decimal;

#ifndef EXIP_INDEX
# define EXIP_INDEX size_t
#endif

typedef EXIP_INDEX Index;

#ifndef EXIP_INDEX_MAX
# define EXIP_INDEX_MAX SIZE_MAX
#endif

#define INDEX_MAX EXIP_INDEX_MAX

#ifndef EXIP_SMALL_INDEX
# define EXIP_SMALL_INDEX size_t
#endif

typedef EXIP_SMALL_INDEX SmallIndex;

#ifndef EXIP_SMALL_INDEX_MAX
# define EXIP_SMALL_INDEX_MAX SIZE_MAX
#endif

#define SMALL_INDEX_MAX EXIP_SMALL_INDEX_MAX

#ifndef EXIP_IMPLICIT_DATA_TYPE_CONVERSION
# define EXIP_IMPLICIT_DATA_TYPE_CONVERSION ON
#endif

#ifndef CHAR_TYPE
# define CHAR_TYPE char
#endif

typedef CHAR_TYPE CharType;


#ifndef EXIP_STRTOLL

# define EXIP_STRTOLL strtoll
#endif

struct StringType
{
    CharType* str;
    Index length;
};

typedef struct StringType String;

struct QName {
    const String* uri;
    const String* localName;
    const String* prefix;
};

typedef struct QName QName;

#define URI_MAX SMALL_INDEX_MAX
#define LN_MAX INDEX_MAX

struct QNameID {
    SmallIndex uriId;   // VOID == URI_MAX
    Index lnId; // VOID == LN_MAX
};

typedef struct QNameID QNameID;

#define ALLOCATION_ARRAY_SIZE 100

struct allocBlock {
    void* allocation[ALLOCATION_ARRAY_SIZE];
    struct allocBlock* nextBlock;
};

struct allocList {
    struct allocBlock* firstBlock;
    struct allocBlock* lastBlock;
    SmallIndex currAllocSlot;
};

typedef struct allocList AllocList;

struct dynArray {
    size_t entrySize;

    Index chunkEntries;

    Index arrayEntries;
};

typedef struct dynArray DynArray;
 //End Memory management definitions


enum EventType
{
    EVENT_SD       =   0,
    EVENT_ED       =  10,
    EVENT_AT_QNAME =  20,
    EVENT_AT_URI   =  21,
    EVENT_AT_ALL   =  22,
    EVENT_SE_QNAME =  30,
    EVENT_SE_URI   =  31,
    EVENT_SE_ALL   =  32,
    EVENT_EE       =  40,
    EVENT_CH       =  50,
    EVENT_NS       =  60,
    EVENT_CM       =  70,
    EVENT_PI       =  80,
    EVENT_DT       =  90,
    EVENT_ER       = 100,
    EVENT_SC       = 110,
    EVENT_VOID     = 255
};

typedef enum EventType EventType;

enum EventTypeClass
{
    EVENT_SD_CLASS   =  0,
    EVENT_ED_CLASS   =  1,
    EVENT_AT_CLASS   =  2,
    EVENT_SE_CLASS   =  3,
    EVENT_EE_CLASS   =  4,
    EVENT_CH_CLASS   =  5,
    EVENT_NS_CLASS   =  6,
    EVENT_CM_CLASS   =  7,
    EVENT_PI_CLASS   =  8,
    EVENT_DT_CLASS   =  9,
    EVENT_ER_CLASS   = 10,
    EVENT_SC_CLASS   = 11,
    EVENT_VOID_CLASS = 25
};

typedef enum EventTypeClass EventTypeClass;

#define GET_EVENT_CLASS(evnt) (evnt/10)

enum EXIType
{
    VALUE_TYPE_NONE             =   0,
    VALUE_TYPE_STRING           =  10,
    VALUE_TYPE_FLOAT            =  20,
    VALUE_TYPE_DECIMAL          =  30,
    VALUE_TYPE_DATE_TIME        =  40,
    VALUE_TYPE_YEAR             =  41,
    VALUE_TYPE_DATE             =  42,
    VALUE_TYPE_MONTH            =  43,
    VALUE_TYPE_TIME             =  44,
    VALUE_TYPE_BOOLEAN          =  50,
    VALUE_TYPE_BINARY           =  60,
    VALUE_TYPE_LIST             =  70,
    VALUE_TYPE_QNAME            =  80,
    VALUE_TYPE_INTEGER          =  90,
    VALUE_TYPE_SMALL_INTEGER    =  91,
    VALUE_TYPE_NON_NEGATIVE_INT =  92,
    VALUE_TYPE_UNTYPED          = 255
};

typedef enum EXIType EXIType;

enum EXITypeClass
{
    VALUE_TYPE_NONE_CLASS              =   0,
    VALUE_TYPE_STRING_CLASS            =   1,
    VALUE_TYPE_FLOAT_CLASS             =   2,
    VALUE_TYPE_DECIMAL_CLASS           =   3,
    VALUE_TYPE_DATE_TIME_CLASS         =   4,
    VALUE_TYPE_BOOLEAN_CLASS           =   5,
    VALUE_TYPE_BINARY_CLASS            =   6,
    VALUE_TYPE_LIST_CLASS              =   7,
    VALUE_TYPE_QNAME_CLASS             =   8,
    VALUE_TYPE_INTEGER_CLASS           =   9,
    VALUE_TYPE_UNTYPED_CLASS           =  25
};

typedef enum EXITypeClass EXITypeClass;

#define GET_VALUE_TYPE_CLASS(value_type) (value_type/10)

#define PROD_CONTENT_MASK 0xFFFFFF // 0b00000000111111111111111111111111

#define GET_PROD_EXI_EVENT(content) (content>>24)
#define GET_PROD_EXI_EVENT_CLASS(content) GET_EVENT_CLASS((content>>24))
#define SET_PROD_EXI_EVENT(content, eventType) (content = (content & PROD_CONTENT_MASK) | (((uint32_t) eventType)<<24))
#define GET_PROD_NON_TERM(content) (content & PROD_CONTENT_MASK)
#define SET_PROD_NON_TERM(content, nt) (content = (content & ~PROD_CONTENT_MASK) | (nt & PROD_CONTENT_MASK))

struct Production
{
    uint32_t content;

    Index typeId;
    
    QNameID qnameId;
};

typedef struct Production Production;

struct EventCode
{
    Index part[3];
    Index bits[3];
    unsigned char length;
};

typedef struct EventCode EventCode;

#ifndef GR_VOID_NON_TERMINAL
# define GR_VOID_NON_TERMINAL SMALL_INDEX_MAX
#endif

#define GR_DOC_CONTENT       0
#define GR_DOC_END           1

#define GR_START_TAG_CONTENT 0
#define GR_ELEMENT_CONTENT   1
#define GR_CONTENT_2 (GR_VOID_NON_TERMINAL-1)

#define GR_FRAGMENT_CONTENT  0

struct GrammarRule
{
    Production* production;

    Index pCount;

    uint16_t meta;
};

typedef struct GrammarRule GrammarRule;

#define RULE_CONTAIN_EE_OR_XSI_TYPE_MASK       0x01 // 0b0000000000000001

#define RULE_CONTAIN_EE(meta) ((meta & RULE_CONTAIN_EE_OR_XSI_TYPE_MASK) != 0)
#define RULE_SET_CONTAIN_EE(meta) (meta = meta | RULE_CONTAIN_EE_OR_XSI_TYPE_MASK)
#define RULE_CONTAIN_XSI_TYPE(meta) ((meta & RULE_CONTAIN_EE_OR_XSI_TYPE_MASK) != 0)
#define RULE_SET_CONTAIN_XSI_TYPE(meta) (meta = meta | RULE_CONTAIN_EE_OR_XSI_TYPE_MASK)

#define RULE_SET_AT_COUNT(meta, ac) (meta = meta | (ac<<1))
#define RULE_GET_AT_COUNT(meta) (meta>>1)

#if BUILD_IN_GRAMMARS_USE

    struct DynGrammarRule
    {
        Production* production;

        Index pCount;

        uint16_t meta;

       Index prodDim; // The size of the productions Dynamic production array /allocated space for Productions in it/
    };
    typedef struct DynGrammarRule DynGrammarRule;
#endif

#define IS_NILLABLE(p)                  ((p & GR_PROP_NILLABLE) != 0)
#define IS_BUILT_IN_ELEM(p)             ((p & GR_PROP_BUILT_IN_ELEMENT) != 0)
#define IS_SCHEMA(p)                    ((p & GR_PROP_SCHEMA_INFORMED) != 0)
#define IS_DOCUMENT(p)                  ((p & GR_PROP_DOCUMENT) != 0)
#define IS_FRAGMENT(p)                  ((p & GR_PROP_FRAGMENT) != 0)
#define HAS_NAMED_SUB_TYPE_OR_UNION(p)  ((p & GR_PROP_NAMED_SUB_TYPE_OR_UNION) != 0)
#define HAS_CONTENT2(p)                 ((p & GR_PROP_HAS_CONTENT2) != 0)

#define SET_NILLABLE_GR(p)                  ((p) = (p) | GR_PROP_NILLABLE)
#define SET_BUILT_IN_ELEM_GR(p)             ((p) = (p) | GR_PROP_BUILT_IN_ELEMENT)
#define SET_SCHEMA_GR(p)                    ((p) = (p) | GR_PROP_SCHEMA_INFORMED)
#define SET_DOCUMENT_GR(p)                  ((p) = (p) | GR_PROP_DOCUMENT)
#define SET_FRAGMENT_GR(p)                  ((p) = (p) | GR_PROP_FRAGMENT)
#define SET_NAMED_SUB_TYPE_OR_UNION(p)      ((p) = (p) | GR_PROP_NAMED_SUB_TYPE_OR_UNION)
#define SET_HAS_CONTENT2(p)                 ((p) = (p) | GR_PROP_HAS_CONTENT2)

#define GR_PROP_BUILT_IN_ELEMENT         0x1000000 // 0b00000001000000000000000000000000
#define GR_PROP_SCHEMA_INFORMED          0x2000000 // 0b00000010000000000000000000000000
#define GR_PROP_DOCUMENT                 0x4000000 // 0b00000100000000000000000000000000
#define GR_PROP_FRAGMENT                 0x8000000 // 0b00001000000000000000000000000000
#define GR_PROP_NILLABLE                0x10000000 // 0b00010000000000000000000000000000
#define GR_PROP_NAMED_SUB_TYPE_OR_UNION 0x20000000 // 0b00100000000000000000000000000000
/* There is a content2 rule if there are AT productions
 * that point to the content grammar rule OR the content index is 0. */
#define GR_PROP_HAS_CONTENT2            0x40000000 // 0b01000000000000000000000000000000

#define GR_CONTENT_INDEX_MASK 0xFFFFFF // 0b00000000111111111111111111111111

#define SET_CONTENT_INDEX(props, indx) (props = (props & ~GR_CONTENT_INDEX_MASK) | (indx & GR_CONTENT_INDEX_MASK))
#define GET_CONTENT_INDEX(props) (props & GR_CONTENT_INDEX_MASK)

struct EXIGrammar
{
    GrammarRule* rule;

    uint32_t props;

    SmallIndex count;
};

typedef struct EXIGrammar EXIGrammar;

struct GrammarStackNode
{
    EXIGrammar* grammar;

    SmallIndex currNonTermID;
    QNameID currQNameID;
    struct GrammarStackNode* nextInStack;
};

typedef struct GrammarStackNode EXIGrammarStack;
 // End Grammar Types


struct ValueEntry {
#if VALUE_CROSSTABLE_USE
    struct
    {
        QNameID forQNameId;
        Index vxEntryId;
    } locValuePartition; // A reference to the VxEntry for that global value
#endif
    String valueStr;
};

typedef struct ValueEntry ValueEntry;

struct ValueTable {
#if DYN_ARRAY_USE == ON
    DynArray dynArray;
#endif
    ValueEntry* value;
    Index count;
#if HASH_TABLE_USE

    struct hashtable* hashTbl;
#endif

    Index globalId;
};

typedef struct ValueTable ValueTable;

#if VALUE_CROSSTABLE_USE
    struct VxEntry {
        Index globalId;
    };

    typedef struct VxEntry VxEntry;

    struct VxTable {
    #if DYN_ARRAY_USE == ON
        DynArray dynArray;
    #endif
        VxEntry* vx;
        Index count;
    };

    typedef struct VxTable VxTable;
#endif

struct PfxTable {
#if DYN_ARRAY_USE == ON
    DynArray dynArray;
#endif
    String* pfx;
    Index count;
};

typedef struct PfxTable PfxTable;

struct LnEntry {
#if VALUE_CROSSTABLE_USE
    VxTable* vxTable;
#endif
    String lnStr;
    Index elemGrammar;
    Index typeGrammar;
};

typedef struct LnEntry LnEntry;

struct LnTable {
#if DYN_ARRAY_USE == ON
    DynArray dynArray;
#endif
    LnEntry* ln;
    Index count;
};

typedef struct LnTable LnTable;

struct UriEntry {
    LnTable lnTable;
    PfxTable pfxTable;
    String uriStr;
};

typedef struct UriEntry UriEntry;

struct UriTable {
#if DYN_ARRAY_USE == ON
    DynArray dynArray;
#endif
    UriEntry* uri;
    SmallIndex count;
};

typedef struct UriTable UriTable;
 // End String Table Types

#define TYPE_FACET_LENGTH               0x0001 // 0b0000000000000001
#define TYPE_FACET_MIN_LENGTH           0x0002 // 0b0000000000000010
#define TYPE_FACET_MAX_LENGTH           0x0004 // 0b0000000000000100
#define TYPE_FACET_PATTERN              0x0008 // 0b0000000000001000
#define TYPE_FACET_ENUMERATION          0x0010 // 0b0000000000010000
#define TYPE_FACET_WHITE_SPACE          0x0020 // 0b0000000000100000
#define TYPE_FACET_MAX_INCLUSIVE        0x0040 // 0b0000000001000000
#define TYPE_FACET_MAX_EXCLUSIVE        0x0080 // 0b0000000010000000
#define TYPE_FACET_MIN_EXCLUSIVE        0x0100 // 0b0000000100000000
#define TYPE_FACET_MIN_INCLUSIVE        0x0200 // 0b0000001000000000
#define TYPE_FACET_TOTAL_DIGITS         0x0400 // 0b0000010000000000
#define TYPE_FACET_FRACTION_DIGITS      0x0800 // 0b0000100000000000
#define TYPE_FACET_NAMED_SUBTYPE_UNION  0x1000 // 0b0001000000000000

#define ST_CONTENT_MASK 0xFFFFFF // 0b00000000111111111111111111111111

#define GET_EXI_TYPE(content) (content>>24)
#define SET_EXI_TYPE(content, et) (content = (content & ST_CONTENT_MASK) | (((uint32_t) et)<<24))
#define HAS_TYPE_FACET(content, facet) ((content & facet) != 0)
#define SET_TYPE_FACET(content, facet) (content = (content | facet))
#define REMOVE_TYPE_FACET(content, facet) (content = (content & ~facet))

struct SimpleType {
    uint32_t content;
    uint32_t length;

    int64_t max;
    int64_t min;
};

typedef struct SimpleType SimpleType;

struct SimpleTypeTable {
#if DYN_ARRAY_USE == ON
    DynArray dynArray;
#endif
    SimpleType* sType;
    Index count;
};

typedef struct SimpleTypeTable SimpleTypeTable;

#define SIMPLE_TYPE_ENTITIES              0
#define SIMPLE_TYPE_ENTITY                1
#define SIMPLE_TYPE_ID                    2
#define SIMPLE_TYPE_IDREF                 3
#define SIMPLE_TYPE_IDREFS                4
#define SIMPLE_TYPE_NCNAME                5
#define SIMPLE_TYPE_NMTOKEN               6
#define SIMPLE_TYPE_NMTOKENS              7
#define SIMPLE_TYPE_NOTATION              8
#define SIMPLE_TYPE_NAME                  9
#define SIMPLE_TYPE_QNAME                10
#define SIMPLE_TYPE_ANY_SIMPLE_TYPE      11
#define SIMPLE_TYPE_ANY_TYPE             12
#define SIMPLE_TYPE_ANY_URI              13
#define SIMPLE_TYPE_BASE64_BINARY        14
#define SIMPLE_TYPE_BOOLEAN              15
#define SIMPLE_TYPE_BYTE                 16
#define SIMPLE_TYPE_DATE                 17
#define SIMPLE_TYPE_DATE_TIME            18
#define SIMPLE_TYPE_DECIMAL              19
#define SIMPLE_TYPE_DOUBLE               20
#define SIMPLE_TYPE_DURATION             21
#define SIMPLE_TYPE_FLOAT                22
#define SIMPLE_TYPE_GDAY                 23
#define SIMPLE_TYPE_GMONTH               24
#define SIMPLE_TYPE_GMONTH_DAY           25
#define SIMPLE_TYPE_GYEAR                26
#define SIMPLE_TYPE_GYEAR_MONTH          27
#define SIMPLE_TYPE_HEX_BINARY           28
#define SIMPLE_TYPE_INT                  29
#define SIMPLE_TYPE_INTEGER              30
#define SIMPLE_TYPE_LANGUAGE             31
#define SIMPLE_TYPE_LONG                 32
#define SIMPLE_TYPE_NEGATIVE_INTEGER     33
#define SIMPLE_TYPE_NON_NEGATIVE_INTEGER 34
#define SIMPLE_TYPE_NON_POSITIVE_INTEGER 35
#define SIMPLE_TYPE_NORMALIZED_STRING    36
#define SIMPLE_TYPE_POSITIVE_INTEGER     37
#define SIMPLE_TYPE_SHORT                38
#define SIMPLE_TYPE_STRING               39
#define SIMPLE_TYPE_TIME                 40
#define SIMPLE_TYPE_TOKEN                41
#define SIMPLE_TYPE_UNSIGNED_BYTE        42
#define SIMPLE_TYPE_UNSIGNED_INT         43
#define SIMPLE_TYPE_UNSIGNED_LONG        44
#define SIMPLE_TYPE_UNSIGNED_SHORT       45

#define SIMPLE_TYPE_COUNT                46

#define XML_NAMESPACE_ID                  1

#define XML_SCHEMA_INSTANCE_ID            2
#define XML_SCHEMA_INSTANCE_NIL_ID        0
#define XML_SCHEMA_INSTANCE_TYPE_ID       1

#define XML_SCHEMA_NAMESPACE_ID           3

struct SchemaGrammarTable {
#if DYN_ARRAY_USE == ON
    DynArray dynArray;
#endif
    EXIGrammar* grammar;
    Index count;
};

typedef struct SchemaGrammarTable SchemaGrammarTable;

#if EXI_PROFILE_DEFAULT
// The index of the EXI Profile stub grammar
#  define EXI_PROFILE_STUB_GRAMMAR_INDX (INDEX_MAX-1)
#endif

struct enumDefinition
{
    Index typeId;
    void *values;
    SmallIndex count;
};

typedef struct enumDefinition EnumDefinition;

struct EnumTable {
#if DYN_ARRAY_USE == ON
    DynArray dynArray;
#endif
    EnumDefinition* enumDef;
    Index count;
};

typedef struct EnumTable EnumTable;

struct EXIPSchema
{
    AllocList memList;

    UriTable uriTable;

    EXIGrammar docGrammar;

    SimpleTypeTable simpleTypeTable;

    SchemaGrammarTable grammarTable;

    Index staticGrCount;

    EnumTable enumTable;
};

typedef struct EXIPSchema EXIPSchema;

struct StreamContext
{
    Index bufferIndx;

    unsigned char bitPointer;

    QNameID currAttr;

    unsigned int expectATData;

    boolean isNilType;

    Index attrTypeId;
};

typedef struct StreamContext StreamContext;

struct ioStream
{
    size_t (*readWriteToStream)(void* buf, size_t size, void* stream);
    void* stream;
};

typedef struct ioStream IOStream;

struct DatatypeRepresentationMap
{
    void* TODO; //TODO: fill in the information for this structure
};

typedef struct DatatypeRepresentationMap DatatypeRepresentationMap;

struct EXIOptions
{
    unsigned char enumOpt;

    unsigned char preserve;

    SchemaIdMode schemaIDMode;

    String schemaID;

    DatatypeRepresentationMap* drMap;

    uint32_t blockSize;

    Index valueMaxLength;

    Index valuePartitionCapacity;

    void* user_defined_data;
};

typedef struct EXIOptions EXIOptions;

struct EXIheader
{
    boolean has_cookie;

    boolean has_options;

    boolean is_preview_version;

    int16_t version_number;

    EXIOptions opts;
};

typedef struct EXIheader EXIheader;

struct BinaryBuffer
{
    char* buf;

    Index bufLen;

    Index bufContent;

    IOStream ioStrm;
};

typedef struct BinaryBuffer BinaryBuffer;

struct EXIStream
{
    BinaryBuffer buffer;

    EXIheader header;

    StreamContext context;

    ValueTable valueTable;

    EXIGrammarStack* gStack;

    AllocList memList;

    EXIPSchema* schema;
};

typedef struct EXIStream EXIStream;


/**********************Function definitions************************/

void makeDefaultOpts(EXIOptions* opts);

errorCode checkOptionValues(EXIOptions* opts);

errorCode pushOnStack(GenericStack** stack, void* item);

void popFromStack(GenericStack** stack, void** item);

int compareEnumDefs(const void* enum1, const void* enum2);

#endif /* PROCTYPES_H_ */