dvgenh.c

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

        dvPrefix, name);
    if(dvClassGetMemoryStyle(theClass) == MEM_CREATE_ONLY) {
        dvWrtemp(dvFile,
            "#define %0First%1() (%0RootData.used%1 == 0? %0%1Null : %0Index2%1(0))\n"
            "#define %0Last%1() (%0RootData.used%1 == 0? %0%1Null : \\\n"
            "    %0Index2%1(%0RootData.used%1 - 1))\n"
            "#define %0Next%1(%1) (%0%12ValidIndex(%1) + 1 == %0RootData.used%1? %0%1Null : \\\n"
            "    (%1) + 1)\n"
            "#define %0Prev%1(%1) (%0%12ValidIndex(%1) == 0? %0%1Null : (%1) - 1)\n"
            "#define %0Foreach%1(var) \\\n"
            "    for(var = %0Index2%1(0); %0%12Index(var) != %0RootData.used%1; var++)\n"
            "#define %0EndForeach%1\n",
            dvPrefix, name, dvClassGetReferenceTypeName(theClass));
        dvWrtemp(dvFile, "#define %0%1FreeAll() (%0SetUsed%1(0)", dvPrefix, name);
        dvForeachClassProperty(theClass, prop) {
            if(dvPropertyArray(prop)) {
                dvWrtemp(dvFile, ", %0SetUsed%1%2(0)" , dvPrefix, name,
                dvPropertyGetName(prop));
            }
        } dvEndForeachClassProperty;
        dvWrtemp(dvFile, ")\n");
    } else if(dvClassGetMemoryStyle(theClass) == MEM_FREE_LIST) {
        prop = dvClassGetFreeListProperty(theClass);
        dvWrtemp(dvFile,
            "#define %0%1SetDestructorCallback(func) (%0%1DestructorCallback = (func))\n"
            "#define %0%1GetDestructorCallback() (%0%1DestructorCallback)\n",
            dvPrefix, name);
        dvWrtemp(dvFile,
            "#define %0%1NextFree(_%1) (((%0%1 *)(void *)(%0%1s.%3))[%2%12ValidIndex(_%1)])\n",
            dvPrefix, name, dvClassGetPrefix(theClass), dvPropertyGetName(prop));
        preString = dvSwrtemp(!dvClassUndo(theClass)? "" :
            " \\\n    (void)utRecordField(%0ModuleID, %3, %2%12ValidIndex(%1), true), \\\n    ",
            dvPrefix, name, dvClassGetPrefix(theClass),
            utSprintf("%u", dvPropertyGetFieldNumber(prop)));
        postString = dvSwrtemp(!dvClassRedo(theClass)? "" :
            ", \\\n    (void)utRecordField(%0ModuleID, %3, %2%12ValidIndex(%1), false)",
            dvPrefix, name, dvClassGetPrefix(theClass),
            utSprintf("%u", dvPropertyGetFieldNumber(prop)));
        dvWrtemp(dvFile,
            "#define %0%1SetNextFree(%1, value) (%4((%0%1 *)(void *)(%0%1s.%3)) \\\n"
            "    [%2%12ValidIndex(%1)] = (value)%5)\n",
            dvPrefix, name, dvClassGetPrefix(theClass), dvPropertyGetName(prop),
            preString, postString);
    }
}

/*--------------------------------------------------------------------------------------------------
  Write all the access/modify macros for theClass.
--------------------------------------------------------------------------------------------------*/
static void writeClassMacros(
    dvClass theClass)
{
    writeClassPropMacros(theClass);
    writeClassChildRelMacros(theClass);
    if(dvClassGetBaseClass(theClass) == dvClassNull) {
        writeClassMiscMacros(theClass);
        writeClassCreateMacro(theClass);
    } else {
        writeClassInitMacro(theClass);
    }
}

