utdatabase.h

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

#define utDynarrayCheckValueIndex(Dynarray, x) ((uint32)(x) < utDynarrayGetNumValue(Dynarray)? (x) : \
    (utAssert(false),(x)))
#else
#define utDynarrayCheckValueIndex(Dynarray, x) (x)
#endif
#define utDynarrayGetiValue(_Dynarray, x) ((utDynarrays.Value)[ \
    utDynarrayGetValueIndex(_Dynarray) + utDynarrayCheckValueIndex(_Dynarray, (x))])
#define utDynarrayGetValues(Dynarray) (utDynarrays.Value + utDynarrayGetValueIndex(Dynarray))
#define utDynarraySetValue(Dynarray, valuePtr) (memcpy(utDynarrayGetValues(Dynarray), valuePtr, \
    utDynarrayGetNumValue(Dynarray)*sizeof(uint8)))
#define utDynarraySetiValue(Dynarray, x, value) ((utDynarrays.Value)[ \
    utDynarrayGetValueIndex(Dynarray) + utDynarrayCheckValueIndex(Dynarray, (x))] = (value))
#define utDynarrayGetValueSize(_Dynarray) (utDynarrays.ValueSize[utDynarray2ValidIndex(_Dynarray)])
#define utDynarraySetValueSize(_Dynarray, value) ((utDynarrays.ValueSize)[utDynarray2ValidIndex(_Dynarray)] = (value))
#define utDynarrayGetUsedValue(_Dynarray) (utDynarrays.UsedValue[utDynarray2ValidIndex(_Dynarray)])
#define utDynarraySetUsedValue(_Dynarray, value) ((utDynarrays.UsedValue)[utDynarray2ValidIndex(_Dynarray)] = (value))
#define utDynarrayGetSize(_Dynarray) (utDynarrays.Size[utDynarray2ValidIndex(_Dynarray)])
#define utDynarraySetSize(_Dynarray, value) ((utDynarrays.Size)[utDynarray2ValidIndex(_Dynarray)] = (value))
#define utDynarraySetConstructorCallback(func) (utDynarrayConstructorCallback = (func))
#define utDynarrayGetConstructorCallback() (utDynarrayConstructorCallback)
#define utDynarraySetDestructorCallback(func) (utDynarrayDestructorCallback = (func))
#define utDynarrayGetDestructorCallback() (utDynarrayDestructorCallback)
#define utDynarrayNextFree(_Dynarray) (((utDynarray *)(void *)(utDynarrays.ValueIndex))[utDynarray2ValidIndex(_Dynarray)])
#define utDynarraySetNextFree(Dynarray, value) (((utDynarray *)(void *)(utDynarrays.ValueIndex)) \
    [utDynarray2ValidIndex(Dynarray)] = (value))
#define utDynarrayAllocRaw() ( \
    utRootData.firstFreeDynarray != utDynarrayNull? \
        (utTemp_.Dynarray = utRootData.firstFreeDynarray, \
        utSetFirstFreeDynarray(utDynarrayNextFree(utTemp_.Dynarray)), true) \
    : (utRootData.usedDynarray == utRootData.allocatedDynarray && (utDynarrayAllocMore(), true), \
        utTemp_.Dynarray = utIndex2Dynarray(utRootData.usedDynarray), \
        utSetUsedDynarray(utUsedDynarray() + 1)), \
    utTemp_.Dynarray)
#define utDynarrayAlloc() ( \
    utRootData.firstFreeDynarray != utDynarrayNull? \
        (utTemp_.Dynarray = utRootData.firstFreeDynarray, \
        utSetFirstFreeDynarray(utDynarrayNextFree(utTemp_.Dynarray)), true) \
    : (utRootData.usedDynarray == utRootData.allocatedDynarray && (utDynarrayAllocMore(), true), \
        utTemp_.Dynarray = utIndex2Dynarray(utRootData.usedDynarray), \
        utSetUsedDynarray(utUsedDynarray() + 1)), \
    utDynarraySetValueIndex(utTemp_.Dynarray, 0), \
    utDynarraySetNumValue(utTemp_.Dynarray, 0), \
    utDynarraySetNumValue(utTemp_.Dynarray, 0), \
    utDynarraySetValueSize(utTemp_.Dynarray, 0), \
    utDynarraySetUsedValue(utTemp_.Dynarray, 0), \
    utDynarraySetSize(utTemp_.Dynarray, 0), \
    utDynarrayConstructorCallback != NULL && (utDynarrayConstructorCallback(utTemp_.Dynarray), true), \
    utTemp_.Dynarray)

