dvutil.c

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

    case PROP_BIT: return "UT_BIT";
    case PROP_BOOL: return "UT_BOOL";
    case PROP_CHAR: return "UT_CHAR";
    case PROP_SYM: return "UT_SYM";
    case PROP_ENUM: return "UT_ENUM";
    case PROP_TYPEDEF: return "UT_TYPEDEF";
    case PROP_POINTER: return "UT_POINTER";
    default:
        utExit("Unknown property type");
    }
    return NULL; /* Dummy return */
}

/*--------------------------------------------------------------------------------------------------
  Find a hash summary of the enumerated type.
--------------------------------------------------------------------------------------------------*/
static uint32 findEnumHash(
    dvEnum theEnum)
{
    dvEntry entry;
    uint32 hash;

    utStartHash();
    utHashSym(dvEnumGetSym(theEnum));
    utHashSym(dvEnumGetPrefixSym(theEnum));
    hash = utHashValue;
    dvForeachEnumEntry(theEnum, entry) {
        hash ^= utSymGetHashValue(dvEntryGetSym(entry));
    } dvEndForeachEnumEntry;
    return hash;
}

/*--------------------------------------------------------------------------------------------------
  Find a hash signature for the class.
--------------------------------------------------------------------------------------------------*/
static uint32 findPropertyHash(
    dvProperty property)
{
    utStartHash();
    utHashSym(dvPropertyGetSym(property));
    utHashUint32(dvPropertyGetType(property));
    utHashBool(dvPropertyArray(property));
    switch(dvPropertyGetType(property)) {
    case PROP_INT:
    case PROP_UINT:
        utHashUint8(dvPropertyGetWidth(property));
        break;
    case PROP_FLOAT:
    case PROP_DOUBLE:
    case PROP_BIT:
    case PROP_BOOL:
    case PROP_CHAR:
    case PROP_SYM:
        break;
    case PROP_ENUM:
        utHashSym(dvEnumGetSym(dvPropertyGetEnumProp(property)));
        break;
    case PROP_TYPEDEF:
        utHashSym(dvTypedefGetSym(dvPropertyGetTypedefProp(property)));
        break;
    case PROP_POINTER:
        utHashSym(dvClassGetSym(dvPropertyGetClassProp(property)));
        break;
    default:
        utExit("Unknown property type");
    }
    return utHashValue;
}

/*--------------------------------------------------------------------------------------------------
  Find a hash signature for the union.
--------------------------------------------------------------------------------------------------*/
static uint32 findUnionHash(
    dvUnion theUnion)
{
    dvProperty property;
    uint32 hash = 0;

    dvForeachUnionProperty(theUnion, property) {
        hash ^= utSymGetHashValue(dvPropertyGetSym(property));
    } dvEndForeachUnionProperty;
    return hash;
}

/*--------------------------------------------------------------------------------------------------
  Find a hash signature for the relationship.
--------------------------------------------------------------------------------------------------*/
static uint32 findRelationshipHash(
    dvRelationship relationship)
{
    utStartHash();
    utHashSym(dvClassGetSym(dvRelationshipGetParentClass(relationship)));
    utHashSym(dvClassGetSym(dvRelationshipGetChildClass(relationship)));
    utHashUint32(dvRelationshipGetType(relationship));
    utHashSym(dvRelationshipGetParentLabelSym(relationship));
    utHashSym(dvRelationshipGetChildLabelSym(relationship));
    utHashBool(dvRelationshipMandatory(relationship));
    utHashBool(dvRelationshipCascade(relationship));
    utHashBool(dvRelationshipAccessChild(relationship));
    utHashBool(dvRelationshipAccessParent(relationship));
    return utHashValue;
}

/*--------------------------------------------------------------------------------------------------
  Find a hash signature for the class.
--------------------------------------------------------------------------------------------------*/
static uint32 findClassHash(
    dvClass theClass)
{
    dvProperty property;
    dvUnion theUnion;
    dvRelationship relationship;
    uint32 hash;

    utStartHash();
    utHashSym(dvClassGetSym(theClass));
    if(dvClassGetBaseClass(theClass) != dvClassNull) {
        utHashSym(dvClassGetSym(dvClassGetBaseClass(theClass)));
    }
    utHashUint32(dvClassGetMemoryStyle(theClass));
    utHashUint8(dvClassGetReferenceSize(theClass));
    hash = utHashValue;
    dvForeachClassProperty(theClass, property) {
        hash ^= findPropertyHash(property);
    } dvEndForeachClassProperty;
    dvForeachClassUnion(theClass, theUnion) {
        hash ^= findUnionHash(theUnion);
    } dvEndForeachClassUnion;
    dvForeachClassChildRelationship(theClass, relationship) {
        hash ^= findRelationshipHash(relationship);
    } dvEndForeachClassChildRelationship;
    return hash;
}