/*--------------------------------------------------------------------------------------------------
  Check to see if Typedef section is needed for this tool.
--------------------------------------------------------------------------------------------------*/
static bool needTypedefSection(
    dvModule module)
{
    dvClass theClass;

    dvForeachModuleClass(module, theClass) {
        if(dvClassGetBaseClass(theClass) == dvClassNull) {
            return true;
        }
    } dvEndForeachModuleClass;
    return false;
}

/*--------------------------------------------------------------------------------------------------
  Write the type definitions for handles to objects.
--------------------------------------------------------------------------------------------------*/
static void writeTypedefs(
    dvModule module)
{
    dvClass theClass;
    
    dvWrtemp(dvFile,
        "/* Class reference definitions */\n\n"
        "#if defined(DD_DEBUG)\n", dvFile);
    dvForeachModuleClass(module, theClass) {
        if(dvClassGetBaseClass(theClass) == dvClassNull) {
            dvWrtemp(dvFile, 
                "typedef struct _struct_%0%1{char val;} *%0%1;\n" 
                "#define %0%1Null ((%0%1)(%c3_MAX))\n"
                "#define %0%12Index(%1) ((uint32)((%1) - (%0%1)(0)))\n"
                "#define %0%12ValidIndex(%1) ((uint32)(%0Valid%1(%1) - (%0%1)(0)))\n"
                "#define %0Index2%1(x%1) ((%0%1)((x%1) + (%0%1)(0)))\n", 
                dvPrefix, dvClassGetName(theClass), dvClassGetReferenceTypeName(theClass),
                dvClassGetReferenceTypeName(theClass));
        }
    } dvEndForeachModuleClass;
    fputs("#else\n", dvFile);
    dvForeachModuleClass(module, theClass) {
        if(dvClassGetBaseClass(theClass) == dvClassNull) {
            dvWrtemp(dvFile, "typedef %2 %0%1;\n"
                "#define %0%1Null %c3_MAX\n"
                "#define %0%12Index(%1) (%1)\n"
                "#define %0%12ValidIndex(%1) (%0Valid%1(%1))\n"
                "#define %0Index2%1(x%1) ((x%1))\n",
                dvClassGetPrefix(theClass), dvClassGetName(theClass),
                dvClassGetReferenceTypeName(theClass),
                dvClassGetReferenceTypeName(theClass));
        }
    } dvEndForeachModuleClass;
    fputs("#endif\n\n", dvFile);
}

/*--------------------------------------------------------------------------------------------------
  Write macros for validating object references.
--------------------------------------------------------------------------------------------------*/
static void writeValidateMacros(
    dvModule module)
{
    dvClass theClass;
    
    dvWrtemp(dvFile, "/* Validate macros */\n");
    fputs("#if defined(DD_DEBUG)\n", dvFile);
    dvForeachModuleClass(module, theClass) {
        if(dvClassGetBaseClass(theClass) == dvClassNull) {
            dvWrtemp(dvFile,
                "#define %0Valid%1(%1) (utLikely((uint32)((%1) - (%0%1)0) < \\\n"
                "    %0RootData.used%1)? (%1) : (utExit(\"Invalid %1\"), (%0%1)0))\n",
                dvPrefix, dvClassGetName(theClass));
        }
    } dvEndForeachModuleClass;
    fputs("#else\n", dvFile);
    dvForeachModuleClass(module, theClass) {
        if(dvClassGetBaseClass(theClass) == dvClassNull) {
            dvWrtemp(dvFile, 
                "#define %0Valid%1(%1) (%1)\n",
                dvClassGetPrefix(theClass), dvClassGetName(theClass),
                dvClassGetReferenceTypeName(theClass));
        }
    } dvEndForeachModuleClass;
    fputs("#endif\n\n", dvFile);
}

