dvgenh.c

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

                dvPrefix, name, propName, utSprintf("%u", dvPropertyGetFieldNumber(prop)));
            dvWrtemp(dvFile, 
                    "#define %0%1Seti%2(%1, x, value) (%3(%0%1s.%2)[ \\\n"
                    "    %0%1Get%2Index(%1) + %0%1Check%2Index(%1, (x))] = (value)%4)\n",
                dvPrefix, name, propName, preString, postString);
            if(dvPropertyGetType(prop) == PROP_CHAR) {
                dvWrtemp(dvFile, 
                    "#define %0%1Get%2(%1) (%0%1s.%2 + %0%1Get%2Index(%1))\n",
                    dvPrefix, name, propName);
            }
        } else {
            theUnion = dvPropertyGetUnion(prop);
            if(theUnion == dvUnionNull) {
                preString = dvSwrtemp(!dvClassUndo(theClass)? "" :
                    " \\\n    (void)utRecordField(%0ModuleID, %3, %2%12ValidIndex(_%1)%4, true), \\\n    ",
                    dvPrefix, name, dvClassGetPrefix(theClass),
                    utSprintf("%u", dvPropertyGetFieldNumber(prop)),
                    dvPropertyGetType(prop) == PROP_BIT? " >> 3" : "");
                postString = dvSwrtemp(!dvClassRedo(theClass)? "" :
                    ", \\\n    (void)utRecordField(%0ModuleID, %3, %2%12ValidIndex(_%1)%4, false)",
                    dvPrefix, name, dvClassGetPrefix(theClass),
                    utSprintf("%u", dvPropertyGetFieldNumber(prop)),
                    dvPropertyGetType(prop) == PROP_BIT? " >> 3" : "");
            } else {
                preString = dvSwrtemp(!dvClassUndo(theClass)? "" :
                    " \\\n    (void)utRecordField(%0ModuleID, %3, %2%12ValidIndex(_%1), true), \\\n    ",
                    dvPrefix, name, dvClassGetPrefix(theClass),
                    utSprintf("%u", dvUnionGetFieldNumber(theUnion)));
                postString = dvSwrtemp(!dvClassRedo(theClass)? "" :
                    ", \\\n    (void)utRecordField(%0ModuleID, %3, %2%12ValidIndex(_%1), false)",
                    dvPrefix, name, dvClassGetPrefix(theClass),
                    utSprintf("%u", dvUnionGetFieldNumber(theUnion)));
            }
            if(dvPropertyGetType(prop) == PROP_BIT) {
                dvWrtemp(dvFile, 
                    "#define %0%1%2(_%1) (((%0%1s.%2)[%3%12ValidIndex(_%1) >> 3] >> \\\n"
                    "    (%3%12ValidIndex(_%1) & 7)) & 1)\n"
                    "#define %0%1Set%2(_%1, value) (%4(%0%1s.%2)[%3%12ValidIndex(_%1) >> 3] = \\\n"
                    "    (%4(%0%1s.%2)[%3%12ValidIndex(_%1) >> 3] & ~(1 << (%3%12ValidIndex(_%1) & 7))) | \\\n"
                    "    (((value) != 0) << (%3%12ValidIndex(_%1) & 7))%5)\n",
                    dvPrefix, name, propName, dvClassGetPrefix(theClass), preString, postString);
            } else {
                if(theUnion == dvUnionNull) {
                    dvWrtemp(dvFile, 
                        "#define %0%1%3%2(_%1) (%0%1s.%2[%4%12ValidIndex(_%1)])\n"
                        "#define %0%1Set%2(_%1, value) (%5(%0%1s.%2)[%4%12ValidIndex(_%1)] = (value)%6)\n",
                        dvPrefix, name, propName, dvPropertyGetType(prop) == PROP_BOOL? "" : "Get",
                        dvClassGetPrefix(theClass), preString, postString);
                } else {
                    dvWrtemp(dvFile, 
                        "#define %0%1%3%2(_%1) (%0%1s.%7[%4%12ValidIndex(_%1)].%2)\n"
                        "#define %0%1Set%2(_%1, value) \\\n"
                        "    (%5%0%1s.%7[%4%12ValidIndex(_%1)].%2 = (value)%6)\n",
                        dvPrefix, name, propName, dvPropertyGetType(prop) == PROP_BOOL? "" : "Get",
                        dvClassGetPrefix(theClass), preString, postString,
                        dvUnionGetFieldName(theUnion));
                }
            }
        }
    } dvEndForeachClassProperty;
}