#define utDynarrayFree(Dynarray) (utDynarrayFreeValues(Dynarray), \
    utDynarraySetNextFree(Dynarray, utRootData.firstFreeDynarray), \
    utSetFirstFreeDynarray(Dynarray))
void utDynarrayDestroy(utDynarray Dynarray);
void utDynarrayAllocMore(void);
void utDynarrayAllocValues(utDynarray Dynarray, uint32 numValues);
void utDynarrayResizeValues(utDynarray Dynarray, uint32 numValues);
void utDynarrayFreeValues(utDynarray Dynarray);
void utCompactDynarrayValues(void);

/*----------------------------------------------------------------------------------------
  Fields for class SymArray.
----------------------------------------------------------------------------------------*/
struct utSymArrayFields {
    uint32 *SymIndex;
    uint32 *NumSym;
    utSym *Sym;
    uint32 *UsedSym;
};
extern struct utSymArrayFields utSymArrays;

#define utSymArrayGetSymIndex(_SymArray) (utSymArrays.SymIndex[utSymArray2ValidIndex(_SymArray)])
#define utSymArraySetSymIndex(_SymArray, value) ((utSymArrays.SymIndex)[utSymArray2ValidIndex(_SymArray)] = (value))
#define utSymArrayGetNumSym(_SymArray) (utSymArrays.NumSym[utSymArray2ValidIndex(_SymArray)])
#define utSymArraySetNumSym(_SymArray, value) ((utSymArrays.NumSym)[utSymArray2ValidIndex(_SymArray)] = (value))
#if defined(DD_DEBUG)
#define utSymArrayCheckSymIndex(SymArray, x) ((uint32)(x) < utSymArrayGetNumSym(SymArray)? (x) : \
    (utAssert(false),(x)))
#else
#define utSymArrayCheckSymIndex(SymArray, x) (x)
#endif
#define utSymArrayGetiSym(_SymArray, x) ((utSymArrays.Sym)[ \
    utSymArrayGetSymIndex(_SymArray) + utSymArrayCheckSymIndex(_SymArray, (x))])
#define utSymArrayGetSyms(SymArray) (utSymArrays.Sym + utSymArrayGetSymIndex(SymArray))
#define utSymArraySetSym(SymArray, valuePtr) (memcpy(utSymArrayGetSyms(SymArray), valuePtr, \
    utSymArrayGetNumSym(SymArray)*sizeof(utSym)))
#define utSymArraySetiSym(SymArray, x, value) ((utSymArrays.Sym)[ \
    utSymArrayGetSymIndex(SymArray) + utSymArrayCheckSymIndex(SymArray, (x))] = (value))
