dvgenc.c

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

    dvWrtemp(dvFile, "}\n\n");
}

/*--------------------------------------------------------------------------------------------------
  Write out the reallocation stuff for a class.
--------------------------------------------------------------------------------------------------*/
static void writeClassReallocs(
    dvClass theClass)
{
    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Realloc the arrays of properties for class %0.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "static void realloc%0s(\n"
        "    %1 newSize)\n"
        "{\n",
        dvClassGetName(theClass), dvClassGetReferenceTypeName(theClass));
    writeClassPropFieldReallocs(theClass);
    dvWrtemp(dvFile,
        "    %0SetAllocated%1(newSize);\n"
        "}\n\n",
        dvPrefix, dvClassGetName(theClass));
}

/*--------------------------------------------------------------------------------------------------
  Write the database stop routine.
--------------------------------------------------------------------------------------------------*/
static void writeStop(
    dvModule module)
{
    dvClass theClass;

    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Free memory used by the %0 database.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "void %0DatabaseStop(void)\n{\n",
        dvPrefix);
    dvForeachModuleClass(module, theClass) {
        writeClassPropFieldFrees(theClass);
        if(dvClassGetBaseClass(theClass) != dvClassNull) {
            dvWrtemp(dvFile,
                "    %2%1SetConstructorCallback(%0%1ConstructorCallback);\n"
                "    %0%1ConstructorCallback = NULL;\n",
                dvPrefix, dvClassGetName(theClass), dvClassGetPrefix(theClass));
            if(dvClassGetMemoryStyle(theClass) == MEM_FREE_LIST) {
                dvWrtemp(dvFile,
                    "    if(%2%1GetDestructorCallback() != destroy%1) {\n"
                    "        utExit(\"%0DatabaseClose called out of order\");\n"
                    "    }\n"
                    "    %2%1SetDestructorCallback(%0%1DestructorCallback);\n"
                    "    %0%1DestructorCallback = NULL;\n",
                    dvPrefix, dvClassGetName(theClass), dvClassGetPrefix(theClass));
            }
        }
    } dvEndForeachModuleClass;
    dvWrtemp(dvFile,
        "    utUnregisterModule(%0ModuleID);\n"
        "}\n\n",
        dvPrefix);
}