/*--------------------------------------------------------------------------------------------------
  Write the enumerated types.
--------------------------------------------------------------------------------------------------*/
static void writeEnms(
    dvModule module)
{
    dvEnum theEnum;
    dvEntry entry;
    
    dvForeachModuleEnum(module, theEnum) {
        dvWrtemp(dvFile, "/* %0 enumerated type */\n", dvEnumGetName(theEnum));
        fputs("typedef enum {\n", dvFile);
        dvForeachEnumEntry(theEnum, entry) {
            dvWrtemp(dvFile,
                "    %0%1",
                utSymGetName(dvEnumGetPrefixSym(theEnum)), dvEntryGetName(entry));
            if(dvEntryGetNextEnumEntry(entry) != dvEntryNull) {
                fprintf(dvFile, " = %u,\n", dvEntryGetValue(entry));
            } else {
                fprintf(dvFile, " = %u\n", dvEntryGetValue(entry));
            }
        } dvEndForeachEnumEntry;
        dvWrtemp(dvFile, "} %0%1;\n\n", dvPrefix, dvEnumGetName(theEnum));
    } dvEndForeachModuleEnum;
}

/*--------------------------------------------------------------------------------------------------
  Write the header's top portion.
--------------------------------------------------------------------------------------------------*/
static void writeHeaderTop(
    dvModule module)
{
    dvLink link;
    bool hasHeader = false;

    dvWrtemp(dvFile, 
        "/*----------------------------------------------------------------------------------------\n"
        "  Module header file for: %0 module\n"
        "----------------------------------------------------------------------------------------*/\n"
        "#ifndef %c0DATABASE_H\n\n"
        "#define %c0DATABASE_H\n\n"
        "#if defined __cplusplus\n"
        "extern \"C\" {\n"
        "#endif\n\n"
        "#ifndef DD_UTIL_H\n"
        "#include \"ddutil.h\"\n"
        "#endif\n\n",
        dvPrefix);
    if(dvModuleGetFirstTypedef(module) != dvTypedefNull) {
        dvWrtemp(dvFile, 
            "#include \"%0typedef.h\"\n",
            dvPrefix);
        hasHeader = true;
    }
    dvForeachModuleImportLink(module, link) {
        dvWrtemp(dvFile, 
            "#include \"%0database.h\"\n",
            dvModuleGetPrefix(dvLinkGetExportModule(link)));
        hasHeader = true;
    } dvEndForeachModuleImportLink;
    if(hasHeader) {
        dvWrtemp(dvFile, "\n");
    }
}

/*--------------------------------------------------------------------------------------------------
  Write the overall types in tool including enums.
--------------------------------------------------------------------------------------------------*/
static void writeTypes(
    dvModule module)
{
    if(needTypedefSection(module)) {
        writeTypedefs(module);
    }
    writeEnms(module);
}

/*--------------------------------------------------------------------------------------------------
  Write the header file.
--------------------------------------------------------------------------------------------------*/
void dvWriteHeaderFile(
    dvModule module,
    char *includeFile)
{
    dvClass theClass;
    char *fileName = includeFile;
    
    if(utDirectoryExists(includeFile)) {
        fileName = utSprintf("%s%c%sdatabase.h", includeFile, UTDIRSEP,
            dvModuleGetPrefix(module));
    }
    dvFile = fopen(fileName, "wt");
    if(dvFile == NULL) {
        utError("Could not open file %s", fileName);
        return;
    }
    utLogMessage("Generating header file %s", fileName);
    dvPrefix = dvModuleGetPrefix(module);
    writeHeaderTop(module);
    writeTypes(module);
    writeValidateMacros(module);
    dvForeachModuleClass(module, theClass) {
        writeUnionTypes(theClass);
        writeClassStruct(theClass);
        writeClassMacros(theClass);
        writeClassExternFuncs(theClass);
    } dvEndForeachModuleClass;
    writeTempUnion(module);
    writeConstructorDestructorVariables(module);
    writeRoot(module);
    writeHeaderBot(module);
    fclose(dvFile);
}