/*--------------------------------------------------------------------------------------------------
  Write theClass's child rel macros.
--------------------------------------------------------------------------------------------------*/
static void writeClassChildRelMacros(
    dvClass theClass)
{
    dvRelationship relationship;
    dvClass childClass;
    dvRelationshipType type;
    char *name = dvClassGetName(theClass);
    
    dvForeachClassChildRelationship(theClass, relationship) {
        type = dvRelationshipGetType(relationship);
        if(dvRelationshipAccessChild(relationship)) {
            childClass = dvRelationshipGetChildClass(relationship);
            if(type == REL_HASHED) {
                dvWrtemp(dvFile, 
                    "%5%3 %0%1Find%2%3(%4%1 %1, utSym sym);\n"
                    "void %0%1Rename%2%3(%4%1 %1, %5%3 _%3, utSym sym);\n"
                    "#define %0%3Get%2Name(%3) utSymGetName(%0%3Get%2Sym(%3))\n",
                    dvPrefix, name, dvRelationshipGetChildLabel(relationship),
                    dvClassGetName(childClass), dvClassGetPrefix(theClass),
                    dvClassGetPrefix(childClass));
            }
            if(type == REL_LINKED_LIST || type == REL_DOUBLY_LINKED || type == REL_TAIL_LINKED ||
                    type == REL_HASHED) {
                dvWrtemp(dvFile, 
                    "#define %0Foreach%1%2%3(pVar, cVar) \\\n"
                    "    for(cVar = %0%1GetFirst%2%3(pVar); cVar != %5%3Null; \\\n"
                    "        cVar = %0%3GetNext%1%2%3(cVar))\n"
                    "#define %0EndForeach%1%2%3\n",
                    dvPrefix, name, dvRelationshipGetChildLabel(relationship),
                    dvClassGetName(childClass), dvClassGetPrefix(theClass),
                    dvClassGetPrefix(childClass));
                dvWrtemp(dvFile, 
                    "#define %0SafeForeach%1%2%3(pVar, cVar) { \\\n"
                    "    %5%3 _next%3; \\\n"
                    "    for(cVar = %0%1GetFirst%2%3(pVar); cVar != %5%3Null; cVar = _next%3) { \\\n"
                    "        _next%3 = %0%3GetNext%1%2%3(cVar);\n"
                    "#define %0EndSafeForeach%1%2%3 }}\n",
                    dvPrefix, name, dvRelationshipGetChildLabel(relationship),
                    dvClassGetName(childClass), dvClassGetPrefix(theClass),
                    dvClassGetPrefix(childClass));
            }
            if(type == REL_ARRAY) {
                dvWrtemp(dvFile, 
                    "#define %0Foreach%1%2%3(pVar, cVar) { \\\n"
                    "    uint32 _x%3; \\\n"
                    "    for(_x%3 = 0; _x%3 < %0%1GetUsed%2%3(pVar); _x%3++) { \\\n"
                    "        cVar = %0%1Geti%2%3(pVar, _x%3); \\\n"
                    "        if(cVar != %4%3Null) {\n"
                    "#define %0EndForeach%1%2%3 }}}\n",
                    dvPrefix, name, dvRelationshipGetChildLabel(relationship),
                    dvClassGetName(childClass), dvClassGetPrefix(childClass));
            }
        }
    } dvEndForeachClassChildRelationship;
}

/*--------------------------------------------------------------------------------------------------
  Write the constructor callback in the creation macro.
--------------------------------------------------------------------------------------------------*/
static void writeClassConstructorCallback(
    dvClass theClass)
{
    dvWrtemp(dvFile, 
        "    %0%1ConstructorCallback != NULL && (%0%1ConstructorCallback(%0Temp_.%1), true), \\\n",
        dvPrefix, dvClassGetName(theClass));
}

/*--------------------------------------------------------------------------------------------------
  Write code to initialize properties of an object.
--------------------------------------------------------------------------------------------------*/
void writePropertyInits(
    dvClass theClass)
{
    dvUnion theUnion;
    dvProperty prop;
    char *nullObj;

    dvForeachClassProperty(theClass, prop) {
        if(dvPropertyArray(prop)) {
            dvWrtemp(dvFile, 
                "    %0%1SetNum%2(%0Temp_.%1, 0), \\\n",
                dvPrefix, dvClassGetName(theClass), dvPropertyGetName(prop));
        } else { 
            theUnion = dvPropertyGetUnion(prop);
            if(theUnion == dvUnionNull || dvUnionGetFirstProperty(theUnion) == prop) {
                if(dvPropertyGetType(prop) == PROP_POINTER) {
                    nullObj = utSprintf("%s%sNull", dvClassGetPrefix(dvPropertyGetClassProp(prop)),
                           dvClassGetName(dvPropertyGetClassProp(prop)));
                } else {
                    nullObj = "0";
                }
                if(dvPropertyGetType(prop) != PROP_TYPEDEF) {
                    dvWrtemp(dvFile, 
                        "    %0%1Set%2(%0Temp_.%1, %3), \\\n",
                        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(prop), nullObj);
                }
            }
        }
    } dvEndForeachClassProperty;
}

