dvdatabase.h

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

#define dvEnumSetNextTableModuleEnum(_Enum, value) ((dvEnums.NextTableModuleEnum)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetFirstEntry(_Enum) (dvEnums.FirstEntry[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetFirstEntry(_Enum, value) ((dvEnums.FirstEntry)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetLastEntry(_Enum) (dvEnums.LastEntry[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetLastEntry(_Enum, value) ((dvEnums.LastEntry)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetEntryTableIndex(_Enum) (dvEnums.EntryTableIndex[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetEntryTableIndex(_Enum, value) ((dvEnums.EntryTableIndex)[dvEnum2ValidIndex(_Enum)] = (value))
#define dvEnumGetNumEntryTable(_Enum) (dvEnums.NumEntryTable[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetNumEntryTable(_Enum, value) ((dvEnums.NumEntryTable)[dvEnum2ValidIndex(_Enum)] = (value))
#if defined(DD_DEBUG)
#define dvEnumCheckEntryTableIndex(Enum, x) ((uint32)(x) < dvEnumGetNumEntryTable(Enum)? (x) : \
    (utAssert(false),(x)))
#else
#define dvEnumCheckEntryTableIndex(Enum, x) (x)
#endif
#define dvEnumGetiEntryTable(_Enum, x) ((dvEnums.EntryTable)[ \
    dvEnumGetEntryTableIndex(_Enum) + dvEnumCheckEntryTableIndex(_Enum, (x))])
#define dvEnumGetEntryTables(Enum) (dvEnums.EntryTable + dvEnumGetEntryTableIndex(Enum))
#define dvEnumSetEntryTable(Enum, valuePtr) (memcpy(dvEnumGetEntryTables(Enum), valuePtr, \
    dvEnumGetNumEntryTable(Enum)*sizeof(dvEntry)))
#define dvEnumSetiEntryTable(Enum, x, value) ((dvEnums.EntryTable)[ \
    dvEnumGetEntryTableIndex(Enum) + dvEnumCheckEntryTableIndex(Enum, (x))] = (value))
#define dvEnumGetNumEntry(_Enum) (dvEnums.NumEntry[dvEnum2ValidIndex(_Enum)])
#define dvEnumSetNumEntry(_Enum, value) ((dvEnums.NumEntry)[dvEnum2ValidIndex(_Enum)] = (value))
dvEntry dvEnumFindEntry(dvEnum Enum, utSym sym);
void dvEnumRenameEntry(dvEnum Enum, dvEntry _Entry, utSym sym);
#define dvEntryGetName(Entry) utSymGetName(dvEntryGetSym(Entry))
#define dvForeachEnumEntry(pVar, cVar) \
    for(cVar = dvEnumGetFirstEntry(pVar); cVar != dvEntryNull; \
        cVar = dvEntryGetNextEnumEntry(cVar))
#define dvEndForeachEnumEntry
#define dvSafeForeachEnumEntry(pVar, cVar) { \
    dvEntry _nextEntry; \
    for(cVar = dvEnumGetFirstEntry(pVar); cVar != dvEntryNull; cVar = _nextEntry) { \
        _nextEntry = dvEntryGetNextEnumEntry(cVar);
#define dvEndSafeForeachEnumEntry }}
#define dvEnumSetConstructorCallback(func) (dvEnumConstructorCallback = (func))
#define dvEnumGetConstructorCallback() (dvEnumConstructorCallback)
#define dvFirstEnum() (dvRootData.usedEnum == 0? dvEnumNull : dvIndex2Enum(0))
#define dvLastEnum() (dvRootData.usedEnum == 0? dvEnumNull : \
    dvIndex2Enum(dvRootData.usedEnum - 1))
#define dvNextEnum(Enum) (dvEnum2ValidIndex(Enum) + 1 == dvRootData.usedEnum? dvEnumNull : \
    (Enum) + 1)
#define dvPrevEnum(Enum) (dvEnum2ValidIndex(Enum) == 0? dvEnumNull : (Enum) - 1)
#define dvForeachEnum(var) \
    for(var = dvIndex2Enum(0); dvEnum2Index(var) != dvRootData.usedEnum; var++)
#define dvEndForeachEnum
#define dvEnumFreeAll() (dvSetUsedEnum(0), dvSetUsedEnumEntryTable(0))
#define dvEnumAllocRaw() ( \
    dvRootData.usedEnum == dvRootData.allocatedEnum && (dvEnumAllocMore(), true), \
    dvTemp_.Enum = dvIndex2Enum(dvRootData.usedEnum), \
    dvSetUsedEnum(dvUsedEnum() + 1), \
    dvTemp_.Enum)
