cozis/Noja
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

general cleanups. Removed lots of unused code and redundant error checks

Browse Source
This commit is contained in:
Francesco Cozzuto
2022-08-24 16:46:32 +02:00
parent 71e8a9e4cb
commit cd74dda4a9
29 changed files with 333 additions and 813 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/objects/o_bool.c
+9 -9
View File
@@ -32,7 +32,6 @@
#include "objects.h"
#include "../utils/defs.h"
static _Bool to_bool(Object *obj, Error *err);
static void print(Object *obj, FILE *fp);
static _Bool op_eql(Object *self, Object *other);
static int hash(Object *self);
@@ -41,11 +40,9 @@ static Object *copy(Object *self, Heap *heap, Error *err);
static TypeObject t_bool = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "bool",
.size = sizeof (Object),
.atomic = ATMTP_BOOL,
.size = sizeof(Object),
.hash = hash,
.copy = copy,
.to_bool = to_bool,
.print = print,
.op_eql = op_eql,
};
@@ -89,12 +86,15 @@ static _Bool op_eql(Object *self, Object *other)
return self == other;
}
static _Bool to_bool(Object *obj, Error *err)
bool Object_GetBool(Object *obj)
{
UNUSED(err);
ASSERT(obj);
ASSERT(err);
ASSERT(Object_GetType(obj) == &t_bool);
if(!Object_IsBool(obj)) {
Error_Panic("%s expected a bool object, but "
"an %s was provided", __func__,
Object_GetName(obj));
return -1;
}
return obj == &the_true_object;
}
src/lib/objects/o_buffer.c
+73 -253
View File
@@ -34,17 +34,15 @@
#include "objects.h"
typedef struct {
Object base;
int size;
unsigned char *body;
} BufferObject;
size_t refs, size;
unsigned char body[];
} Payload;
typedef struct {
Object base;
BufferObject *sliced;
int offset,
length;
} BufferSliceObject;
Object base;
Payload *payload;
size_t offset, length;
} BufferObject;
static Object *buffer_select(Object *self, Object *key, Heap *heap, Error *err);
static _Bool buffer_insert(Object *self, Object *key, Object *val, Heap *heap, Error *err);
@@ -52,16 +50,10 @@ static int buffer_count(Object *self);
static void buffer_print(Object *obj, FILE *fp);
static _Bool buffer_free(Object *self, Error *error);
static Object *slice_select(Object *self, Object *key, Heap *heap, Error *err);
static _Bool slice_insert(Object *self, Object *key, Object *val, Heap *heap, Error *err);
static int slice_count(Object *self);
static void slice_print(Object *obj, FILE *fp);
static TypeObject t_buffer = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "buffer",
.size = sizeof (BufferObject),
.size = sizeof(BufferObject),
.select = buffer_select,
.insert = buffer_insert,
.count = buffer_count,
@@ -69,16 +61,6 @@ static TypeObject t_buffer = {
.free = buffer_free,
};
static TypeObject t_buffer_slice = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "buffer slice",
.size = sizeof (BufferSliceObject),
.select = slice_select,
.insert = slice_insert,
.count = slice_count,
.print = slice_print,
};
#define THRESHOLD 128
TypeObject *Object_GetBufferType()
@@ -88,44 +70,31 @@ TypeObject *Object_GetBufferType()
_Bool Object_IsBuffer(Object *obj)
{
return obj->type == &t_buffer_slice || obj->type == &t_buffer;
return Object_GetType(obj) == Object_GetBufferType();
}
Object *Object_NewBuffer(int size, Heap *heap, Error *error)
Object *Object_NewBuffer(size_t size, Heap *heap, Error *error)
{
ASSERT(size >= 0);
// Make the thing.
BufferObject *obj;
{
obj = (BufferObject*) Heap_Malloc(heap, &t_buffer, error);
Payload *payload = malloc(sizeof(Payload) + size);
if(payload == NULL)
{
Error_Report(error, 1, "No memory");
return NULL;
}
payload->refs = 1;
payload->size = size;
memset(payload->body, 0, size);
obj = (BufferObject*) Heap_Malloc(heap, &t_buffer, error);
if(obj == NULL)
return NULL;
unsigned char *body;
if(size > THRESHOLD)
{
body = malloc(sizeof(unsigned char) * size);
if(body == NULL)
{
Error_Report(error, 1, "No memory");
return NULL;
}
}
else
{
body = Heap_RawMalloc(heap, sizeof(unsigned char) * size, error);
if(body == NULL)
return NULL;
}
obj->size = size;
obj->body = body;
memset(obj->body, 0, size);
obj->payload = payload;
obj->offset = 0;
obj->length = size;
}
return (Object*) obj;
@@ -133,124 +102,63 @@ Object *Object_NewBuffer(int size, Heap *heap, Error *error)
static _Bool buffer_free(Object *self, Error *error)
{
(void) error;
UNUSED(error);
BufferObject *buffer = (BufferObject*) self;
if(buffer->size > THRESHOLD)
free(buffer->body);
Payload *payload = buffer->payload;
ASSERT(payload != NULL && payload->refs > 0);
payload->refs -= 1;
if(payload->refs == 0)
free(payload);
return 1;
}
Object *Object_SliceBuffer(Object *buffer, int offset, int length, Heap *heap, Error *error)
Object *Object_SliceBuffer(Object *obj, size_t offset, size_t length, Heap *heap, Error *error)
{
if(buffer->type != &t_buffer && buffer->type != &t_buffer_slice)
if(!Object_IsBuffer(obj))
{
Error_Report(error, 0, "Not a buffer or a buffer slice");
Error_Report(error, 0, "Not a buffer");
return NULL;
}
BufferSliceObject *slice;
Payload *payload = ((BufferObject*) obj)->payload;
if(buffer->type == &t_buffer)
{
BufferObject *original = (BufferObject*) buffer;
if(offset == 0 && length == original->size)
return buffer;
slice = (BufferSliceObject*) Heap_Malloc(heap, &t_buffer_slice, error);
if(slice == NULL)
return NULL;
if(offset < 0 || offset >= original->size)
{
Error_Report(error, 0, "offset out of range");
return NULL;
}
if(length < 0 || length >= original->size)
{
Error_Report(error, 0, "length out of range");
return NULL;
}
if(offset + length > original->size)
{
Error_Report(error, 0, "slice out of range");
return NULL;
}
slice->sliced = original;
slice->offset = offset;
slice->length = length;
if(offset >= payload->size) {
Error_Report(error, 0, "Offset out of range");
return NULL;
}
else
{
ASSERT(buffer->type == &t_buffer_slice);
slice = (BufferSliceObject*) Heap_Malloc(heap, &t_buffer_slice, error);
if(slice == NULL)
return NULL;
BufferSliceObject *original = (BufferSliceObject*) buffer;
if(offset < 0 || offset >= original->length)
{
Error_Report(error, 0, "offset out of range");
return NULL;
}
if(length < 0 || length >= original->length)
{
Error_Report(error, 0, "length out of range");
return NULL;
}
if(offset + length > original->length)
{
Error_Report(error, 0, "slice out of range");
return NULL;
}
slice->sliced = original->sliced;
slice->offset = original->offset + offset;
slice->length = length;
if(offset + length > payload->size) {
Error_Report(error, 0, "Length out of range");
return NULL;
}
BufferObject *slice = (BufferObject*) Heap_Malloc(heap, &t_buffer, error);
if(slice == NULL)
return NULL;
slice->payload = payload;
slice->offset = offset;
slice->length = length;
return (Object*) slice;
}
void *Object_GetBufferAddrAndSize(Object *obj, int *size, Error *error)
void *Object_GetBuffer(Object *obj, size_t *size)
{
if(obj->type != &t_buffer && obj->type != &t_buffer_slice)
if(!Object_IsBuffer(obj))
{
Error_Report(error, 0, "Not a buffer or a buffer slice");
Error_Panic("Not a buffer");
return NULL;
}
if(obj->type == &t_buffer)
{
BufferObject *buffer = (BufferObject*) obj;
if(size)
*size = buffer->size;
BufferObject *buffer = (BufferObject*) obj;
Payload *payload = buffer->payload;
return buffer->body;
}
else
{
ASSERT(obj->type == &t_buffer_slice);
BufferSliceObject *slice = (BufferSliceObject*) obj;
if(size)
*size = slice->length;
return slice->sliced->body + slice->offset;
}
if(size) *size = buffer->length;
return payload->body + buffer->offset;
}
static Object *buffer_select(Object *self, Object *key, Heap *heap, Error *error)
@@ -267,48 +175,19 @@ static Object *buffer_select(Object *self, Object *key, Heap *heap, Error *error
return NULL;
}
int idx = Object_ToInt(key, error);
ASSERT(error->occurred == 0);
int idx = Object_GetInt(key);
BufferObject *buffer = (BufferObject*) self;
if(idx < 0 || idx >= buffer->size)
if(idx < 0 || (size_t) idx >= buffer->length)
{
Error_Report(error, 0, "Out of range index");
Error_Report(error, 0, "Index out of range");
return NULL;
}
unsigned char byte = buffer->body[idx];
Payload *payload = buffer->payload;
return Object_FromInt(byte, heap, error);
}
static Object *slice_select(Object *self, Object *key, Heap *heap, Error *error)
{
ASSERT(self != NULL);
ASSERT(self->type == &t_buffer_slice);
ASSERT(key != NULL);
ASSERT(heap != NULL);
ASSERT(error != NULL);
if(!Object_IsInt(key))
{
Error_Report(error, 0, "Non integer key");
return NULL;
}
int idx = Object_ToInt(key, error);
ASSERT(error->occurred == 0);
BufferSliceObject *slice = (BufferSliceObject*) self;
if(idx < 0 || idx >= slice->length)
{
Error_Report(error, 0, "Out of range index");
return NULL;
}
unsigned char byte = slice->sliced->body[slice->offset + idx];
unsigned char byte = payload->body[buffer->offset + idx];
return Object_FromInt(byte, heap, error);
}
@@ -330,18 +209,18 @@ static _Bool buffer_insert(Object *self, Object *key, Object *val, Heap *heap, E
Error_Report(error, 0, "Non integer key");
return NULL;
}
int idx = Object_ToInt(key, error);
ASSERT(error->occurred == 0);
if(idx < 0 || idx >= buffer->size)
if(!Object_IsInt(val))
{
Error_Report(error, 0, "Non integer value");
return NULL;
}
int idx = Object_GetInt(key);
long long int qword = Object_GetInt(val);
if(idx < 0 || (size_t) idx >= buffer->length)
{
Error_Report(error, 0, "Out of range index");
return NULL;
}
long long int qword = Object_ToInt(val, error);
if(qword > 255 || qword < 0)
{
Error_Report(error, 0, "Not in range [0, 255]");
@@ -350,54 +229,8 @@ static _Bool buffer_insert(Object *self, Object *key, Object *val, Heap *heap, E
unsigned char byte = qword & 0xff;
if(error->occurred == 1)
return 0;
buffer->body[idx] = byte;
return 1;
}
static _Bool slice_insert(Object *self, Object *key, Object *val, Heap *heap, Error *error)
{
UNUSED(heap);
ASSERT(error != NULL);
ASSERT(key != NULL);
ASSERT(val != NULL);
ASSERT(heap != NULL);
ASSERT(self != NULL);
ASSERT(self->type == &t_buffer_slice);
BufferSliceObject *slice = (BufferSliceObject*) self;
if(!Object_IsInt(key))
{
Error_Report(error, 0, "Non integer key");
return NULL;
}
int idx = Object_ToInt(key, error);
ASSERT(error->occurred == 0);
if(idx < 0 || idx >= slice->length)
{
Error_Report(error, 0, "Out of range index");
return NULL;
}
long long int qword = Object_ToInt(val, error);
if(qword > 255 || qword < 0)
{
Error_Report(error, 0, "Not in range [0, 255]");
return NULL;
}
unsigned char byte = qword & 0xff;
if(error->occurred == 1)
return 0;
slice->sliced->body[slice->offset + idx] = byte;
Payload *payload = buffer->payload;
payload->body[buffer->offset + idx] = byte;
return 1;
}
@@ -405,14 +238,7 @@ static int buffer_count(Object *self)
{
BufferObject *buffer = (BufferObject*) self;
return buffer->size;
}
static int slice_count(Object *self)
{
BufferSliceObject *slice = (BufferSliceObject*) self;
return slice->length;
return buffer->length;
}
static void print_bytes(FILE *fp, unsigned char *addr, int size)
@@ -446,11 +272,5 @@ static void print_bytes(FILE *fp, unsigned char *addr, int size)
static void buffer_print(Object *self, FILE *fp)
{
BufferObject *buffer = (BufferObject*) self;
print_bytes(fp, buffer->body, buffer->size);
}
static void slice_print(Object *self, FILE *fp)
{
BufferSliceObject *slice = (BufferSliceObject*) self;
print_bytes(fp, slice->sliced->body + slice->offset, slice->length);
print_bytes(fp, buffer->payload->body + buffer->offset, buffer->length);
}
src/lib/objects/o_closure.c
+2 -1
View File
@@ -69,7 +69,8 @@ Object *Object_NewClosure(Object *parent, Object *new_map, Heap *heap, Error *er
return (Object*) obj;
}
static Object *select_(Object *self, Object *key, Heap *heap, Error *err)
static Object *select_(Object *self, Object *key,
Heap *heap, Error *err)
{
ClosureObject *closure = (ClosureObject*) self;
src/lib/objects/o_dir.c
+6 -5
View File
@@ -51,7 +51,7 @@ TypeObject *Object_GetDirType()
_Bool Object_IsDir(Object *obj)
{
return obj->type == &t_dir;
return Object_GetType(obj) == Object_GetDirType();
}
Object *Object_FromDIR(DIR *handle, Heap *heap, Error *error)
@@ -66,11 +66,12 @@ Object *Object_FromDIR(DIR *handle, Heap *heap, Error *error)
return (Object*) dob;
}
DIR *Object_ToDIR(Object *obj, Error *error)
DIR *Object_GetDIR(Object *obj)
{
if(!Object_IsDir(obj))
{
Error_Report(error, 0, "Object is not a directory");
if(!Object_IsDir(obj)) {
Error_Panic("%s expected a directory object, but an %s "
"was provided", __func__, Object_GetName(obj));
return NULL;
}
src/lib/objects/o_file.c
+4 -4
View File
@@ -54,11 +54,11 @@ _Bool Object_IsFile(Object *obj)
return obj->type == &t_file;
}
FILE *Object_ToStream(Object *obj, Error *error)
FILE *Object_GetStream(Object *obj)
{
if(!Object_IsFile(obj))
{
Error_Report(error, 0, "Object is not a file");
if(!Object_IsDir(obj)) {
Error_Panic("%s expected a file object, but an %s "
"was provided", __func__, Object_GetName(obj));
return NULL;
}
src/lib/objects/o_float.c
+16 -21
View File
@@ -30,9 +30,9 @@
#include <assert.h>
#include "objects.h"
#include "../utils/defs.h"
#include "../utils/hash.h"
static double to_float(Object *obj, Error *err);
static void print(Object *obj, FILE *fp);
static _Bool op_eql(Object *self, Object *other);
static int hash(Object *self);
@@ -47,10 +47,8 @@ static TypeObject t_float = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "float",
.size = sizeof (FloatObject),
.atomic = ATMTP_FLOAT,
.hash = hash,
.copy = copy,
.to_float = to_float,
.print = print,
.op_eql = op_eql
};
@@ -67,17 +65,15 @@ static int hash(Object *self)
static Object *copy(Object *self, Heap *heap, Error *err)
{
(void) heap;
(void) err;
return self;
UNUSED(heap);
UNUSED(err);
return self; /* Float objects are immutable */
}
static _Bool op_eql(Object *self, Object *other)
{
assert(self != NULL);
assert(self->type == &t_float);
assert(other != NULL);
assert(other->type == &t_float);
assert(self != NULL && self->type == &t_float);
assert(other != NULL && other->type == &t_float);
FloatObject *i1, *i2;
@@ -87,13 +83,14 @@ static _Bool op_eql(Object *self, Object *other)
return i1->val == i2->val;
}
static double to_float(Object *obj, Error *err)
double Object_GetFloat(Object *obj)
{
assert(obj);
assert(err);
assert(Object_GetType(obj) == &t_float);
(void) err;
if(!Object_IsFloat(obj)) {
Error_Panic("%s expected a float object, but "
"an %s was provided", __func__,
Object_GetName(obj));
return 0.0;
}
return ((FloatObject*) obj)->val;
}
@@ -106,9 +103,8 @@ TypeObject *Object_GetFloatType()
Object *Object_FromFloat(double val, Heap *heap, Error *error)
{
FloatObject *obj = (FloatObject*) Heap_Malloc(heap, &t_float, error);
if(obj == 0)
return 0;
if(obj == NULL)
return NULL;
obj->val = val;
@@ -118,8 +114,7 @@ Object *Object_FromFloat(double val, Heap *heap, Error *error)
static void print(Object *obj, FILE *fp)
{
assert(fp != NULL);
assert(obj != NULL);
assert(obj->type == &t_float);
assert(obj != NULL && obj->type == &t_float);
fprintf(fp, "%2.2f", ((FloatObject*) obj)->val);
}
src/lib/objects/o_int.c
+26 -29
View File
@@ -28,12 +28,11 @@
** +--------------------------------------------------------------------------+
*/
#include <assert.h>
#include <string.h>
#include "objects.h"
#include "../utils/defs.h"
#include "../utils/hash.h"
static long long int to_int(Object *obj, Error *err);
static void print(Object *obj, FILE *fp);
static _Bool op_eql(Object *self, Object *other);
static int hash(Object *self);
@@ -47,19 +46,16 @@ typedef struct {
static TypeObject t_int = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "int",
.size = sizeof (IntObject),
.atomic = ATMTP_INT,
.size = sizeof(IntObject),
.hash = hash,
.copy = copy,
.to_int = to_int,
.print = print,
.op_eql = op_eql,
};
static int hash(Object *self)
{
assert(self != NULL);
assert(self->type == &t_int);
ASSERT(self != NULL && self->type == &t_int);
IntObject *iobj = (IntObject*) self;
@@ -68,22 +64,11 @@ static int hash(Object *self)
static Object *copy(Object *self, Heap *heap, Error *err)
{
(void) heap;
(void) err;
UNUSED(heap);
UNUSED(err);
return self;
}
static long long int to_int(Object *obj, Error *err)
{
assert(obj != NULL);
assert(err != NULL);
assert(Object_GetType(obj) == &t_int);
(void) err;
return ((IntObject*) obj)->val;
}
TypeObject *Object_GetIntType()
{
return &t_int;
@@ -91,8 +76,8 @@ TypeObject *Object_GetIntType()
Object *Object_FromInt(long long int val, Heap *heap, Error *error)
{
assert(heap != NULL);
assert(error != NULL);
ASSERT(heap != NULL);
ASSERT(error != NULL);
IntObject *obj = (IntObject*) Heap_Malloc(heap, &t_int, error);
@@ -104,21 +89,33 @@ Object *Object_FromInt(long long int val, Heap *heap, Error *error)
return (Object*) obj;
}
long long int Object_GetInt(Object *obj)
{
if(!Object_IsInt(obj)) {
Error_Panic("%s expected an int object, but "
"an %s was provided", __func__,
Object_GetName(obj));
return 0;
}
return ((IntObject*) obj)->val;
}
static void print(Object *obj, FILE *fp)
{
assert(fp != NULL);
assert(obj != NULL);
assert(obj->type == &t_int);
ASSERT(fp != NULL);
ASSERT(obj != NULL);
ASSERT(obj->type == &t_int);
fprintf(fp, "%lld", ((IntObject*) obj)->val);
}
static _Bool op_eql(Object *self, Object *other)
{
assert(self != NULL);
assert(self->type == &t_int);
assert(other != NULL);
assert(other->type == &t_int);
ASSERT(self != NULL);
ASSERT(self->type == &t_int);
ASSERT(other != NULL);
ASSERT(other->type == &t_int);
IntObject *i1, *i2;
src/lib/objects/o_list.c
+3 -5
View File
@@ -50,7 +50,7 @@ static int hash(Object *self);
static TypeObject t_list = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "list",
.size = sizeof (ListObject),
.size = sizeof(ListObject),
.copy = copy,
.hash = hash,
.select = select_,
@@ -173,8 +173,7 @@ static Object *select_(Object *self, Object *key, Heap *heap, Error *error)
return NULL;
}
int idx = Object_ToInt(key, error);
ASSERT(error->occurred == 0);
int idx = Object_GetInt(key);
ListObject *list = (ListObject*) self;
@@ -228,8 +227,7 @@ static _Bool insert(Object *self, Object *key, Object *val, Heap *heap, Error *e
return NULL;
}
int idx = Object_ToInt(key, error);
ASSERT(error->occurred == 0);
int idx = Object_GetInt(key);
if(idx < 0 || idx > list->count)
{
src/lib/objects/o_map.c
+1 -1
View File
@@ -51,7 +51,7 @@ static int hash(Object *self);
static TypeObject t_map = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "map",
.size = sizeof (MapObject),
.size = sizeof(MapObject),
.copy = copy,
.hash = hash,
.select = select_,
src/lib/objects/o_none.c
+2 -2
View File
@@ -40,7 +40,7 @@ static Object *copy(Object *self, Heap *heap, Error *err);
static TypeObject t_none = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "none",
.size = sizeof (Object),
.size = sizeof(Object),
.hash = hash,
.copy = copy,
.print = print,
@@ -59,7 +59,7 @@ TypeObject *Object_GetNoneType()
_Bool Object_IsNone(Object *obj)
{
return obj == &the_none_object;
return Object_GetType(obj) == Object_GetNoneType();
}
static int hash(Object *self)
src/lib/objects/o_string.c
+10 -17
View File
@@ -45,7 +45,6 @@ static int hash(Object *self);
static int count(Object *self);
static Object *copy(Object *self, Heap *heap, Error *err);
static void print(Object *obj, FILE *fp);
static char *to_string(Object *self, int *size, Heap *heap, Error *err);
static _Bool op_eql(Object *self, Object *other);
static void walkexts(Object *self, void (*callback)(void **referer, unsigned int size, void *userp), void *userp);
static Object *select_(Object *self, Object *key, Heap *heap, Error *error);
@@ -53,14 +52,12 @@ static Object *select_(Object *self, Object *key, Heap *heap, Error *error);
static TypeObject t_string = {
.base = (Object) { .type = &t_type, .flags = Object_STATIC },
.name = "string",
.atomic = ATMTP_STRING,
.size = sizeof(StringObject),
.hash = hash,
.count = count,
.copy = copy,
.print = print,
.select = select_,
.to_string = to_string,
.op_eql = op_eql,
.walkexts = walkexts,
};
@@ -99,9 +96,7 @@ static Object *select_(Object *self, Object *key, Heap *heap, Error *error)
Error_Report(error, 0, "Non integer key");
return NULL;
}
int idx = Object_ToInt(key, error);
ASSERT(error->occurred == 0);
int idx = Object_GetInt(key);
StringObject *str = (StringObject*) self;
@@ -117,19 +112,17 @@ static Object *select_(Object *self, Object *key, Heap *heap, Error *error)
return Object_FromString(str->body + byteoffset, codelength, heap, error);
}
static char *to_string(Object *self, int *size, Heap *heap, Error *err)
const char *Object_GetString(Object *obj, int *size)
{
ASSERT(self != NULL);
ASSERT(self->type == &t_string);
(void) heap;
(void) err;
StringObject *s = (StringObject*) self;
if(size)
*size = s->bytes;
if(!Object_IsString(obj)) {
Error_Panic("%s expected a string object, but "
"an %s was provided", __func__,
Object_GetName(obj));
return NULL;
}
StringObject *s = (StringObject*) obj;
if(size) *size = s->bytes;
return s->body;
}
src/lib/objects/objects.c
+7 -171
View File
@@ -28,15 +28,15 @@
** +--------------------------------------------------------------------------+
*/
#include "../utils/defs.h"
#include "objects.h"
#include "../utils/defs.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),
.size = sizeof(TypeObject),
.op_eql = op_eql,
};
@@ -70,41 +70,11 @@ const TypeObject *Object_GetType(const Object *obj)
return obj->type;
}
unsigned int Object_GetSize(const Object *obj, Error *err)
{
UNUSED(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);
ASSERT(type != NULL && type->hash != NULL);
return type->hash(obj);
}
@@ -225,158 +195,24 @@ int Object_Count(Object *coll, Error *err)
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;
return Object_GetType(obj) == Object_GetIntType();
}
_Bool Object_IsBool(Object *obj)
{
ASSERT(obj != NULL);
ASSERT(obj->type != NULL);
return obj->type->atomic == ATMTP_BOOL;
return Object_GetType(obj) == Object_GetBoolType();
}
_Bool Object_IsFloat(Object *obj)
{
ASSERT(obj != NULL);
ASSERT(obj->type != NULL);
return obj->type->atomic == ATMTP_FLOAT;
return Object_GetType(obj) == Object_GetFloatType();
}
_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);
return Object_GetType(obj) == Object_GetStringType();
}
_Bool Object_Compare(Object *obj1, Object *obj2, Error *error)
src/lib/objects/objects.h
+29 -52
View File
@@ -31,8 +31,9 @@
#ifndef OBJECT_H
#define OBJECT_H
#include <dirent.h>
#include <stdio.h>
#include <dirent.h>
#include <stdbool.h>
#include "../utils/error.h"
#define MAX_RETS 8
@@ -51,14 +52,6 @@ typedef struct {
Object *new_location;
} MovedObject;
typedef enum {
ATMTP_NOTATOMIC = 0,
ATMTP_INT,
ATMTP_BOOL,
ATMTP_FLOAT,
ATMTP_STRING,
} AtomicType;
struct TypeObject {
Object base;
@@ -66,10 +59,10 @@ struct TypeObject {
// Any.
const char *name;
unsigned int size;
AtomicType atomic;
//AtomicType atomic;
_Bool (*init)(Object *self, Error *err);
_Bool (*free)(Object *self, Error *err);
bool (*init)(Object *self, Error *err);
bool (*free)(Object *self, Error *err);
int (*hash)(Object *self);
Object* (*copy)(Object *self, Heap *heap, Error *err);
int (*call)(Object *self, Object **argv, unsigned int argc, Object *rets[static MAX_RETS], Heap *heap, Error *err);
@@ -79,22 +72,10 @@ struct TypeObject {
// Collections.
Object *(*select)(Object *self, Object *key, Heap *heap, Error *err);
Object *(*delete)(Object *self, Object *key, Heap *heap, Error *err);
_Bool (*insert)(Object *self, Object *key, Object *val, Heap *heap, Error *err);
bool (*insert)(Object *self, Object *key, Object *val, Heap *heap, Error *err);
int (*count)(Object *self);
// Iterators.
Object *(*next)(Object *self, Heap *heap, Error *err);
Object *(*prev)(Object *self, Heap *heap, Error *err);
// Some.
union {
long long int (*to_int)(Object *self, Error *err);
_Bool (*to_bool)(Object *self, Error *err);
double (*to_float)(Object *self, Error *err);
char *(*to_string)(Object *self, int *size, Heap *heap, Error *err);
};
_Bool (*op_eql)(Object *self, Object *other);
bool (*op_eql)(Object *self, Object *other);
// All.
void (*walk) (Object *self, void (*callback)(Object **referer, void *userp), void *userp);
@@ -110,8 +91,8 @@ Heap* Heap_New(int size);
void Heap_Free(Heap *heap);
void* Heap_Malloc (Heap *heap, TypeObject *type, Error *err);
void* Heap_RawMalloc(Heap *heap, int size, Error *err);
_Bool Heap_StartCollection(Heap *heap, Error *error);
_Bool Heap_StopCollection(Heap *heap);
bool Heap_StartCollection(Heap *heap, Error *error);
bool Heap_StopCollection(Heap *heap);
void Heap_CollectReference(Object **referer, void *heap);
float Heap_GetUsagePercentage(Heap *heap);
unsigned int Heap_GetObjectCount(Heap *heap);
@@ -120,19 +101,14 @@ unsigned int Heap_GetSize(Heap *heap);
const TypeObject* Object_GetType(const Object *obj);
const char* Object_GetName(const Object *obj);
unsigned int Object_GetSize(const Object *obj, Error *err);
unsigned int Object_GetDeepSize(const Object *obj, Error *err);
void *Object_GetBufferAddrAndSize(Object *obj, int *size, Error *error);
int Object_Hash (Object *obj);
Object* Object_Copy (Object *obj, Heap *heap, Error *err);
int Object_Call (Object *obj, Object **argv, unsigned int argc, Object *rets[static MAX_RETS], Heap *heap, Error *err);
void Object_Print (Object *obj, FILE *fp);
Object* Object_Select(Object *coll, Object *key, Heap *heap, Error *err);
Object* Object_Delete(Object *coll, Object *key, Heap *heap, Error *err);
_Bool Object_Insert(Object *coll, Object *key, Object *val, Heap *heap, Error *err);
bool Object_Insert(Object *coll, Object *key, Object *val, Heap *heap, Error *err);
int Object_Count (Object *coll, Error *err);
Object* Object_Next (Object *iter, Heap *heap, Error *err);
Object* Object_Prev (Object *iter, Heap *heap, Error *err);
void Object_WalkReferences(Object *parent, void (*callback)(Object **referer, void *userp), void *userp);
void Object_WalkExtensions(Object *parent, void (*callback)(void **referer, unsigned int size, void *userp), void *userp);
@@ -140,12 +116,12 @@ Object* Object_NewMap(int num, Heap *heap, Error *error);
Object* Object_NewList(int capacity, Heap *heap, Error *error);
Object* Object_NewList2(int num, Object **items, Heap *heap, Error *error);
Object* Object_NewNone(Heap *heap, Error *error);
Object* Object_NewBuffer(int size, Heap *heap, Error *error);
Object* Object_NewBuffer(size_t size, Heap *heap, Error *error);
Object* Object_NewClosure(Object *parent, Object *new_map, Heap *heap, Error *error);
Object* Object_SliceBuffer(Object *buffer, int offset, int length, Heap *heap, Error *error);
Object* Object_SliceBuffer(Object *obj, size_t offset, size_t length, Heap *heap, Error *error);
Object* Object_FromInt (long long int val, Heap *heap, Error *error);
Object* Object_FromBool (_Bool val, Heap *heap, Error *error);
Object* Object_FromBool (bool val, Heap *heap, Error *error);
Object* Object_FromFloat (double val, Heap *heap, Error *error);
Object* Object_FromString(const char *str, int len, Heap *heap, Error *error);
Object* Object_FromStream(FILE *fp, Heap *heap, Error *error);
@@ -163,23 +139,24 @@ TypeObject *Object_GetBufferType();
TypeObject *Object_GetFileType();
TypeObject *Object_GetDirType();
_Bool Object_IsNone(Object *obj);
_Bool Object_IsInt(Object *obj);
_Bool Object_IsBool(Object *obj);
_Bool Object_IsFloat(Object *obj);
_Bool Object_IsString(Object *obj);
_Bool Object_IsBuffer(Object *obj);
_Bool Object_IsFile(Object *obj);
_Bool Object_IsDir(Object *obj);
bool Object_IsNone(Object *obj);
bool Object_IsInt(Object *obj);
bool Object_IsBool(Object *obj);
bool Object_IsFloat(Object *obj);
bool Object_IsString(Object *obj);
bool Object_IsBuffer(Object *obj);
bool Object_IsFile(Object *obj);
bool Object_IsDir(Object *obj);
long long int Object_ToInt (Object *obj, Error *err);
_Bool Object_ToBool (Object *obj, Error *err);
double Object_ToFloat(Object *obj, Error *err);
const char *Object_ToString(Object *obj, int *size, Heap *heap, Error *err);
DIR *Object_ToDIR(Object *obj, Error *error);
FILE *Object_ToStream(Object *obj, Error *error);
long long int Object_GetInt (Object *obj);
bool Object_GetBool (Object *obj);
double Object_GetFloat(Object *obj);
const char *Object_GetString(Object *obj, int *size);
DIR *Object_GetDIR(Object *obj);
FILE *Object_GetStream(Object *obj);
void *Object_GetBuffer(Object *obj, size_t *size);
_Bool Object_Compare(Object *obj1, Object *obj2, Error *error);
bool Object_Compare(Object *obj1, Object *obj2, Error *error);
extern TypeObject t_type;