#define utSymArrayGetUsedSym(_SymArray) (utSymArrays.UsedSym[utSymArray2ValidIndex(_SymArray)])
#define utSymArraySetUsedSym(_SymArray, value) ((utSymArrays.UsedSym)[utSymArray2ValidIndex(_SymArray)] = (value))
#define utForeachSymArraySym(pVar, cVar) { \
    uint32 _xSym; \
    for(_xSym = 0; _xSym < utSymArrayGetUsedSym(pVar); _xSym++) { \
        cVar = utSymArrayGetiSym(pVar, _xSym); \
        if(cVar != utSymNull) {
#define utEndForeachSymArraySym }}}
#define utSymArraySetConstructorCallback(func) (utSymArrayConstructorCallback = (func))
#define utSymArrayGetConstructorCallback() (utSymArrayConstructorCallback)
#define utSymArraySetDestructorCallback(func) (utSymArrayDestructorCallback = (func))
#define utSymArrayGetDestructorCallback() (utSymArrayDestructorCallback)
#define utSymArrayNextFree(_SymArray) (((utSymArray *)(void *)(utSymArrays.SymIndex))[utSymArray2ValidIndex(_SymArray)])
#define utSymArraySetNextFree(SymArray, value) (((utSymArray *)(void *)(utSymArrays.SymIndex)) \
    [utSymArray2ValidIndex(SymArray)] = (value))
#define utSymArrayAllocRaw() ( \
    utRootData.firstFreeSymArray != utSymArrayNull? \
        (utTemp_.SymArray = utRootData.firstFreeSymArray, \
        utSetFirstFreeSymArray(utSymArrayNextFree(utTemp_.SymArray)), true) \
    : (utRootData.usedSymArray == utRootData.allocatedSymArray && (utSymArrayAllocMore(), true), \
        utTemp_.SymArray = utIndex2SymArray(utRootData.usedSymArray), \
        utSetUsedSymArray(utUsedSymArray() + 1)), \
    utTemp_.SymArray)
#define utSymArrayAlloc() ( \
    utRootData.firstFreeSymArray != utSymArrayNull? \
        (utTemp_.SymArray = utRootData.firstFreeSymArray, \
        utSetFirstFreeSymArray(utSymArrayNextFree(utTemp_.SymArray)), true) \
    : (utRootData.usedSymArray == utRootData.allocatedSymArray && (utSymArrayAllocMore(), true), \
        utTemp_.SymArray = utIndex2SymArray(utRootData.usedSymArray), \
        utSetUsedSymArray(utUsedSymArray() + 1)), \
    utSymArraySetSymIndex(utTemp_.SymArray, 0), \
    utSymArraySetNumSym(utTemp_.SymArray, 0), \
    utSymArraySetNumSym(utTemp_.SymArray, 0), \
    utSymArraySetUsedSym(utTemp_.SymArray, 0), \
    utSymArrayConstructorCallback != NULL && (utSymArrayConstructorCallback(utTemp_.SymArray), true), \
    utTemp_.SymArray)

#define utSymArrayFree(SymArray) (utSymArrayFreeSyms(SymArray), \
    utSymArraySetNextFree(SymArray, utRootData.firstFreeSymArray), \
    utSetFirstFreeSymArray(SymArray))
void utSymArrayDestroy(utSymArray SymArray);
void utSymArrayAllocMore(void);
void utSymArrayAllocSyms(utSymArray SymArray, uint32 numSyms);
void utSymArrayResizeSyms(utSymArray SymArray, uint32 numSyms);
void utSymArrayFreeSyms(utSymArray SymArray);
void utCompactSymArraySyms(void);
void utSymArrayInsertSym(utSymArray SymArray, uint32 x, utSym _Sym);
void utSymArrayAppendSym(utSymArray SymArray, utSym _Sym);
void utSymArrayRemoveSym(utSymArray SymArray, utSym _Sym);

/*----------------------------------------------------------------------------------------
  Temp Union structure - Macro temp variables, use only one
----------------------------------------------------------------------------------------*/
union utTempType_ {
    utSymtab Symtab;
    utSym Sym;
    utDynarray Dynarray;
    utSymArray SymArray;
};

extern union utTempType_ utTemp_;

/*----------------------------------------------------------------------------------------
  Constructor/Destructor hooks.
----------------------------------------------------------------------------------------*/
extern void(*utSymtabConstructorCallback)(utSymtab);
extern void(*utSymConstructorCallback)(utSym);
extern void(*utDynarrayConstructorCallback)(utDynarray);
extern void(*utDynarrayDestructorCallback)(utDynarray);
extern void(*utSymArrayConstructorCallback)(utSymArray);
extern void(*utSymArrayDestructorCallback)(utSymArray);