#define dvEnumAlloc() ( \
    dvRootData.usedEnum == dvRootData.allocatedEnum && (dvEnumAllocMore(), true), \
    dvTemp_.Enum = dvIndex2Enum(dvRootData.usedEnum), \
    dvSetUsedEnum(dvUsedEnum() + 1), \
    dvEnumSetPrefixSym(dvTemp_.Enum, 0), \
    dvEnumSetNumEntries(dvTemp_.Enum, 0), \
    dvEnumSetModule(dvTemp_.Enum, dvModuleNull), \
    dvEnumSetNextModuleEnum(dvTemp_.Enum, dvEnumNull), \
    dvEnumSetPrevModuleEnum(dvTemp_.Enum, dvEnumNull), \
    dvEnumSetSym(dvTemp_.Enum, 0), \
    dvEnumSetNextTableModuleEnum(dvTemp_.Enum, dvEnumNull), \
    dvEnumSetFirstEntry(dvTemp_.Enum, dvEntryNull), \
    dvEnumSetLastEntry(dvTemp_.Enum, dvEntryNull), \
    dvEnumSetEntryTableIndex(dvTemp_.Enum, 0), \
    dvEnumSetNumEntryTable(dvTemp_.Enum, 0), \
    dvEnumSetNumEntryTable(dvTemp_.Enum, 0), \
    dvEnumSetNumEntry(dvTemp_.Enum, 0), \
    dvEnumConstructorCallback != NULL && (dvEnumConstructorCallback(dvTemp_.Enum), true), \
    dvTemp_.Enum)

void dvEnumAllocMore(void);
void dvEnumAllocEntryTables(dvEnum Enum, uint32 numEntryTables);
void dvEnumResizeEntryTables(dvEnum Enum, uint32 numEntryTables);
void dvEnumFreeEntryTables(dvEnum Enum);
void dvCompactEnumEntryTables(void);
void dvEnumInsertEntry(dvEnum Enum, dvEntry _Entry);
void dvEnumRemoveEntry(dvEnum Enum, dvEntry _Entry);
void dvEnumInsertAfterEntry(dvEnum Enum, dvEntry prevEntry, dvEntry _Entry);
void dvEnumAppendEntry(dvEnum Enum, dvEntry _Entry);

/*----------------------------------------------------------------------------------------
  Fields for class Entry.
----------------------------------------------------------------------------------------*/
struct dvEntryFields {
    uint32 *Value;
    dvEnum *Enum;
    dvEntry *NextEnumEntry;
    dvEntry *PrevEnumEntry;
    utSym *Sym;
    dvEntry *NextTableEnumEntry;
    dvCase *FirstCase;
    dvCase *LastCase;
};
extern struct dvEntryFields dvEntrys;

#define dvEntryGetValue(_Entry) (dvEntrys.Value[dvEntry2ValidIndex(_Entry)])
#define dvEntrySetValue(_Entry, value) ((dvEntrys.Value)[dvEntry2ValidIndex(_Entry)] = (value))
#define dvEntryGetEnum(_Entry) (dvEntrys.Enum[dvEntry2ValidIndex(_Entry)])
#define dvEntrySetEnum(_Entry, value) ((dvEntrys.Enum)[dvEntry2ValidIndex(_Entry)] = (value))
#define dvEntryGetNextEnumEntry(_Entry) (dvEntrys.NextEnumEntry[dvEntry2ValidIndex(_Entry)])
#define dvEntrySetNextEnumEntry(_Entry, value) ((dvEntrys.NextEnumEntry)[dvEntry2ValidIndex(_Entry)] = (value))
#define dvEntryGetPrevEnumEntry(_Entry) (dvEntrys.PrevEnumEntry[dvEntry2ValidIndex(_Entry)])
#define dvEntrySetPrevEnumEntry(_Entry, value) ((dvEntrys.PrevEnumEntry)[dvEntry2ValidIndex(_Entry)] = (value))
#define dvEntryGetSym(_Entry) (dvEntrys.Sym[dvEntry2ValidIndex(_Entry)])
#define dvEntrySetSym(_Entry, value) ((dvEntrys.Sym)[dvEntry2ValidIndex(_Entry)] = (value))
#define dvEntryGetNextTableEnumEntry(_Entry) (dvEntrys.NextTableEnumEntry[dvEntry2ValidIndex(_Entry)])
#define dvEntrySetNextTableEnumEntry(_Entry, value) ((dvEntrys.NextTableEnumEntry)[dvEntry2ValidIndex(_Entry)] = (value))
#define dvEntryGetFirstCase(_Entry) (dvEntrys.FirstCase[dvEntry2ValidIndex(_Entry)])
#define dvEntrySetFirstCase(_Entry, value) ((dvEntrys.FirstCase)[dvEntry2ValidIndex(_Entry)] = (value))
#define dvEntryGetLastCase(_Entry) (dvEntrys.LastCase[dvEntry2ValidIndex(_Entry)])
#define dvEntrySetLastCase(_Entry, value) ((dvEntrys.LastCase)[dvEntry2ValidIndex(_Entry)] = (value))
#define dvForeachEntryCase(pVar, cVar) \
    for(cVar = dvEntryGetFirstCase(pVar); cVar != dvCaseNull; \
        cVar = dvCaseGetNextEntryCase(cVar))