/*--------------------------------------------------------------------------------------------------
  Write code to register this module's fields so that changes can be mirrored to disk.
--------------------------------------------------------------------------------------------------*/
static void writeRegisterFields(
    dvModule module)
{
    dvClass theClass;
    dvUnion theUnion;
    dvCase theCase;
    dvEnum theEnum;
    dvEntry entry;
    dvProperty property;

    dvWrtemp(dvFile,
        "    %0ModuleID = utRegisterModule(\"%0\", %0Hash(), %1, sizeof(struct %0RootType_),\n"
        "        &%0RootData, %0DatabaseStart, %0DatabaseStop);\n",
        dvPrefix, utSprintf("%u, %u, %u", dvModuleGetNumClasses(module), dvModuleGetNumFields(module),
        dvModuleGetNumEnums(module)));
    dvForeachModuleEnum(module, theEnum) {
        dvWrtemp(dvFile,
            "    utRegisterEnum(\"%0\", %1);\n",
            dvEnumGetName(theEnum), utSprintf("%u", dvEnumGetNumEntries(theEnum)));
        dvForeachEnumEntry(theEnum, entry) {
            dvWrtemp(dvFile,
                "    utRegisterEntry(\"%0\", %1);\n",
                dvEntryGetName(entry), utSprintf("%u", dvEntryGetValue(entry)));
        } dvEndForeachEnumEntry;
    } dvEndForeachModuleEnum;
    dvForeachModuleClass(module, theClass) {
        dvWrtemp(dvFile,
            "    utRegisterClass(\"%1\", %3, &%2RootData.used%1, &%2RootData.allocated%1,\n",
            dvModuleGetPrefix(module), dvClassGetName(theClass), dvClassGetPrefix(theClass),
            utSprintf("%u", dvClassGetNumFields(theClass)));
        if(dvClassGetMemoryStyle(theClass) == MEM_FREE_LIST) {
            dvWrtemp(dvFile,
                "        &%1RootData.firstFree%0, ",
                dvClassGetName(theClass), dvClassGetPrefix(theClass));
        } else {
            dvWrtemp(dvFile, "        NULL, ");
        }
        dvWrtemp(dvFile,
            "%0, %1, ",
            utSprintf("%u", dvPropertyGetFieldNumber(dvClassGetFreeListProperty(theClass))),
            utSprintf("%u", dvClassGetReferenceSize(theClass) >> 3));
        if(dvClassGetBaseClass(theClass) == dvClassNull) {
            dvWrtemp(dvFile, "alloc%0, ", dvClassGetName(theClass));
            if(dvClassGetMemoryStyle(theClass) != MEM_CREATE_ONLY) {
                dvWrtemp(dvFile, "destroy%0);\n", dvClassGetName(theClass));
            } else {
                dvWrtemp(dvFile, "NULL);\n");
            }
        } else {
            dvWrtemp(dvFile, "NULL, NULL);\n");
        }
        dvForeachClassProperty(theClass, property) {
            if(dvPropertyGetUnion(property) == dvUnionNull) {
                dvWrtemp(dvFile,
                    "    utRegisterField(\"%2\", &%0%1s.%2, sizeof(%3), %4,",
                    dvModuleGetPrefix(module), dvClassGetName(theClass),
                    dvPropertyGetName(property), dvPropertyGetTypeName(property),
                    dvPropertyGetFieldTypeName(property));
                if(dvPropertyGetType(property) == PROP_POINTER) {
                    dvWrtemp(dvFile, " \"%0\");\n", dvClassGetName(dvPropertyGetClassProp(property)));
                } else if(dvPropertyGetType(property) == PROP_ENUM) {
                    dvWrtemp(dvFile, " \"%0\");\n", dvEnumGetName(dvPropertyGetEnumProp(property)));
                } else {
                    dvWrtemp(dvFile, " NULL);\n");
                }
                if(dvPropertyArray(property)) {
                    dvWrtemp(dvFile,
                        "    utRegisterArray(&%0RootData.used%1%2, &%0RootData.allocated%1%2,\n"
                        "        get%1%2s, alloc%1%2s);\n",
                        dvPrefix, dvClassGetName(theClass), dvPropertyGetName(property),
                        utSprintf("%u", dvPropertyGetFieldNumber(property)));
                }
                if(dvPropertyHidden(property)) {
                    dvWrtemp(dvFile, "    utSetFieldHidden();\n");
                }
            }
        } dvEndForeachClassProperty;
        dvForeachClassUnion(theClass, theUnion) {
            property = dvUnionGetTypeProperty(theUnion);
            dvWrtemp(dvFile,
                "    utRegisterField(\"%2\", &%0%1s.%2, sizeof(%3), UT_UNION, \"%4\");\n"
                "    utRegisterUnion(\"%4\", %5);\n",
                dvModuleGetPrefix(module), dvClassGetName(theClass), dvUnionGetFieldName(theUnion),
                dvUnionGetTypeName(theUnion), dvPropertyGetName(property),
                utSprintf("%u", dvUnionGetNumCases(theUnion)));
            dvForeachUnionProperty(theUnion, property) {
                dvForeachPropertyCase(property, theCase) {
                    entry = dvCaseGetEntry(theCase);
                    dvWrtemp(dvFile,
                        "    utRegisterUnionCase(%0, %1, sizeof(%2));\n",
                        utSprintf("%u", dvEntryGetValue(entry)), dvPropertyGetFieldTypeName(property),
                        dvPropertyGetTypeName(property));
                } dvEndForeachPropertyCase;
            } dvEndForeachUnionProperty;
        } dvEndForeachClassUnion;
    } dvEndForeachModuleClass;
}