/*----------------------------------------------------------------------------------------
  Root structure
----------------------------------------------------------------------------------------*/
struct utRootType_ {
    uint32 hash; /* This depends only on the structure of the database */
    uint32 usedSymtab, allocatedSymtab;
    uint32 usedSymtabTable, allocatedSymtabTable, freeSymtabTable;
    uint32 usedSym, allocatedSym;
    uint32 usedSymName, allocatedSymName, freeSymName;
    utDynarray firstFreeDynarray;
    uint32 usedDynarray, allocatedDynarray;
    uint32 usedDynarrayValue, allocatedDynarrayValue, freeDynarrayValue;
    utSymArray firstFreeSymArray;
    uint32 usedSymArray, allocatedSymArray;
    uint32 usedSymArraySym, allocatedSymArraySym, freeSymArraySym;
};
extern struct utRootType_ utRootData;

#define utHash() (utRootData.hash)
#define utUsedSymtab() utRootData.usedSymtab
#define utAllocatedSymtab() utRootData.allocatedSymtab
#define utSetUsedSymtab(value) (utRootData.usedSymtab = (value))
#define utSetAllocatedSymtab(value) (utRootData.allocatedSymtab = (value))
#define utUsedSymtabTable() utRootData.usedSymtabTable
#define utAllocatedSymtabTable() utRootData.allocatedSymtabTable
#define utFreeSymtabTable() utRootData.freeSymtabTable
#define utSetUsedSymtabTable(value) (utRootData.usedSymtabTable = (value))
#define utSetAllocatedSymtabTable(value) (utRootData.allocatedSymtabTable = (value))
#define utSetFreeSymtabTable(value) (utRootData.freeSymtabTable = (value))
#define utUsedSym() utRootData.usedSym
#define utAllocatedSym() utRootData.allocatedSym
#define utSetUsedSym(value) (utRootData.usedSym = (value))
#define utSetAllocatedSym(value) (utRootData.allocatedSym = (value))
#define utUsedSymName() utRootData.usedSymName
#define utAllocatedSymName() utRootData.allocatedSymName
#define utFreeSymName() utRootData.freeSymName
#define utSetUsedSymName(value) (utRootData.usedSymName = (value))
#define utSetAllocatedSymName(value) (utRootData.allocatedSymName = (value))
#define utSetFreeSymName(value) (utRootData.freeSymName = (value))
#define utFirstFreeDynarray() utRootData.firstFreeDynarray
#define utSetFirstFreeDynarray(value) (utRootData.firstFreeDynarray = (value))
#define utUsedDynarray() utRootData.usedDynarray
#define utAllocatedDynarray() utRootData.allocatedDynarray
#define utSetUsedDynarray(value) (utRootData.usedDynarray = (value))
#define utSetAllocatedDynarray(value) (utRootData.allocatedDynarray = (value))
#define utUsedDynarrayValue() utRootData.usedDynarrayValue
#define utAllocatedDynarrayValue() utRootData.allocatedDynarrayValue
#define utFreeDynarrayValue() utRootData.freeDynarrayValue
#define utSetUsedDynarrayValue(value) (utRootData.usedDynarrayValue = (value))
#define utSetAllocatedDynarrayValue(value) (utRootData.allocatedDynarrayValue = (value))
#define utSetFreeDynarrayValue(value) (utRootData.freeDynarrayValue = (value))
#define utFirstFreeSymArray() utRootData.firstFreeSymArray
#define utSetFirstFreeSymArray(value) (utRootData.firstFreeSymArray = (value))
#define utUsedSymArray() utRootData.usedSymArray
#define utAllocatedSymArray() utRootData.allocatedSymArray
#define utSetUsedSymArray(value) (utRootData.usedSymArray = (value))
#define utSetAllocatedSymArray(value) (utRootData.allocatedSymArray = (value))
#define utUsedSymArraySym() utRootData.usedSymArraySym
#define utAllocatedSymArraySym() utRootData.allocatedSymArraySym
#define utFreeSymArraySym() utRootData.freeSymArraySym
#define utSetUsedSymArraySym(value) (utRootData.usedSymArraySym = (value))
#define utSetAllocatedSymArraySym(value) (utRootData.allocatedSymArraySym = (value))
#define utSetFreeSymArraySym(value) (utRootData.freeSymArraySym = (value))

extern uint8 utModuleID;
void utDatabaseStart(void);
void utDatabaseStop(void);
#if defined __cplusplus
}
#endif

#endif