#define dvEndForeachEntryCase
#define dvSafeForeachEntryCase(pVar, cVar) { \
    dvCase _nextCase; \
    for(cVar = dvEntryGetFirstCase(pVar); cVar != dvCaseNull; cVar = _nextCase) { \
        _nextCase = dvCaseGetNextEntryCase(cVar);
#define dvEndSafeForeachEntryCase }}
#define dvEntrySetConstructorCallback(func) (dvEntryConstructorCallback = (func))
#define dvEntryGetConstructorCallback() (dvEntryConstructorCallback)
#define dvFirstEntry() (dvRootData.usedEntry == 0? dvEntryNull : dvIndex2Entry(0))
#define dvLastEntry() (dvRootData.usedEntry == 0? dvEntryNull : \
    dvIndex2Entry(dvRootData.usedEntry - 1))
#define dvNextEntry(Entry) (dvEntry2ValidIndex(Entry) + 1 == dvRootData.usedEntry? dvEntryNull : \
    (Entry) + 1)
#define dvPrevEntry(Entry) (dvEntry2ValidIndex(Entry) == 0? dvEntryNull : (Entry) - 1)
#define dvForeachEntry(var) \
    for(var = dvIndex2Entry(0); dvEntry2Index(var) != dvRootData.usedEntry; var++)
#define dvEndForeachEntry
#define dvEntryFreeAll() (dvSetUsedEntry(0))
#define dvEntryAllocRaw() ( \
    dvRootData.usedEntry == dvRootData.allocatedEntry && (dvEntryAllocMore(), true), \
    dvTemp_.Entry = dvIndex2Entry(dvRootData.usedEntry), \
    dvSetUsedEntry(dvUsedEntry() + 1), \
    dvTemp_.Entry)
#define dvEntryAlloc() ( \
    dvRootData.usedEntry == dvRootData.allocatedEntry && (dvEntryAllocMore(), true), \
    dvTemp_.Entry = dvIndex2Entry(dvRootData.usedEntry), \
    dvSetUsedEntry(dvUsedEntry() + 1), \
    dvEntrySetValue(dvTemp_.Entry, 0), \
    dvEntrySetEnum(dvTemp_.Entry, dvEnumNull), \
    dvEntrySetNextEnumEntry(dvTemp_.Entry, dvEntryNull), \
    dvEntrySetPrevEnumEntry(dvTemp_.Entry, dvEntryNull), \
    dvEntrySetSym(dvTemp_.Entry, 0), \
    dvEntrySetNextTableEnumEntry(dvTemp_.Entry, dvEntryNull), \
    dvEntrySetFirstCase(dvTemp_.Entry, dvCaseNull), \
    dvEntrySetLastCase(dvTemp_.Entry, dvCaseNull), \
    dvEntryConstructorCallback != NULL && (dvEntryConstructorCallback(dvTemp_.Entry), true), \
    dvTemp_.Entry)

void dvEntryAllocMore(void);
void dvEntryInsertCase(dvEntry Entry, dvCase _Case);
void dvEntryRemoveCase(dvEntry Entry, dvCase _Case);
void dvEntryInsertAfterCase(dvEntry Entry, dvCase prevCase, dvCase _Case);
void dvEntryAppendCase(dvEntry Entry, dvCase _Case);

/*----------------------------------------------------------------------------------------
  Fields for class Typedef.
----------------------------------------------------------------------------------------*/
struct dvTypedefFields {
    dvModule *Module;
    dvTypedef *NextModuleTypedef;
    dvTypedef *PrevModuleTypedef;
    utSym *Sym;
    dvTypedef *NextTableModuleTypedef;
};
extern struct dvTypedefFields dvTypedefs;