/*--------------------------------------------------------------------------------------------------
  Write the database initialization routine.
--------------------------------------------------------------------------------------------------*/
static void writeStart(
    dvModule module)
{
    dvClass theClass;

    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Allocate memory used by the %0 database.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "void %0DatabaseStart(void)\n{\n"
        "    if(!utInitialized()) {\n"
        "        utStart();\n"
        "    }\n"
        "    %0RootData.hash = %1;\n",
        dvPrefix, utSprintf("0x%x", dvComputeDatabaseHash()));
    writeRegisterFields(module);
    dvForeachModuleClass(module, theClass) {
        dvWrtemp(dvFile, "    alloc%0s();\n", dvClassGetName(theClass));
    } dvEndForeachModuleClass;
    dvWrtemp(dvFile, "}\n\n");
}

/*--------------------------------------------------------------------------------------------------
  Write the function to allocate more objects of the class.
--------------------------------------------------------------------------------------------------*/
static void writeClassAllocateMore(
    dvClass theClass)
{
    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Allocate more %1s.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "void %0%1AllocMore(void)\n"
        "{\n"
        "    realloc%1s(%2Allocated%1() + (%2Allocated%1() >> 1));\n"
        "}\n\n",
        dvPrefix, dvClassGetName(theClass), dvClassGetPrefix(theClass));
}

/*--------------------------------------------------------------------------------------------------
  Write the init function for local fields of an object.
--------------------------------------------------------------------------------------------------*/
static void writeExtendedClassInitFunc(
    dvClass theClass)
{
    dvWrtemp(dvFile, 
        "static void realloc%1s(%3 newSize);\n"
        "/*----------------------------------------------------------------------------------------\n"
        "  Initialize a new %1.  This is a constructor callback from the base class.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "static void init%1(\n"
        "    %2%1 %1)\n"
        "{\n"
        "    if(%0Allocated%1() != %2Allocated%1()) {\n"
        "        realloc%1s(%2Allocated%1());\n"
        "    }\n"
        "    %0%1Init(%1);\n"
        "    if(%0%1ConstructorCallback != NULL) {\n"
        "        %0%1ConstructorCallback(%1);\n"
        "    }\n"
        "}\n\n",
        dvPrefix, dvClassGetName(theClass), dvClassGetPrefix(theClass), dvClassGetReferenceTypeName(theClass));
}

/*--------------------------------------------------------------------------------------------------
  Write simple constructor/destructor wrapper functions for the database manager's use.
--------------------------------------------------------------------------------------------------*/
static void writeConstructorDestructorWrappers(
    dvClass theClass)
{
    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Default constructor wrapper for the database manager.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "static uint64 alloc%1(void)\n"
        "{\n"
        "    %0%1 %1 = %0%1Alloc();\n"
        "\n"
        "    return %0%12Index(%1);\n"
        "}\n\n",
        dvPrefix, dvClassGetName(theClass));
    if(dvClassGetMemoryStyle(theClass) != MEM_CREATE_ONLY) {
        dvWrtemp(dvFile, 
            "/*-----------------------------------------------------"
            "-----------------------------------\n"
            "  Destructor wrapper for the database manager.\n"
            "-------------------------------------------------------"
            "---------------------------------*/\n"
            "static void destroy%1(\n"
            "    uint64 objectIndex)\n"
            "{\n"
            "    %0%1Destroy(%0Index2%1(objectIndex));\n"
            "}\n\n" ,
            dvPrefix, dvClassGetName(theClass));
    }
}

/*--------------------------------------------------------------------------------------------------
  Write a function to compact a property array.
--------------------------------------------------------------------------------------------------*/
static void writeArrayCompact(
    dvProperty property)
{
    dvClass theClass = dvPropertyGetClass(property);

    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Compact the %1.%2 heap to free memory.\n"
        "----------------------------------------------------------------------------------------*/\n"
        "void %0Compact%1%2s(void)\n"
        "{\n"
        "    uint32 elementSize = sizeof(%4);\n"
        "    uint32 usedHeaderSize = (sizeof(%3%1) + elementSize - 1)/elementSize;\n"
        "    uint32 freeHeaderSize = (sizeof(%3%1) + sizeof(uint32) + elementSize - 1)/elementSize;\n"
        "    %4 *toPtr = %0%1s.%2;\n"
        "    %4 *fromPtr = toPtr;\n"
        "    %3%1 %1;\n"
        "    uint32 size;\n"
        "\n"