/*--------------------------------------------------------------------------------------------------
  Find a hash summary of the entire module.
--------------------------------------------------------------------------------------------------*/
static uint32 findModuleHash(
    dvModule module)
{
    dvEnum theEnum;
    dvClass theClass;
    dvTypedef theTypedef;
    uint32 hash;

    utStartHash();
    utHashSym(dvModuleGetSym(module));
    utHashBool(dvModulePersistent(module));
    utHashSym(dvModuleGetPrefixSym(module));
    hash = utHashValue;
    dvForeachModuleEnum(module, theEnum) {
        hash ^= findEnumHash(theEnum);
    } dvEndForeachModuleEnum;
    dvForeachModuleTypedef(module, theTypedef) {
        hash ^= utSymGetHashValue(dvTypedefGetSym(theTypedef));
    } dvEndForeachModuleTypedef;
    dvForeachModuleClass(module, theClass) {
        hash ^= findClassHash(theClass);
    } dvEndForeachModuleClass;
    return hash;
}

/*--------------------------------------------------------------------------------------------------
  Compute a hash value that depends on every aspect of the database.  Two databases with the same
  hash value should be 100% compatible.
--------------------------------------------------------------------------------------------------*/
uint32 dvComputeDatabaseHash(void)
{
    dvModule module;
    uint32 hash = 0;

    dvForeachRootModule(dvTheRoot, module) {
        hash ^= findModuleHash(module);
    } dvEndForeachRootModule;
    return hash;
}

/*--------------------------------------------------------------------------------------------------
  Find the module prefix to use for the class.  It is the prefix of the base class, if defined,
  otherwise the prefix of the owning module.
--------------------------------------------------------------------------------------------------*/
char *dvClassGetPrefix(
    dvClass theClass)
{
    dvClass baseClass;

    utDo {
        baseClass = dvClassGetBaseClass(theClass);
    } utWhile(baseClass != dvClassNull) {
        theClass = baseClass;
    } utRepeat;
    return dvModuleGetPrefix(dvClassGetModule(theClass));
}

/*--------------------------------------------------------------------------------------------------
  Return a symbol with the same name, but the first letter capitalized.
--------------------------------------------------------------------------------------------------*/
utSym dvUpperSym(
    utSym sym)
{
    char *name = utCopyString(utSymGetName(sym));

    *name = toupper(*name);
    return utSymCreate(name);
}

/*--------------------------------------------------------------------------------------------------
  Return the format string for printing a property value.
--------------------------------------------------------------------------------------------------*/
char *dvFindPropertyFormatString(
    dvProperty property)
{
    switch(dvPropertyGetType(property)) {
    case PROP_INT: return "%d";
    case PROP_UINT: return "%u";
    case PROP_FLOAT: return "%g";
    case PROP_DOUBLE: return "%g";
    case PROP_BIT: return "%u";
    case PROP_BOOL: return "%u";
    case PROP_CHAR:
        if(dvPropertyArray(property)) {
            return "\\\"%s\\\"";
        }
        return "%c";
    case PROP_SYM: return "0x%x \\\"%s\\\"";
    case PROP_ENUM: return "%u";
    case PROP_TYPEDEF:
        return "???";
    case PROP_POINTER: return "0x%x";
    default:
        utExit("Unknown property type");
    }
    return NULL; /* Dummy return */
}

/*--------------------------------------------------------------------------------------------------
  Find the value to initialize a property, either "0", or "0xff".
--------------------------------------------------------------------------------------------------*/
char *dvPropertyFindInitValue(
    dvProperty property)
{
    switch(dvPropertyGetType(property)) {
    case PROP_INT:
    case PROP_UINT:
    case PROP_FLOAT:
    case PROP_DOUBLE:
    case PROP_BIT:
    case PROP_BOOL:
    case PROP_CHAR:
    case PROP_ENUM:
    case PROP_TYPEDEF:
        return "0";
    case PROP_SYM:
    case PROP_POINTER:
        return "0xff";
    default:
        utExit("Unknown property type");
    }
    return NULL; /* Dummy return */
}

/*--------------------------------------------------------------------------------------------------
  Just return a string representing the object reference type.
--------------------------------------------------------------------------------------------------*/
char *dvClassGetReferenceTypeName(
    dvClass theClass)
{
    return utSprintf("uint%u", dvClassGetReferenceSize(theClass));
}