378 lines
7.4 KiB
C
378 lines
7.4 KiB
C
#include <assert.h>
|
|
#include "../utils/defs.h"
|
|
#include "objects.h"
|
|
|
|
static _Bool op_eql(Object *self, Object *other);
|
|
|
|
TypeObject t_type = {
|
|
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
|
|
.name = "type",
|
|
.size = sizeof (TypeObject),
|
|
.op_eql = op_eql,
|
|
};
|
|
|
|
static _Bool op_eql(Object *self, Object *other)
|
|
{
|
|
return self == other;
|
|
}
|
|
|
|
const char *Object_GetName(const Object *obj)
|
|
{
|
|
assert(obj != NULL);
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
const char *name = type->name;
|
|
assert(name);
|
|
|
|
return name;
|
|
}
|
|
|
|
const TypeObject *Object_GetType(const Object *obj)
|
|
{
|
|
assert(obj != NULL);
|
|
assert(obj->type != NULL);
|
|
return obj->type;
|
|
}
|
|
|
|
unsigned int Object_GetSize(const Object *obj, Error *err)
|
|
{
|
|
assert(err != NULL);
|
|
assert(obj != NULL);
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
return type->size;
|
|
}
|
|
|
|
unsigned int Object_GetDeepSize(const Object *obj, Error *err)
|
|
{
|
|
assert(err != NULL);
|
|
assert(obj != NULL);
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
if(type->deepsize == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(obj), __func__);
|
|
return 0;
|
|
}
|
|
|
|
return type->deepsize(obj);
|
|
}
|
|
|
|
int Object_Hash(Object *obj)
|
|
{
|
|
assert(obj != NULL);
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type != NULL);
|
|
assert(type->hash != NULL);
|
|
return type->hash(obj);
|
|
}
|
|
|
|
Object *Object_Copy(Object *obj, Heap *heap, Error *err)
|
|
{
|
|
assert(err != NULL);
|
|
assert(obj != NULL);
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type != NULL);
|
|
|
|
if(type->copy == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(obj), __func__);
|
|
return NULL;
|
|
}
|
|
|
|
return type->copy(obj, heap, err);
|
|
}
|
|
|
|
Object *Object_Call(Object *obj, Object **argv, unsigned int argc, Heap *heap, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(obj);
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
if(type->call == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(obj), __func__);
|
|
return NULL;
|
|
}
|
|
|
|
return type->call(obj, argv, argc, heap, err);
|
|
}
|
|
|
|
void Object_Print(Object *obj, FILE *fp)
|
|
{
|
|
assert(obj != NULL);
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
if(type->print == NULL)
|
|
fprintf(fp, "<%s is unprintable>", Object_GetName(obj));
|
|
else
|
|
type->print(obj, fp);
|
|
}
|
|
|
|
Object *Object_Select(Object *coll, Object *key, Heap *heap, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(key);
|
|
assert(coll);
|
|
|
|
const TypeObject *type = Object_GetType(coll);
|
|
assert(type);
|
|
|
|
if(type->select == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(coll), __func__);
|
|
return NULL;
|
|
}
|
|
|
|
return type->select(coll, key, heap, err);
|
|
}
|
|
|
|
Object *Object_Delete(Object *coll, Object *key, Heap *heap, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(key);
|
|
assert(coll);
|
|
|
|
const TypeObject *type = Object_GetType(coll);
|
|
assert(type);
|
|
|
|
if(type->delete == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(coll), __func__);
|
|
return NULL;
|
|
}
|
|
|
|
return type->delete(coll, key, heap, err);
|
|
}
|
|
|
|
_Bool Object_Insert(Object *coll, Object *key, Object *val, Heap *heap, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(key);
|
|
assert(coll);
|
|
|
|
const TypeObject *type = Object_GetType(coll);
|
|
assert(type);
|
|
|
|
if(type->insert == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(coll), __func__);
|
|
return 0;
|
|
}
|
|
|
|
return type->insert(coll, key, val, heap, err);
|
|
}
|
|
|
|
int Object_Count(Object *coll, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(coll);
|
|
|
|
const TypeObject *type = Object_GetType(coll);
|
|
assert(type);
|
|
|
|
if(type->count == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(coll), __func__);
|
|
return -1;
|
|
}
|
|
|
|
return type->count(coll);
|
|
}
|
|
|
|
Object *Object_Next(Object *iter, Heap *heap, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(iter);
|
|
|
|
const TypeObject *type = Object_GetType(iter);
|
|
assert(type);
|
|
|
|
if(type->next == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(iter), __func__);
|
|
return NULL;
|
|
}
|
|
|
|
return type->next(iter, heap, err);
|
|
}
|
|
|
|
Object *Object_Prev(Object *iter, Heap *heap, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(iter);
|
|
|
|
const TypeObject *type = Object_GetType(iter);
|
|
assert(type);
|
|
|
|
if(type->prev == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(iter), __func__);
|
|
return NULL;
|
|
}
|
|
|
|
return type->prev(iter, heap, err);
|
|
}
|
|
|
|
_Bool Object_IsInt(Object *obj)
|
|
{
|
|
assert(obj != NULL);
|
|
assert(obj->type != NULL);
|
|
return obj->type->atomic == ATMTP_INT;
|
|
}
|
|
|
|
_Bool Object_IsBool(Object *obj)
|
|
{
|
|
assert(obj != NULL);
|
|
assert(obj->type != NULL);
|
|
return obj->type->atomic == ATMTP_BOOL;
|
|
}
|
|
|
|
_Bool Object_IsFloat(Object *obj)
|
|
{
|
|
assert(obj != NULL);
|
|
assert(obj->type != NULL);
|
|
return obj->type->atomic == ATMTP_FLOAT;
|
|
}
|
|
|
|
_Bool Object_IsString(Object *obj)
|
|
{
|
|
assert(obj != NULL);
|
|
assert(obj->type != NULL);
|
|
return obj->type->atomic == ATMTP_STRING;
|
|
}
|
|
|
|
long long int Object_ToInt(Object *obj, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(obj);
|
|
|
|
if(!Object_IsInt(obj))
|
|
{
|
|
Error_Report(err, 0, "Object is not an integer");
|
|
return 0;
|
|
}
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
if(type->to_int == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(obj), __func__);
|
|
return 0;
|
|
}
|
|
|
|
return type->to_int(obj, err);
|
|
}
|
|
|
|
_Bool Object_ToBool(Object *obj, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(obj);
|
|
|
|
if(!Object_IsBool(obj))
|
|
{
|
|
Error_Report(err, 0, "Object is not a boolean");
|
|
return 0;
|
|
}
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
if(type->to_bool == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(obj), __func__);
|
|
return 0;
|
|
}
|
|
|
|
return type->to_bool(obj, err);
|
|
}
|
|
|
|
double Object_ToFloat(Object *obj, Error *err)
|
|
{
|
|
assert(err);
|
|
assert(obj);
|
|
|
|
if(!Object_IsFloat(obj))
|
|
{
|
|
Error_Report(err, 0, "Object is not a floating");
|
|
return 0;
|
|
}
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
if(type->to_float == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(obj), __func__);
|
|
return 0;
|
|
}
|
|
|
|
return type->to_float(obj, err);
|
|
}
|
|
|
|
const char *Object_ToString(Object *obj, int *size, Heap *heap, Error *err)
|
|
{
|
|
assert(err != NULL);
|
|
assert(obj != NULL);
|
|
|
|
if(!Object_IsString(obj))
|
|
{
|
|
Error_Report(err, 0, "Object is not a string");
|
|
return NULL;
|
|
}
|
|
|
|
const TypeObject *type = Object_GetType(obj);
|
|
assert(type);
|
|
|
|
if(type->to_string == NULL)
|
|
{
|
|
Error_Report(err, 0, "Object %s doesn't implement %s", Object_GetName(obj), __func__);
|
|
return NULL;
|
|
}
|
|
|
|
return type->to_string(obj, size, heap, err);
|
|
}
|
|
|
|
_Bool Object_Compare(Object *obj1, Object *obj2, Error *error)
|
|
{
|
|
assert(obj1 != NULL);
|
|
assert(obj2 != NULL);
|
|
assert(error != NULL);
|
|
|
|
if(obj1->type != obj2->type)
|
|
return 0;
|
|
|
|
if(obj1->type->op_eql == NULL)
|
|
{
|
|
Error_Report(error, 0, "Object %s doesn't implement %s", Object_GetName(obj1), __func__);
|
|
return 0;
|
|
}
|
|
|
|
return obj1->type->op_eql(obj1, obj2);
|
|
}
|
|
|
|
void Object_WalkReferences(Object *parent, void (*callback)(Object **referer, void *userp), void *userp)
|
|
{
|
|
assert(parent != NULL);
|
|
if(parent->type->walk != NULL)
|
|
parent->type->walk(parent, callback, userp);
|
|
}
|
|
|
|
void Object_WalkExtensions(Object *parent, void (*callback)(void **referer, unsigned int size, void *userp), void *userp)
|
|
{
|
|
assert(parent != NULL);
|
|
if(parent->type->walkexts != NULL)
|
|
parent->type->walkexts(parent, callback, userp);
|
|
} |