utdatabase.h

DataDraw is an ultra-fast persistent database for high performance programs written in C. It s so fa

/*----------------------------------------------------------------------------------------
  Module header file for: ut module
----------------------------------------------------------------------------------------*/
#ifndef UTDATABASE_H

#define UTDATABASE_H

#if defined __cplusplus
extern "C" {
#endif

#ifndef DD_UTIL_H
#include "ddutil.h"
#endif

/* Class reference definitions */

#if defined(DD_DEBUG)
typedef struct _struct_utSymtab{char val;} *utSymtab;
#define utSymtabNull ((utSymtab)(UINT32_MAX))
#define utSymtab2Index(Symtab) ((uint32)((Symtab) - (utSymtab)(0)))
#define utSymtab2ValidIndex(Symtab) ((uint32)(utValidSymtab(Symtab) - (utSymtab)(0)))
#define utIndex2Symtab(xSymtab) ((utSymtab)((xSymtab) + (utSymtab)(0)))
typedef struct _struct_utSym{char val;} *utSym;
#define utSymNull ((utSym)(UINT32_MAX))
#define utSym2Index(Sym) ((uint32)((Sym) - (utSym)(0)))
#define utSym2ValidIndex(Sym) ((uint32)(utValidSym(Sym) - (utSym)(0)))
#define utIndex2Sym(xSym) ((utSym)((xSym) + (utSym)(0)))
typedef struct _struct_utDynarray{char val;} *utDynarray;
#define utDynarrayNull ((utDynarray)(UINT32_MAX))
#define utDynarray2Index(Dynarray) ((uint32)((Dynarray) - (utDynarray)(0)))
#define utDynarray2ValidIndex(Dynarray) ((uint32)(utValidDynarray(Dynarray) - (utDynarray)(0)))
#define utIndex2Dynarray(xDynarray) ((utDynarray)((xDynarray) + (utDynarray)(0)))
typedef struct _struct_utSymArray{char val;} *utSymArray;
#define utSymArrayNull ((utSymArray)(UINT32_MAX))
#define utSymArray2Index(SymArray) ((uint32)((SymArray) - (utSymArray)(0)))
#define utSymArray2ValidIndex(SymArray) ((uint32)(utValidSymArray(SymArray) - (utSymArray)(0)))
#define utIndex2SymArray(xSymArray) ((utSymArray)((xSymArray) + (utSymArray)(0)))
#else
typedef uint32 utSymtab;
#define utSymtabNull UINT32_MAX
#define utSymtab2Index(Symtab) (Symtab)
#define utSymtab2ValidIndex(Symtab) (utValidSymtab(Symtab))
#define utIndex2Symtab(xSymtab) ((xSymtab))
typedef uint32 utSym;
#define utSymNull UINT32_MAX
#define utSym2Index(Sym) (Sym)
#define utSym2ValidIndex(Sym) (utValidSym(Sym))
#define utIndex2Sym(xSym) ((xSym))
typedef uint32 utDynarray;
#define utDynarrayNull UINT32_MAX
#define utDynarray2Index(Dynarray) (Dynarray)
#define utDynarray2ValidIndex(Dynarray) (utValidDynarray(Dynarray))
#define utIndex2Dynarray(xDynarray) ((xDynarray))
typedef uint32 utSymArray;
#define utSymArrayNull UINT32_MAX
#define utSymArray2Index(SymArray) (SymArray)
#define utSymArray2ValidIndex(SymArray) (utValidSymArray(SymArray))
#define utIndex2SymArray(xSymArray) ((xSymArray))
#endif

/* Validate macros */
#if defined(DD_DEBUG)
#define utValidSymtab(Symtab) (utLikely((uint32)((Symtab) - (utSymtab)0) < \
    utRootData.usedSymtab)? (Symtab) : (utExit("Invalid Symtab"), (utSymtab)0))
#define utValidSym(Sym) (utLikely((uint32)((Sym) - (utSym)0) < \
    utRootData.usedSym)? (Sym) : (utExit("Invalid Sym"), (utSym)0))
#define utValidDynarray(Dynarray) (utLikely((uint32)((Dynarray) - (utDynarray)0) < \
    utRootData.usedDynarray)? (Dynarray) : (utExit("Invalid Dynarray"), (utDynarray)0))
#define utValidSymArray(SymArray) (utLikely((uint32)((SymArray) - (utSymArray)0) < \
    utRootData.usedSymArray)? (SymArray) : (utExit("Invalid SymArray"), (utSymArray)0))
#else
#define utValidSymtab(Symtab) (Symtab)
#define utValidSym(Sym) (Sym)
#define utValidDynarray(Dynarray) (Dynarray)
#define utValidSymArray(SymArray) (SymArray)
#endif

/*----------------------------------------------------------------------------------------
  Fields for class Symtab.
----------------------------------------------------------------------------------------*/
struct utSymtabFields {
    uint32 *TableIndex;
    uint32 *NumTable;
    utSym *Table;
    uint32 *NumSym;
};
extern struct utSymtabFields utSymtabs;