#define dvTypedefGetModule(_Typedef) (dvTypedefs.Module[dvTypedef2ValidIndex(_Typedef)])
#define dvTypedefSetModule(_Typedef, value) ((dvTypedefs.Module)[dvTypedef2ValidIndex(_Typedef)] = (value))
#define dvTypedefGetNextModuleTypedef(_Typedef) (dvTypedefs.NextModuleTypedef[dvTypedef2ValidIndex(_Typedef)])
#define dvTypedefSetNextModuleTypedef(_Typedef, value) ((dvTypedefs.NextModuleTypedef)[dvTypedef2ValidIndex(_Typedef)] = (value))
#define dvTypedefGetPrevModuleTypedef(_Typedef) (dvTypedefs.PrevModuleTypedef[dvTypedef2ValidIndex(_Typedef)])
#define dvTypedefSetPrevModuleTypedef(_Typedef, value) ((dvTypedefs.PrevModuleTypedef)[dvTypedef2ValidIndex(_Typedef)] = (value))
#define dvTypedefGetSym(_Typedef) (dvTypedefs.Sym[dvTypedef2ValidIndex(_Typedef)])
#define dvTypedefSetSym(_Typedef, value) ((dvTypedefs.Sym)[dvTypedef2ValidIndex(_Typedef)] = (value))
#define dvTypedefGetNextTableModuleTypedef(_Typedef) (dvTypedefs.NextTableModuleTypedef[dvTypedef2ValidIndex(_Typedef)])
#define dvTypedefSetNextTableModuleTypedef(_Typedef, value) ((dvTypedefs.NextTableModuleTypedef)[dvTypedef2ValidIndex(_Typedef)] = (value))
#define dvTypedefSetConstructorCallback(func) (dvTypedefConstructorCallback = (func))
#define dvTypedefGetConstructorCallback() (dvTypedefConstructorCallback)
#define dvFirstTypedef() (dvRootData.usedTypedef == 0? dvTypedefNull : dvIndex2Typedef(0))
#define dvLastTypedef() (dvRootData.usedTypedef == 0? dvTypedefNull : \
    dvIndex2Typedef(dvRootData.usedTypedef - 1))
#define dvNextTypedef(Typedef) (dvTypedef2ValidIndex(Typedef) + 1 == dvRootData.usedTypedef? dvTypedefNull : \
    (Typedef) + 1)
#define dvPrevTypedef(Typedef) (dvTypedef2ValidIndex(Typedef) == 0? dvTypedefNull : (Typedef) - 1)
#define dvForeachTypedef(var) \
    for(var = dvIndex2Typedef(0); dvTypedef2Index(var) != dvRootData.usedTypedef; var++)
#define dvEndForeachTypedef
#define dvTypedefFreeAll() (dvSetUsedTypedef(0))
#define dvTypedefAllocRaw() ( \
    dvRootData.usedTypedef == dvRootData.allocatedTypedef && (dvTypedefAllocMore(), true), \
    dvTemp_.Typedef = dvIndex2Typedef(dvRootData.usedTypedef), \
    dvSetUsedTypedef(dvUsedTypedef() + 1), \
    dvTemp_.Typedef)
#define dvTypedefAlloc() ( \
    dvRootData.usedTypedef == dvRootData.allocatedTypedef && (dvTypedefAllocMore(), true), \
    dvTemp_.Typedef = dvIndex2Typedef(dvRootData.usedTypedef), \
    dvSetUsedTypedef(dvUsedTypedef() + 1), \
    dvTypedefSetModule(dvTemp_.Typedef, dvModuleNull), \
    dvTypedefSetNextModuleTypedef(dvTemp_.Typedef, dvTypedefNull), \
    dvTypedefSetPrevModuleTypedef(dvTemp_.Typedef, dvTypedefNull), \
    dvTypedefSetSym(dvTemp_.Typedef, 0), \
    dvTypedefSetNextTableModuleTypedef(dvTemp_.Typedef, dvTypedefNull), \
    dvTypedefConstructorCallback != NULL && (dvTypedefConstructorCallback(dvTemp_.Typedef), true), \
    dvTemp_.Typedef)

void dvTypedefAllocMore(void);

/*----------------------------------------------------------------------------------------
  Fields for class Class.
----------------------------------------------------------------------------------------*/
struct dvClassFields {
    dvMemoryStyle *MemoryStyle;
    uint8 *ReferenceSize;
    uint8 *GenerateArrayClass;
    uint16 *NumFields;
    dvModule *Module;
    dvClass *NextModuleClass;
    dvClass *PrevModuleClass;
    utSym *Sym;
    dvClass *NextTableModu