/*--------------------------------------------------------------------------------------------------
  Write a create macro for a free-list class.
--------------------------------------------------------------------------------------------------*/
static void writeCreateMacroForFreeListClass(
    dvClass theClass,
    bool initFields)
{
    char *name = dvClassGetName(theClass);

    dvWrtemp(dvFile, "#define %0%2%1() ( \\\n", dvPrefix, initFields ? "Alloc" : "AllocRaw", name);
    dvWrtemp(dvFile,
        "    %0RootData.firstFree%1 != %0%1Null? \\\n"
        "        (%0Temp_.%1 = %0RootData.firstFree%1, \\\n"
        "        %0SetFirstFree%1(%0%1NextFree(%0Temp_.%1)), true) \\\n"
        "    : (%0RootData.used%1 == %0RootData.allocated%1 && (%0%1AllocMore(), true), \\\n"
        "        %0Temp_.%1 = %0Index2%1(%0RootData.used%1), \\\n"
        "        %0SetUsed%1(%0Used%1() + 1)), \\\n",
        dvPrefix, name);
    if(initFields) {
        writePropertyInits(theClass);
        writeClassConstructorCallback(theClass);
    }
    dvWrtemp(dvFile, 
        "    %0Temp_.%1)\n", dvPrefix, name);
}

/*--------------------------------------------------------------------------------------------------
  Write a create macro for a create-only class.
--------------------------------------------------------------------------------------------------*/
static void writeCreateMacroForCreateOnlyClass(
    dvClass theClass,
    bool initFields)
{
    char *name = dvClassGetName(theClass);

    dvWrtemp(dvFile, "#define %0%2%1() ( \\\n", dvPrefix, initFields ? "Alloc" : "AllocRaw", name);
    dvWrtemp(dvFile, 
        "    %0RootData.used%1 == %0RootData.allocated%1 && (%0%1AllocMore(), true), \\\n"
        "    %0Temp_.%1 = %0Index2%1(%0RootData.used%1), \\\n"
        "    %0SetUsed%1(%0Used%1() + 1), \\\n",
        dvPrefix, name);
    if(initFields) {
        writePropertyInits(theClass);
        writeClassConstructorCallback(theClass);
    }
    dvWrtemp(dvFile, "    %0Temp_.%1)\n", dvPrefix, name);
}

/*--------------------------------------------------------------------------------------------------
  Write the create macro for theClass.
--------------------------------------------------------------------------------------------------*/
static void writeClassCreateMacro(
    dvClass theClass)
{
    if(dvClassGetMemoryStyle(theClass) == MEM_FREE_LIST) {
        writeCreateMacroForFreeListClass(theClass, false);
        writeCreateMacroForFreeListClass(theClass, true);
    } else if(dvClassGetMemoryStyle(theClass) == MEM_CREATE_ONLY) {
        writeCreateMacroForCreateOnlyClass(theClass, false);
        writeCreateMacroForCreateOnlyClass(theClass, true);
    } else {
        utExit("Unknown type of memory option for %s", dvClassGetName(theClass));
    }
}

/*--------------------------------------------------------------------------------------------------
  Write an init macro for a free-list class.
--------------------------------------------------------------------------------------------------*/
static void writeClassInitMacro(
    dvClass theClass)
{
    char *name = dvClassGetName(theClass);

    dvWrtemp(dvFile,
        "#define %0%1Init(%1) ("
        "    %0Temp_.%1 = (%1), \\\n",
        dvPrefix, name);
    writePropertyInits(theClass);
    writeClassConstructorCallback(theClass);
    dvWrtemp(dvFile, "    true)\n", dvPrefix, name);
}

/*--------------------------------------------------------------------------------------------------
  Write all misc. macros for traversal of theClass.
--------------------------------------------------------------------------------------------------*/
static void writeClassMiscMacros(
    dvClass theClass)
{
    char *name = dvClassGetName(theClass);
    dvProperty prop;
    char *preString, *postString;
    
    dvWrtemp(dvFile,
        "#define %0%1SetConstructorCallback(func) (%0%1ConstructorCallback = (func))\n"
        "#define %0%1GetConstructorCallback() (%0%1ConstructorCallback)\n",