#define utSymtabGetTableIndex(_Symtab) (utSymtabs.TableIndex[utSymtab2ValidIndex(_Symtab)])
#define utSymtabSetTableIndex(_Symtab, value) ((utSymtabs.TableIndex)[utSymtab2ValidIndex(_Symtab)] = (value))
#define utSymtabGetNumTable(_Symtab) (utSymtabs.NumTable[utSymtab2ValidIndex(_Symtab)])
#define utSymtabSetNumTable(_Symtab, value) ((utSymtabs.NumTable)[utSymtab2ValidIndex(_Symtab)] = (value))
#if defined(DD_DEBUG)
#define utSymtabCheckTableIndex(Symtab, x) ((uint32)(x) < utSymtabGetNumTable(Symtab)? (x) : \
    (utAssert(false),(x)))
#else
#define utSymtabCheckTableIndex(Symtab, x) (x)
#endif
#define utSymtabGetiTable(_Symtab, x) ((utSymtabs.Table)[ \
    utSymtabGetTableIndex(_Symtab) + utSymtabCheckTableIndex(_Symtab, (x))])
#define utSymtabGetTables(Symtab) (utSymtabs.Table + utSymtabGetTableIndex(Symtab))
#define utSymtabSetTable(Symtab, valuePtr) (memcpy(utSymtabGetTables(Symtab), valuePtr, \
    utSymtabGetNumTable(Symtab)*sizeof(utSym)))
#define utSymtabSetiTable(Symtab, x, value) ((utSymtabs.Table)[ \
    utSymtabGetTableIndex(Symtab) + utSymtabCheckTableIndex(Symtab, (x))] = (value))
#define utSymtabGetNumSym(_Symtab) (utSymtabs.NumSym[utSymtab2ValidIndex(_Symtab)])
#define utSymtabSetNumSym(_Symtab, value) ((utSymtabs.NumSym)[utSymtab2ValidIndex(_Symtab)] = (value))
#define utSymtabSetConstructorCallback(func) (utSymtabConstructorCallback = (func))
#define utSymtabGetConstructorCallback() (utSymtabConstructorCallback)
#define utFirstSymtab() (utRootData.usedSymtab == 0? utSymtabNull : utIndex2Symtab(0))
#define utLastSymtab() (utRootData.usedSymtab == 0? utSymtabNull : \
    utIndex2Symtab(utRootData.usedSymtab - 1))
#define utNextSymtab(Symtab) (utSymtab2ValidIndex(Symtab) + 1 == utRootData.usedSymtab? utSymtabNull : \
    (Symtab) + 1)
#define utPrevSymtab(Symtab) (utSymtab2ValidIndex(Symtab) == 0? utSymtabNull : (Symtab) - 1)
#define utForeachSymtab(var) \
    for(var = utIndex2Symtab(0); utSymtab2Index(var) != utRootData.usedSymtab; var++)
#define utEndForeachSymtab
#define utSymtabFreeAll() (utSetUsedSymtab(0), utSetUsedSymtabTable(0))
#define utSymtabAllocRaw() ( \
    utRootData.usedSymtab == utRootData.allocatedSymtab && (utSymtabAllocMore(), true), \
    utTemp_.Symtab = utIndex2Symtab(utRootData.usedSymtab), \
    utSetUsedSymtab(utUsedSymtab() + 1), \
    utTemp_.Symtab)
#define utSymtabAlloc() ( \
    utRootData.usedSymtab == utRootData.allocatedSymtab && (utSymtabAllocMore(), true), \
    utTemp_.Symtab = utIndex2Symtab(utRootData.usedSymtab), \
    utSetUsedSymtab(utUsedSymtab() + 1), \
    utSymtabSetTableIndex(utTemp_.Symtab, 0), \
    utSymtabSetNumTable(utTemp_.Symtab, 0), \
    utSymtabSetNumTable(utTemp_.Symtab, 0), \
    utSymtabSetNumSym(utTemp_.Symtab, 0), \
    utSymtabConstructorCallback != NULL && (utSymtabConstructorCallback(utTemp_.Symtab), true), \
    utTemp_.Symtab)

void utSymtabAllocMore(void);
void utSymtabAllocTables(utSymtab Symtab, uint32 numTables);
void utSymtabResizeTables(utSymtab Symtab, uint32 numTables);
void utSymtabFreeTables(utSymtab Symtab);
void utCompactSymtabTables(void);

/*----------------------------------------------------------------------------------------
  Fields for class Sym.
----------------------------------------------------------------------------------------*/
struct utSymFields {
    uint32 *NameIndex;
    uint32 *NumName;
    char *Name;
    uint32 *HashValue;
    utSym *Next;
    uint32 *SymArrayIndex;
};
extern struct utSymFields utSyms;

#define utSymGetNameIndex(_Sym) (utSyms.NameIndex[utSym2ValidIndex(_Sym)])
#define utSymSetNameIndex(_Sym, value) ((utSyms.NameIndex)[utSym2ValidIndex(_Sym)] = (value))
#define utSymGetNumName(_Sym) (utSyms.NumName[utSym2ValidIndex(_Sym)])
#define utSymSetNumName(_Sym, value) ((utSyms.NumName)[utSym2ValidIndex(_Sym)] = (value))
#if defined(DD_DEBUG)
#define utSymCheckNameIndex(Sym, x) ((uint32)(x) < utSymGetNumName(Sym)? (x) : \
    (utAssert(false),(x)))
#else
#define utSymCheckNameIndex(Sym, x) (x)
#endif
#define utSymGetiName(_Sym, x) ((utSyms.Name)[ \
    utSymGetNameIndex(_Sym) + utSymCheckNameIndex(_Sym, (x))])
#define utSymGetNames(Sym) (utSyms.Name + utSymGetNameIndex(Sym))
#define utSymSetName(Sym, valuePtr) (memcpy(utSymGetNames(Sym), valuePtr, \
    utSymGetNumName(Sym)*sizeof(char)))
#define utSymSetiName(Sym, x, value) ((utSyms.Name)[ \
    utSymGetNameIndex(Sym) + utSymCheckNameIndex(Sym, (x))] = (value))
#define utSymGetName(Sym) (utSyms.Name + utSymGetNameIndex(Sym))
#define utSymGetHashValue(_Sym) (utSyms.HashValue[utSym2ValidIndex(_Sym)])
#define utSymSetHashValue(_Sym, value) ((utSyms.HashValue)[utSym2ValidIndex(_Sym)] = (value))
#define utSymGetNext(_Sym) (utSyms.Next[utSym2ValidIndex(_Sym)])
#define utSymSetNext(_Sym, value) ((utSyms.Next)[utSym2ValidIndex(_Sym)] = (value))
#define utSymGetSymArrayIndex(_Sym) (utSyms.SymArrayIndex[utSym2ValidIndex(_Sym)])
#define utSymSetSymArrayIndex(_Sym, value) ((utSyms.SymArrayIndex)[utSym2ValidIndex(_Sym)] = (value))
#define utSymSetConstructorCallback(func) (utSymConstructorCallback = (func))
#define utSymGetConstructorCallback() (utSymConstructorCallback)
#define utFirstSym() (utRootData.usedSym == 0? utSymNull : utIndex2Sym(0))
#define utLastSym() (utRootData.usedSym == 0? utSymNull : \
    utIndex2Sym(utRootData.usedSym - 1))
#define utNextSym(Sym) (utSym2ValidIndex(Sym) + 1 == utRootData.usedSym? utSymNull : \
    (Sym) + 1)
#define utPrevSym(Sym) (utSym2ValidIndex(Sym) == 0? utSymNull : (Sym) - 1)
#define utForeachSym(var) \
    for(var = utIndex2Sym(0); utSym2Index(var) != utRootData.usedSym; var++)
#define utEndForeachSym
#define utSymFreeAll() (utSetUsedSym(0), utSetUsedSymName(0))
#define utSymAllocRaw() ( \
    utRootData.usedSym == utRootData.allocatedSym && (utSymAllocMore(), true), \
    utTemp_.Sym = utIndex2Sym(utRootData.usedSym), \
    utSetUsedSym(utUsedSym() + 1), \
    utTemp_.Sym)
#define utSymAlloc() ( \
    utRootData.usedSym == utRootData.allocatedSym && (utSymAllocMore(), true), \
    utTemp_.Sym = utIndex2Sym(utRootData.usedSym), \
    utSetUsedSym(utUsedSym() + 1), \
    utSymSetNameIndex(utTemp_.Sym, 0), \
    utSymSetNumName(utTemp_.Sym, 0), \
    utSymSetNumName(utTemp_.Sym, 0), \
    utSymSetHashValue(utTemp_.Sym, 0), \
    utSymSetNext(utTemp_.Sym, utSymNull), \
    utSymSetSymArrayIndex(utTemp_.Sym, 0), \
    utSymConstructorCallback != NULL && (utSymConstructorCallback(utTemp_.Sym), true), \
    utTemp_.Sym)

void utSymAllocMore(void);
void utSymAllocNames(utSym Sym, uint32 numNames);
void utSymResizeNames(utSym Sym, uint32 numNames);
void utSymFreeNames(utSym Sym);
void utCompactSymNames(void);

/*----------------------------------------------------------------------------------------
  Fields for class Dynarray.
----------------------------------------------------------------------------------------*/
struct utDynarrayFields {
    uint32 *ValueIndex;
    uint32 *NumValue;
    uint8 *Value;
    uint16 *ValueSize;
    uint32 *UsedValue;
    uint32 *Size;
};
extern struct utDynarrayFields utDynarrays;

#define utDynarrayGetValueIndex(_Dynarray) (utDynarrays.ValueIndex[utDynarray2ValidIndex(_Dynarray)])
#define utDynarraySetValueIndex(_Dynarray, value) ((utDynarrays.ValueIndex)[utDynarray2ValidIndex(_Dynarray)] = (value))
#define utDynarrayGetNumValue(_Dynarray) (utDynarrays.NumValue[utDynarray2ValidIndex(_Dynarray)])
#define utDynarraySetNumValue(_Dynarray, value) ((utDynarrays.NumValue)[utDynarray2ValidIndex(_Dynarray)] = (value))
#if defined(DD_DEBUG)