Objects Initial

Objects/private/primitives/boolobject.cpp

@@ -0,0 +1,78 @@
+
+
+#include "NewPlacement.hpp"
+#include "primitives/boolobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void BoolObject::constructor(BoolObject* self) {
+	self->val = false;
+}
+
+void BoolObject::copy(BoolObject* self, const BoolObject* in) {
+	self->val = in->val;
+}
+
+BoolObject* BoolObject::create(bool in) {
+	NDO_CASTV(BoolObject, NDO->create("bool"), out)->val = alni(in);
+	return out;
+}
+
+void BoolObject::from_int(BoolObject* self, alni in) {
+	self->val = in;
+}
+
+void BoolObject::from_float(BoolObject* self, alnf in) {
+	self->val = alni(bool(in));
+}
+
+void BoolObject::from_string(BoolObject* self, String in) {
+	self->val = alni(bool(in));
+}
+
+String BoolObject::to_string(BoolObject* self) {
+	return String(bool(self->val));
+}
+
+alni BoolObject::to_int(BoolObject* self) {
+	return self->val;
+}
+
+alnf BoolObject::to_float(BoolObject* self) {
+	return alnf(bool(self->val));
+}
+
+static alni save_size(BoolObject* self) {
+	return sizeof(alni);
+}
+
+static void save(BoolObject* self, Archiver& file_self) {
+	file_self.write<alni>(&self->val);
+}
+
+static void load(Archiver& file_self, BoolObject* self) {
+	file_self.read<alni>(&self->val);
+}
+
+struct ObjectTypeConversions BoolObjectTypeConversions = {
+	.from_int = (object_from_int) BoolObject::from_int,
+	.from_float = (object_from_float) BoolObject::from_float,
+	.from_string = (object_from_string) BoolObject::from_string,
+	.to_string = (object_to_string) BoolObject::to_string,
+	.to_int = (object_to_int) BoolObject::to_int,
+	.to_float = (object_to_float) BoolObject::to_float,
+};
+
+struct obj::ObjectType obj::BoolObject::TypeData = {
+	.base = NULL,
+	.constructor = (object_constructor) BoolObject::constructor,
+	.destructor = NULL,
+	.copy = (object_copy) BoolObject::copy,
+	.size = sizeof(BoolObject),
+	.name = "bool",
+	.convesions = &BoolObjectTypeConversions,
+	.save_size = (object_save_size)save_size,
+	.save = (object_save)save,
+	.load = (object_load)load,
+};

Objects/private/primitives/classobject.cpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "NewPlacement.hpp"
+
+#include "primitives/classobject.h"
+#include "primitives/dictobject.h"
+#include "primitives/nullobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void ClassObject::constructor(ClassObject* self) {
+	self->members = NDO_CAST(DictObject, NDO->create("dict"));
+
+	self->addMember(NDO_NULL, "__init__");
+	self->addMember(NDO_NULL, "__del__");
+}
+
+void ClassObject::copy(ClassObject* self, const ClassObject* blueprint) {
+	NDO->copy(self->members, blueprint->members);
+}
+
+void ClassObject::destructor(ClassObject* self) {
+	NDO->destroy(self->members);
+}
+
+void ClassObject::addMember(Object* obj, tp::String id) {
+	members->put(id, obj);
+}
+
+void ClassObject::createMember(tp::String type, tp::String id) {
+	auto newo = NDO->create(type);
+	members->put(id, newo);
+}
+
+alni ClassObject::save_size(ClassObject* self) {
+	return sizeof(alni); // dict object adress
+}
+
+void ClassObject::save(ClassObject* self, Archiver& file_self) {
+	// save dictobject
+	alni ndo_object_adress = NDO->save(file_self, self->members);
+	file_self.write<alni>(&ndo_object_adress);
+}
+
+void ClassObject::load(Archiver& file_self, ClassObject* self) {
+	alni ndo_object_adress;
+	file_self.read<alni>(&ndo_object_adress);
+	self->members = NDO_CAST(DictObject, NDO->load(file_self, ndo_object_adress));
+}
+
+tp::Buffer<Object*> childs_retrival(ClassObject* self) {
+	tp::Buffer<Object*> out;
+	out.append(self->members);
+	return out;
+}
+
+alni allocated_size(ClassObject* self) {
+	return sizeof(DictObject*);
+}
+
+alni allocated_size_recursive(ClassObject* self) {
+	alni out = sizeof(DictObject*);
+	out += NDO->objsize_ram_recursive_util(self->members, self->members->type);
+	return out;
+}
+
+struct ObjectType ClassObject::TypeData = {
+	.base = NULL,
+	.constructor = (object_constructor) ClassObject::constructor,
+	.destructor = (object_destructor) ClassObject::destructor,
+	.copy = (object_copy) ClassObject::copy,
+	.size = sizeof(ClassObject),
+	.name = "class",
+	.save_size = (object_save_size)save_size,
+	.save = (object_save)save,
+  .load = (object_load)load,
+	.childs_retrival = (object_debug_all_childs_retrival) childs_retrival,
+	.allocated_size = (object_allocated_size) allocated_size,
+	.allocated_size_recursive = (object_allocated_size_recursive) allocated_size_recursive
+};

Objects/private/primitives/colorobject.cpp

@@ -0,0 +1,84 @@
+
+#include "NewPlacement.hpp"
+#include "primitives/colorobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void ColorObject::constructor(Object* self) {
+	NDO_CAST(ColorObject, self)->mCol = tp::RGBA(1.f);
+}
+
+void ColorObject::copy(ColorObject* self, const ColorObject* in) {
+	self->mCol = in->mCol;
+}
+
+ColorObject* ColorObject::create(tp::RGBA in) {
+	NDO_CASTV(ColorObject, NDO->create("RGBA"), out)->mCol = in;
+	return out;
+}
+
+void ColorObject::from_int(ColorObject* self, alni in) {
+	self->mCol = tp::RGBA((tp::halnf)tp::clamp(in, (tp::alni) 0, (tp::alni) 1));
+}
+
+void ColorObject::from_float(ColorObject* self, alnf in) {
+	NDO_CAST(ColorObject, self)->mCol = tp::RGBA(tp::clamp((tp::halnf)in, 0.f, 1.f));
+}
+
+String ColorObject::to_string(ColorObject* self) {
+	// auto &col = NDO_CAST(ColorObject, self)->mCol;
+	// return tp::sfmt("%i:%i:%i:%i", (tp::alni) (col.r * 255), (tp::alni)(col.g * 255), (tp::alni)(col.b * 255), (tp::alni)(col.a * 255));
+	// TODO : implement
+	return {};
+}
+
+static alni save_size(ColorObject* self) {
+	return sizeof(tp::RGBA);
+}
+
+static void save(ColorObject* self, Archiver& file_self) {
+	file_self.write<tp::RGBA>(&self->mCol);
+}
+
+static void load(Archiver& file_self, ColorObject* self) {
+	file_self.read<tp::RGBA>(&self->mCol);
+}
+
+struct ObjectTypeConversions ColorObjectTypeConversions = {
+	.from_int = (object_from_int) ColorObject::from_int,
+	.from_float = (object_from_float) ColorObject::from_float,
+	.from_string = NULL,
+	.to_string = (object_to_string) ColorObject::to_string,
+	.to_int = NULL,
+	.to_float = NULL,
+};
+
+void sub(ColorObject* self, ColorObject* in) {
+	self->mCol = in->mCol - self->mCol;
+}
+
+void add(ColorObject* self, ColorObject* in) {
+	self->mCol = in->mCol + self->mCol;
+}
+
+struct ObjectTypeAriphmetics ColorObject::TypeAriphm = {
+	.add = (object_add) add,
+	.sub = (object_sub) sub,
+	.mul = (object_mul) NULL,
+	.div = (object_div) NULL,
+};
+
+struct obj::ObjectType obj::ColorObject::TypeData = {
+	.base = NULL,
+	.constructor = ColorObject::constructor,
+	.destructor = NULL,
+	.copy = (object_copy) ColorObject::copy,
+	.size = sizeof(ColorObject),
+	.name = "RGBA",
+	.convesions = &ColorObjectTypeConversions,
+	.ariphmetics = &ColorObject::TypeAriphm,
+	.save_size = (object_save_size)save_size,
+	.save = (object_save)save,
+	.load = (object_load)load,
+};

Objects/private/primitives/dictobject.cpp

@@ -0,0 +1,232 @@
+#pragma once
+
+#include "NewPlacement.hpp"
+
+#include "primitives/dictobject.h"
+#include "primitives/stringobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void DictObject::constructor(Object* self) {
+	NDO_CASTV(DictObject, self, dict);
+
+	new (&dict->items) Map<String, Object*>();
+}
+
+void DictObject::copy(Object* in, const Object* target) {
+	NDO_CASTV(DictObject, in, self);
+	NDO_CASTV(DictObject, target, src);
+
+	destructor(self);
+	constructor(self);
+
+	for (auto item : src->items) {
+		auto instance = NDO->instatiate(item->val);
+		self->items.put(item->key, instance);
+	}
+}
+
+void DictObject::destructor(Object* self) {
+	NDO_CASTV(DictObject, self, dict);
+	for (auto item : dict->items) {
+		NDO->destroy(item->val);
+	}
+	dict->items.~Map();
+}
+
+alni DictObject::save_size(DictObject* self) {
+	// calculate size needed
+	alni save_size = 0;
+
+	// number on entries
+	save_size += sizeof(alni);
+
+	for (auto item : self->items) {
+		// string length
+		save_size += (item->key.size() + 1) * sizeof(*item->key.read());
+		// object file adress
+		save_size += sizeof(alni);
+	}
+
+	return save_size;
+}
+
+void DictObject::save(DictObject* self, Archiver& file_self) {
+
+	// write size
+	alni len = self->items.size();
+	file_self.write<alni>(&len);
+
+	// save hashmap pairs
+	for (auto item : self->items) {
+		// item val
+		alni ndo_object_adress = NDO->save(file_self, item->val);
+		file_self.write<alni>(&ndo_object_adress);
+
+		// item key
+		item->key.save(&file_self);
+	}
+}
+
+void DictObject::load(Archiver& file_self, DictObject* self) {
+	new (&self->items) tp::Map<tp::String, Object*>();
+
+	alni len;
+	file_self.read<alni>(&len);
+
+	for (alni i = 0; i < len; i++) {
+
+		// read val
+		alni ndo_object_adress;
+		file_self.read<alni>(&ndo_object_adress);
+		Object* val = NDO->load(file_self, ndo_object_adress);
+
+		// read key value
+		String key;
+		key.load(&file_self);
+
+		// add to dictinary
+		self->items.put(key, val);
+	}
+}
+
+tp::Buffer<Object*> DictObject::childs_retrival(DictObject* self) {
+	tp::Buffer<Object*> out;
+	out.reserve(self->items.size());
+	ualni i = 0;
+	for (auto item : self->items) {
+		out[i] = item->val;
+		i++;
+	}
+	return out;
+}
+
+alni DictObject::allocated_size(DictObject* self) {
+	alni out = self->items.sizeAllocatedMem();
+	for (auto item : self->items) {
+		out += item->key.sizeAllocatedMem();
+	}
+	return out;
+	return 0;
+}
+
+alni DictObject::allocated_size_recursive(DictObject* self) {
+	alni out = allocated_size(self);
+	for (auto item : self->items) {
+		out += NDO->objsize_ram_recursive_util(item->val, item->val->type);
+	}
+	return out;
+}
+
+void DictObject::put(tp::String str, Object* obj) {
+	DEBUG_ASSERT(obj);
+	NDO->refinc(obj);
+	items.put(str, obj);
+}
+
+void DictObject::remove(tp::String str) {
+	auto idx = items.presents(str);
+	if (idx) {
+		NDO->destroy(items.getSlotVal(idx));
+		items.remove(str);
+	}
+}
+
+Object* DictObject::get(tp::String str) {
+	return items.get(str);
+}
+
+tp::Map<tp::String, Object*>::Idx DictObject::presents(tp::String str) {
+	return items.presents(str);
+}
+
+Object* DictObject::getSlotVal(tp::alni idx) {
+	return items.getSlotVal(idx);
+}
+
+const tp::Map<tp::String, Object*>& DictObject::getItems() const {
+	return items;
+}
+
+static auto tm_get = TypeMethod{
+	.nameid = "get",
+	.descr = "gets the object",
+	.args = { 
+		{ "str key", NULL }
+	},
+	.exec = [](const TypeMethod* tm) {
+		auto const self = (DictObject*)tm->self;
+		auto str_key = tm->args[0].obj;
+
+		NDO_CASTV(StringObject, str_key, key);
+		ASSERT(key);
+
+		auto idx = self->presents(key->val);
+		if (idx) {
+			tm->ret.obj = self->getSlotVal(idx);
+		}
+	},
+	.ret = { "object", NULL }
+};
+
+static auto tm_put = TypeMethod{
+	.nameid = "put",
+	.descr = "puts the object into the dictinary",
+	.args = {
+		{ "key", NULL },
+		{ "object", NULL }
+	},
+	.exec = [](const TypeMethod* tm) {
+		auto const self = (DictObject*)tm->self;
+
+		auto str_key = tm->args[0].obj;
+		auto obj = tm->args[1].obj;
+
+		NDO_CASTV(StringObject, str_key, key);
+		ASSERT(key);
+
+		self->put(key->val, obj);
+	},
+};
+
+static auto tm_remove = TypeMethod{
+	.nameid = "remove",
+	.descr = "remove the object from the dictinary",
+	.args = {
+		{ "key", NULL },
+	},
+	.exec = [](const TypeMethod* tm) {
+		auto const self = (DictObject*)tm->self;
+
+		auto str_key = tm->args[0].obj;
+		
+		NDO_CASTV(StringObject, str_key, key);
+		ASSERT(key);
+
+		self->remove(key->val);
+	},
+};
+
+struct obj::ObjectType DictObject::TypeData = {
+	.base = NULL,
+	.constructor = DictObject::constructor,
+	.destructor = DictObject::destructor,
+	.copy = DictObject::copy,
+	.size = sizeof(DictObject),
+	.name = "dict",
+	.save_size = (object_save_size)DictObject::save_size,
+	.save = (object_save)DictObject::save,
+	.load = (object_load)DictObject::load,
+	.childs_retrival = (object_debug_all_childs_retrival)DictObject::childs_retrival,
+	.allocated_size = (object_allocated_size)DictObject::allocated_size,
+	.allocated_size_recursive = (object_allocated_size_recursive)DictObject::allocated_size_recursive,
+
+	.type_methods = {
+	.methods = {
+			&tm_put,
+			&tm_remove,
+			&tm_get,
+		}
+	}
+};

Objects/private/primitives/enumobject.cpp

@@ -0,0 +1,182 @@
+
+#pragma once
+
+#include "NewPlacement.hpp"
+#include "primitives/enumobject.h"
+
+#include <malloc.h>
+
+using namespace obj;
+using namespace tp;
+
+void EnumObject::constructor(EnumObject* self) {
+	self->active = 0;
+	self->nentries = 0;
+	self->entries = NULL;
+}
+
+void obj::EnumObject::destructor(EnumObject* self) {
+	if (self->entries) free(self->entries);
+}
+
+void EnumObject::copy(EnumObject* self, const EnumObject* in) {
+	if (self->entries) free(self->entries);
+	self->active = in->active;
+	self->nentries = in->nentries;
+
+	self->entries = (alni*)malloc(self->nentries * ENV_ALNI_SIZE_B);
+	tp::memCopy(self->entries, in->entries, self->nentries * ENV_ALNI_SIZE_B);
+}
+
+void obj::EnumObject::init(tp::init_list<const char*> list) {
+
+	if (entries) free(entries);
+
+	active = 0;
+	nentries = (uhalni) list.size();
+	entries = (alni*) malloc(nentries * ENV_ALNI_SIZE_B);
+	tp::memSetVal(entries, nentries * ENV_ALNI_SIZE_B, 0);
+
+	alni* entry = entries;
+	for (auto elem : list) {
+
+		alni len = tp::String::Logic::calcLength(elem);
+		if (len > ENV_ALNI_SIZE_B - 1) len = ENV_ALNI_SIZE_B - 1;
+
+		tp::memCopy(entry, elem, len);
+
+		for (alni* chech_entry = entries; chech_entry != entry; chech_entry++) {
+			DEBUG_ASSERT(tp::memCompare(chech_entry, entry, ENV_ALNI_SIZE_B) != 0);
+		}
+
+		entry++; 
+	}
+}
+
+const char* obj::EnumObject::getActiveName() {
+	return getItemName(active);
+}
+
+const char* obj::EnumObject::getItemName(tp::uhalni idx) {
+	DEBUG_ASSERT(entries && idx >= 0 && idx < nentries);
+	return (const char*) (entries + idx);
+}
+
+
+void EnumObject::from_int(EnumObject* self, alni in) {
+	if (self->entries && in >= 0 && in < self->nentries) {
+		self->active = uhalni(in);
+	}
+}
+
+void EnumObject::from_float(EnumObject* self, alnf in) {
+	if (self->entries && in >= 0 && in < self->nentries) {
+		self->active = uhalni(in);
+	}
+}
+
+void EnumObject::from_string(EnumObject* self, String in) {
+	if (self->entries) {
+		alni* entry = self->entries;
+		for (uhalni i = 0; i < self->nentries; i++) {
+			if (tp::String::Logic::isEqualLogic((const char*)entry, in.read())) {
+				self->active = i;
+			}
+			entry += 1;
+		}
+	}
+}
+
+String EnumObject::to_string(EnumObject* self) {
+	if (!self->entries) {
+		return tp::String();
+	}
+	auto val = (const char*)(&self->entries[self->active]);
+	return String(val);
+}
+
+alni EnumObject::to_int(EnumObject* self) {
+	if (!self->entries) {
+		return -1;
+	}
+	return alni(self->active);
+}
+
+alnf EnumObject::to_float(EnumObject* self) {
+	if (!self->entries) {
+		return -1;
+	}
+	return alnf(self->active);
+}
+
+static alni save_size(EnumObject* self) {
+	if (!self->entries) {
+		return sizeof(uhalni);
+	}
+	return sizeof(uhalni) + sizeof(uhalni) + sizeof(alni) * self->nentries;
+}
+
+static void save(EnumObject* self, Archiver& file_self) {
+	if (!self->entries) {
+		uhalni empty_code = -1;
+		file_self.write<uhalni>(&empty_code);
+		return;
+	}
+	file_self.write<uhalni>(&self->active);
+	file_self.write<uhalni>(&self->nentries);
+	file_self.write_bytes((tp::int1*) self->entries, self->nentries * ENV_ALNI_SIZE_B);
+}
+
+static void load(Archiver& file_self, EnumObject* self) {
+	file_self.read<uhalni>(&self->active);
+	if (self->active == -1) {
+		self->nentries = 0;
+		self->entries = NULL;
+		return;
+	}
+	file_self.read<uhalni>(&self->nentries);
+	self->entries = (alni*) malloc(self->nentries * ENV_ALNI_SIZE_B);
+	file_self.read_bytes((tp::int1*) self->entries, self->nentries * ENV_ALNI_SIZE_B);
+}
+
+bool obj::EnumObject::compare(EnumObject* first, EnumObject* second) {
+	return first->entries != NULL && second->entries != NULL && first->active == second->active;
+}
+
+EnumObject* obj::EnumObject::create(tp::init_list<const char*> list) {
+	auto enum_object = (EnumObject*)obj::NDO->create("enum");
+	enum_object->init(list);
+	return enum_object;
+}
+
+alni allocated_size(EnumObject* self) {
+	alni out = sizeof(uhalni) * 2 + sizeof(tp::alni*);
+	if (self->entries) {
+		out += self->nentries * sizeof(alni) * 2;
+	}
+	return out;
+}
+
+struct ObjectTypeConversions EnumObjectTypeConversions = {
+	.from_int = (object_from_int) EnumObject::from_int,
+	.from_float = (object_from_float) EnumObject::from_float,
+	.from_string = (object_from_string) EnumObject::from_string,
+	.to_string = (object_to_string) EnumObject::to_string,
+	.to_int = (object_to_int) EnumObject::to_int,
+	.to_float = (object_to_float) EnumObject::to_float,
+};
+
+struct obj::ObjectType obj::EnumObject::TypeData = {
+	.base = NULL,
+	.constructor = (object_constructor) EnumObject::constructor,
+	.destructor = (object_destructor) EnumObject::destructor,
+	.copy = (object_copy) EnumObject::copy,
+	.size = sizeof(EnumObject),
+	.name = "enum",
+	.convesions = &EnumObjectTypeConversions,
+	.save_size = (object_save_size)save_size,
+	.save = (object_save)save,
+	.load = (object_load)load,
+	.comparison = (object_compare) EnumObject::compare,
+	.allocated_size = (object_allocated_size) allocated_size,
+};

Objects/private/primitives/floatobject.cpp

@@ -0,0 +1,102 @@
+#pragma once
+
+#include "NewPlacement.hpp"
+#include "primitives/floatobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void FloatObject::constructor(FloatObject* self) {
+	self->val = 0;
+}
+
+void FloatObject::copy(FloatObject* self, const FloatObject* in) {
+	self->val = in->val;
+}
+
+FloatObject* FloatObject::create(alnf in) {
+	NDO_CASTV(FloatObject, NDO->create("float"), out)->val = alnf(in);
+	return out;
+}
+
+void FloatObject::from_int(FloatObject* self, alni in) {
+	self->val = alnf(in);
+}
+
+void FloatObject::from_float(FloatObject* self, alnf in) {
+	self->val = in;
+}
+
+void FloatObject::from_string(FloatObject* self, String in) {
+	self->val = alnf(in);
+}
+
+String FloatObject::to_string(FloatObject* self) {
+	return String(self->val);
+}
+
+alni FloatObject::to_int(FloatObject* self) {
+	return alni(self->val);
+}
+
+alnf FloatObject::to_float(FloatObject* self) {
+	return self->val;
+}
+
+static alni save_size(FloatObject* self) {
+	return sizeof(alnf);
+}
+
+static void save(FloatObject* self, Archiver& file_self) {
+	file_self.write<alnf>(&self->val);
+}
+
+static void load(Archiver& file_self, FloatObject* self) {
+	file_self.read<alnf>(&self->val);
+}
+
+struct ObjectTypeConversions FloatObjectTypeConversions = {
+	.from_int = (object_from_int) FloatObject::from_int,
+	.from_float = (object_from_float) FloatObject::from_float,
+	.from_string = (object_from_string) FloatObject::from_string,
+	.to_string = (object_to_string) FloatObject::to_string,
+	.to_int = (object_to_int) FloatObject::to_int,
+	.to_float = (object_to_float) FloatObject::to_float,
+};
+
+static void mul(FloatObject* self, FloatObject* in) {
+	self->val *= in->val;
+}
+
+static void sub(FloatObject* self, FloatObject* in) {
+	self->val -= in->val;
+}
+
+static void add(FloatObject* self, FloatObject* in) {
+	self->val += in->val;
+}
+
+static void divide(FloatObject* self, FloatObject* in) {
+	self->val /= in->val;
+}
+
+struct ObjectTypeAriphmetics FloatObject::TypeAriphm = {
+	.add = (object_add)add,
+	.sub = (object_sub)sub,
+	.mul = (object_mul)mul,
+	.div = (object_div)divide,
+};
+
+struct obj::ObjectType obj::FloatObject::TypeData = {
+	.base = NULL,
+	.constructor = (object_constructor) FloatObject::constructor,
+	.destructor = NULL,
+	.copy = (object_copy) FloatObject::copy,
+	.size = sizeof(FloatObject),
+	.name = "float",
+	.convesions = &FloatObjectTypeConversions,
+	.ariphmetics = &FloatObject::TypeAriphm,
+	.save_size = (object_save_size) save_size,
+	.save = (object_save) save,
+	.load = (object_load) load,
+};

Objects/private/primitives/interpreterobject.cpp

@@ -0,0 +1,82 @@
+
+#include "NewPlacement.hpp"
+
+#include "primitives/interpreterobject.h"
+#include "primitives/linkobject.h"
+#include "primitives/methodobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void InterpreterObject::constructor(InterpreterObject* self) {
+	new (&self->mInterpreter) Interpreter();
+
+	self->createMember("dict", "globals");
+	self->createMember("link", "target method");
+}
+
+void InterpreterObject::destructor(InterpreterObject* self) {
+	self->mInterpreter.~Interpreter();
+}
+
+void InterpreterObject::load(Archiver& file_self, InterpreterObject* self) {
+	new (&self->mInterpreter) Interpreter();
+}
+
+bool InterpreterObject::running() { return !mInterpreter.finished(); }
+
+void InterpreterObject::exec(obj::ClassObject* self, tp::init_list<Interpreter::GlobalDef> globals) {
+
+	if (running()) {
+		return;
+	}
+
+	auto link_target = getMember<obj::LinkObject>("target method");
+	if (!link_target) {
+		return;
+	}
+
+	auto target = link_target->getLink();
+	if (!target) {
+		return;
+	}
+
+	NDO_CASTV(obj::MethodObject, target, method);
+	if (!method || !method->mScript->mBytecode.mInstructions.size()) {
+		return;
+	}
+
+	mInterpreter.execAll(method, self, getMember<obj::DictObject>("globals"), globals);
+}
+
+void InterpreterObject::debug() {
+	if (running()) {
+		return;
+	}
+
+	auto link_target = getMember<obj::LinkObject>("target method");
+	if (!link_target) {
+		return;
+	}
+
+	auto target = link_target->getLink();
+	if (!target) {
+		return;
+	}
+
+	NDO_CASTV(obj::MethodObject, target, method);
+	if (!method || !method->mScript->mBytecode.mInstructions.size()) {
+		return;
+	}
+	
+	mInterpreter.exec(method, this, getMember<obj::DictObject>("globals"));
+}
+
+struct obj::ObjectType InterpreterObject::TypeData = {
+	.base = &ClassObject::TypeData,
+	.constructor = (object_constructor)InterpreterObject::constructor,
+	.destructor = (object_destructor)InterpreterObject::destructor,
+	.size = sizeof(InterpreterObject),
+	.name = "interpreter",
+	.load = (object_load)InterpreterObject::load,
+};

Objects/private/primitives/intobject.cpp

@@ -0,0 +1,104 @@
+
+#pragma once
+
+#include "NewPlacement.hpp"
+
+#include "primitives/intobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void IntObject::constructor(Object* self) {
+	NDO_CAST(IntObject, self)->val = 0;
+}
+
+void IntObject::copy(IntObject* self, const IntObject* in) {
+	self->val = in->val;
+}
+
+IntObject* IntObject::create(alni in) {
+	NDO_CASTV(IntObject, NDO->create("int"), out)->val = in;
+	return out;
+}
+
+void IntObject::from_int(Object* self, alni in) {
+	NDO_CAST(IntObject, self)->val = in;
+}
+
+void IntObject::from_float(Object* self, alnf in) {
+	NDO_CAST(IntObject, self)->val = (alni)in;
+}
+
+void IntObject::from_string(Object* self, String in) {
+	NDO_CAST(IntObject, self)->val = alni(in);
+}
+
+String IntObject::to_string(Object* self) {
+	return String(NDO_CAST(IntObject, self)->val);
+}
+
+alni IntObject::to_int(Object* self) {
+	return alni(NDO_CAST(IntObject, self)->val);
+}
+
+alnf IntObject::to_float(Object* self) {
+	return alnf(NDO_CAST(IntObject, self)->val);
+}
+
+static alni save_size(IntObject* self) {
+	return sizeof(alni);
+}
+
+static void save(IntObject* self, Archiver& file_self) {
+	file_self.write<alni>(&self->val);
+}
+
+static void load(Archiver& file_self, IntObject* self) {
+	file_self.read<alni>(&self->val);
+}
+
+struct ObjectTypeConversions IntObjectTypeConversions = {
+	.from_int = IntObject::from_int,
+	.from_float = IntObject::from_float,
+	.from_string = IntObject::from_string,
+	.to_string = IntObject::to_string,
+	.to_int = IntObject::to_int,
+	.to_float = IntObject::to_float,
+};
+
+void divide(IntObject* self, IntObject* in) {
+	self->val /= in->val;
+}
+
+void mul(IntObject* self, IntObject* in) {
+	self->val *= in->val;
+}
+
+void sub(IntObject* self, IntObject* in) {
+	self->val -= in->val;
+}
+
+void add(IntObject* self, IntObject* in) {
+	self->val += in->val;
+}
+
+struct ObjectTypeAriphmetics IntObject::TypeAriphm = {
+	.add = (object_add) add,
+	.sub = (object_sub) sub,
+	.mul = (object_mul) mul,
+	.div = (object_div) divide,
+};
+
+struct obj::ObjectType obj::IntObject::TypeData = {
+	.base = NULL,
+	.constructor = IntObject::constructor,
+	.destructor = NULL,
+	.copy = (object_copy) IntObject::copy,
+	.size = sizeof(IntObject),
+	.name = "int",
+	.convesions = &IntObjectTypeConversions,
+	.ariphmetics = &IntObject::TypeAriphm,
+	.save_size = (object_save_size)save_size,
+	.save = (object_save)save,
+	.load = (object_load)load,
+};

Objects/private/primitives/linkobject.cpp

@@ -0,0 +1,132 @@
+
+#pragma once
+
+#include "NewPlacement.hpp"
+#include "primitives/linkobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void LinkObject::constructor(Object* self) {
+	NDO_CAST(LinkObject, self)->link = 0;
+}
+
+void LinkObject::destructor(LinkObject* self) {
+	if (self->link) NDO->destroy(self->link);
+}
+
+void LinkObject::copy(Object* self, const Object* in) {
+	NDO_CAST(LinkObject, self)->setLink(NDO_CAST(LinkObject, in)->link);
+}
+
+LinkObject* LinkObject::create(Object* in) {
+	NDO_CASTV(LinkObject, NDO->create("link"), out)->link = in;
+	return out;
+}
+
+alni LinkObject::save_size(LinkObject* self) {
+	return sizeof(alni);
+}
+
+void LinkObject::save(LinkObject* self, Archiver& file_self) {
+	if (self->link != NULL) {
+		alni link_object_save_adress = NDO->save(file_self, self->link);
+		file_self.write<alni>(&link_object_save_adress);
+	}
+	else {
+		alni null = -1;
+		file_self.write<alni>(&null);
+	}
+}
+
+void LinkObject::load(Archiver& file_self, LinkObject* self) {
+
+	alni saved_object_adress;
+	file_self.read<alni>(&saved_object_adress);
+
+	if (saved_object_adress == -1) {
+		self->link = NULL;
+	}
+	else {
+		self->link = NDO->load(file_self, saved_object_adress);
+	}
+}
+
+tp::Buffer<Object*> LinkObject::childs_retrival(LinkObject* self) {
+	tp::Buffer<Object*> out;
+	if (self->link) out.append(self->link);
+	return out;
+}
+
+alni LinkObject::allocated_size(LinkObject* self) {
+	return sizeof(Object*);
+}
+
+alni LinkObject::allocated_size_recursive(LinkObject* self) {
+	alni out = sizeof(Object*);
+	if (self->link) {
+		out += NDO->objsize_ram_recursive_util(self->link, self->link->type);
+	}
+	return out;
+}
+
+Object* LinkObject::getLink() {
+	return link;
+}
+
+void LinkObject::setLink(Object* obj) {
+#ifdef OBJECT_REF_COUNT
+	if (link) NDO->destroy(link);
+	if (obj) NDO->refinc(obj);
+#endif // OBJECT_REF_COUNT
+	link = obj;
+}
+
+static auto tm_set = TypeMethod{
+	.nameid = "set",
+	.descr = "sets the link",
+	.args = {
+		{ "target", NULL }
+	},
+	.exec = [](const TypeMethod* tm) {
+		auto const self = (LinkObject*)tm->self;
+		auto const target = tm->args[0].obj;
+		self->setLink(target);
+	}
+};
+
+static auto tm_get = TypeMethod{
+	.nameid = "get",
+	.descr = "gets the link",
+	.exec = [](const TypeMethod* tm) {
+		auto const self = (LinkObject*)tm->self;
+		auto link = self->getLink();
+		if (link) {
+			tm->ret.obj = link;
+		}
+	},
+	.ret = { "the link", NULL }
+};
+
+struct obj::ObjectType LinkObject::TypeData = {
+	.base = NULL,
+	.constructor = LinkObject::constructor,
+	.destructor = (object_destructor)LinkObject::destructor,
+	.copy = LinkObject::copy,
+	.size = sizeof(LinkObject),
+	.name = "link",
+	.convesions = NULL,
+	.save_size = (object_save_size)LinkObject::save_size,
+	.save = (object_save)LinkObject::save,
+	.load = (object_load)LinkObject::load,
+	.childs_retrival = (object_debug_all_childs_retrival)LinkObject::childs_retrival,
+	.allocated_size = (object_allocated_size)LinkObject::allocated_size,
+	.allocated_size_recursive = (object_allocated_size_recursive)LinkObject::allocated_size_recursive,
+
+	.type_methods = {
+		.methods = {
+			&tm_set,
+			&tm_get,
+		}
+	}
+};

Objects/private/primitives/listobject.cpp

@@ -0,0 +1,135 @@
+
+#pragma once
+
+#include "NewPlacement.hpp"
+
+#include "primitives/listobject.h"
+#include "primitives/intobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void ListObject::constructor(Object* in) {
+	NDO_CASTV(ListObject, in, self);
+	new (&self->items) List<Object*>();
+}
+
+void ListObject::copy(Object* in, const Object* target) {
+	NDO_CASTV(ListObject, in, self);
+	NDO_CASTV(ListObject, target, src);
+
+	destructor(in);
+
+	for (auto item : src->items) {
+		self->pushBack(NDO->instatiate(item.data()));
+	}
+}
+
+void ListObject::destructor(Object* in) {
+	NDO_CASTV(ListObject, in, self);
+	for (auto item : self->items) {
+		NDO->destroy(item.data());
+	}
+	self->items.removeAll();
+}
+
+alni ListObject::save_size(ListObject* self) {
+	alni len = self->items.length();
+	return (len + 1) * sizeof(alni);
+}
+
+void ListObject::save(ListObject* self, Archiver& file_self) {
+	alni len = self->items.length();
+	file_self.write<alni>(&len);
+
+	for (auto item : self->items) {
+		alni ndo_object_adress = NDO->save(file_self, item.data());
+		file_self.write<alni>(&ndo_object_adress);
+	}
+}
+
+void ListObject::load(Archiver& file_self, ListObject* self) {
+	new (&self->items) tp::List<Object*>();
+
+	alni len;
+	file_self.read<alni>(&len);
+
+	for (alni i = 0; i < len; i++) {
+		alni ndo_object_adress;
+		file_self.read<alni>(&ndo_object_adress);
+		self->items.pushBack(NDO->load(file_self, ndo_object_adress));
+	}
+}
+
+tp::Buffer<Object*> ListObject::childs_retrival(ListObject* self) {
+	tp::Buffer<Object*> out;
+	out.reserve(self->items.length());
+	ualni i = 0;
+	for (auto item : self->items) {
+		out[i] = item.data();
+		i++;
+	}
+	return out;
+}
+
+alni ListObject::allocated_size(ListObject* self) {
+	// return self->items.sizeAllocatedMem();
+	return {};
+}
+
+alni ListObject::allocated_size_recursive(ListObject* self) {
+	alni out = self->items.sizeAllocatedMem();
+	for (auto item : self->items) {
+		out += NDO->objsize_ram_recursive_util(item.data(), item->type);
+	}
+	return out;
+}
+
+void ListObject::pushBack(Object* obj) {
+#ifdef OBJECT_REF_COUNT
+	obj::NDO->refinc(obj);
+#endif // OBJECT_REF_COUNT
+	items.pushBack(obj);
+}
+
+void ListObject::pushFront(Object* obj) {
+#ifdef OBJECT_REF_COUNT
+	obj::NDO->refinc(obj);
+#endif // OBJECT_REF_COUNT
+	items.pushFront(obj);
+}
+
+void ListObject::delNode(tp::List<Object*>::Node* node) {
+#ifdef OBJECT_REF_COUNT
+	obj::NDO->destroy(node->data);
+#endif // OBJECT_REF_COUNT
+	items.deleteNode(node);
+}
+
+void ListObject::popBack() {
+#ifdef OBJECT_REF_COUNT
+	auto obj = items.last();
+	if (obj) obj::NDO->destroy(obj->data);
+#endif // OBJECT_REF_COUNT
+	items.popBack();
+}
+
+const tp::List<Object*>& ListObject::getItems() const {
+	return items;
+}
+
+struct obj::ObjectType obj::ListObject::TypeData = {
+	.base = NULL,
+	.constructor = ListObject::constructor,
+	.destructor = ListObject::destructor,
+	.copy = ListObject::copy,
+	.size = sizeof(ListObject),
+	.name = "list",
+	.convesions = NULL,
+	.save_size = (object_save_size)save_size,
+	.save = (object_save)save,
+	.load = (object_load)load,
+	.childs_retrival = (object_debug_all_childs_retrival) childs_retrival,
+	.allocated_size = (object_allocated_size) allocated_size,
+	.allocated_size_recursive = (object_allocated_size_recursive) allocated_size_recursive
+};

Objects/private/primitives/methodobject.cpp

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "NewPlacement.hpp"
+
+#include "primitives/methodobject.h"
+#include "core/scriptsection.h"
+#include "compiler/function.h"
+
+using namespace obj;
+
+struct ObjectType MethodObject::TypeData = {
+	.base = NULL,
+	.constructor = (object_constructor)MethodObject::constructor,
+	.destructor = (object_destructor)MethodObject::destructor,
+	.copy = (object_copy)MethodObject::copy,
+	.size = sizeof(MethodObject),
+	.name = "method",
+	.convesions = NULL,
+	.save_size = (object_save_size)MethodObject::save_size,
+	.save = (object_save)MethodObject::save,
+	.load = (object_load)MethodObject::load,
+};
+
+void MethodObject::constructor(MethodObject* self) {
+	self->mScript = obj::ScriptSection::globalHandle()->createScript();
+}
+
+void MethodObject::copy(MethodObject* self, MethodObject* in) {
+	obj::ScriptSection::globalHandle()->changeScript(&self->mScript, &in->mScript);
+}
+
+void MethodObject::destructor(MethodObject* self) {
+	obj::ScriptSection::globalHandle()->abandonScript(self->mScript);
+}
+
+tp::alni MethodObject::save_size(MethodObject* self) {
+	// script_table_file_address & script string object address
+	return sizeof(tp::alni);
+}
+
+void MethodObject::save(MethodObject* self, Archiver& file_self) {
+	auto script_section = obj::ScriptSection::globalHandle();
+
+	// script_table_file_address
+	tp::alni script_table_file_address = script_section->get_script_file_adress(self->mScript);
+	file_self.write<tp::alni>(&script_table_file_address);
+}
+
+void MethodObject::load(Archiver& file_self, obj::MethodObject* self) {
+	auto script_section = obj::ScriptSection::globalHandle();
+
+	// script_table_file_address
+	tp::alni script_table_file_address;
+	file_self.read<tp::alni>(&script_table_file_address);
+	self->mScript = script_section->get_scritp_from_file_adress(script_table_file_address);
+}
+
+
+void MethodObject::Initialize() {
+	obj::ScriptSection::initialize();
+	NDO->define(&MethodObject::TypeData);
+	obj::NDO->type_groups.addType(&MethodObject::TypeData, { "Primitives" });
+}
+
+void MethodObject::UnInitialize() {
+	obj::ScriptSection::uninitialize();
+}
+
+void MethodObject::compile() {
+	BCgen::Compile(this);
+}
+
+MethodObject* MethodObject::create(tp::String script) {
+	auto out = (MethodObject*)NDO->create(MethodObject::TypeData.name);
+	out->mScript->mReadable->val = script;
+	out->compile();
+	return out;
+}

Objects/private/primitives/nullobject.cpp

@@ -0,0 +1,60 @@
+
+#pragma once
+
+#include "NewPlacement.hpp"
+
+#include "primitives/nullobject.h"
+
+using namespace obj;
+using namespace tp;
+
+obj::NullObject* obj::NdoNull_globalInstance = NULL;
+bool uninit_flag = false;
+
+void NullObject::uninit() {
+	uninit_flag = true;
+	NDO->destroy(NdoNull_globalInstance);
+}
+
+void NullObject::destructor(Object* self) {
+	DEBUG_ASSERT(uninit_flag && "Only one the instance of NullObject exists and thus it can't be destroyed");
+}
+
+
+String to_string(NullObject* self) {
+	return "NULL";
+}
+
+alni to_int(NullObject* self) {
+	return 0;
+}
+
+alnf to_float(NullObject* self) {
+	return 0;
+}
+
+obj::TypeMethods* tm_construct() {
+	auto out = new obj::TypeMethods();
+	
+	return out;
+}
+
+struct ObjectTypeConversions NullObjectTypeConversions = {
+	.from_int = NULL,
+	.from_float = NULL,
+	.from_string = NULL,
+	.to_string = (object_to_string) to_string,
+	.to_int = (object_to_int) to_int,
+	.to_float = (object_to_float) to_float,
+};
+
+
+struct ObjectType NullObject::TypeData = {
+	.base = NULL,
+	.constructor = NULL,
+	.destructor = NullObject::destructor,
+	.copy = NULL,
+	.size = sizeof(NullObject),
+	.name = "null",
+	.convesions = &NullObjectTypeConversions,
+};

Objects/private/primitives/primitives.cpp

@@ -0,0 +1,83 @@
+
+#pragma once
+
+#include "NewPlacement.hpp"
+
+#include "primitives/primitives.h"
+
+#include "Tokenizer.hpp"
+
+void obj::primitives_uninitialize() {
+	obj::NullObject::uninit();
+	obj::MethodObject::UnInitialize();
+}
+
+void obj::primitives_define_types() {
+	
+	using namespace obj;
+	using namespace tp;
+
+	static bool initialized = false;
+	if (initialized) {
+		return;
+	}
+
+	DEBUG_ASSERT(NDO && "Objects library is not initialized");
+
+	NDO->define(&DictObject::TypeData);
+	NDO->define(&IntObject::TypeData);
+	NDO->define(&LinkObject::TypeData);
+	NDO->define(&ListObject::TypeData);
+	NDO->define(&NullObject::TypeData);
+	NDO->define(&StringObject::TypeData);
+	NDO->define(&BoolObject::TypeData);
+	NDO->define(&FloatObject::TypeData);
+	NDO->define(&EnumObject::TypeData);
+	NDO->define(&ClassObject::TypeData);
+	NDO->define(&ColorObject::TypeData);
+	NDO->define(&InterpreterObject::TypeData);
+	NDO->define(&TypeObject::TypeData);
+
+	NDO->type_groups.addType(&DictObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&IntObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&LinkObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&ListObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&NullObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&StringObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&BoolObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&FloatObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&EnumObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&ClassObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&ColorObject::TypeData, {"Primitives"});
+	NDO->type_groups.addType(&InterpreterObject::TypeData, { "scripting" });
+
+	obj::MethodObject::Initialize();
+
+	initialized = true;
+}
+
+namespace obj {
+	objects_api* objects_init();
+	void objects_finalize();
+};
+
+static bool objInit() {
+	obj::objects_init();
+	obj::primitives_define_types();
+	return true;
+}
+
+static void objDeinit() {
+	obj::primitives_uninitialize();
+	obj::objects_finalize();
+}
+
+static tp::ModuleManifest* sModuleDependencies[] = {
+	// &tp::gModuleCompressor,
+	&tp::gModuleMath, 
+	&tp::gModuleStrings,
+	&tp::gModuleTokenizer,
+	NULL
+};
+
+tp::ModuleManifest obj::gModuleObjects = tp::ModuleManifest("Objects", objInit, objDeinit, sModuleDependencies);

Objects/private/primitives/stringobject.cpp

@@ -0,0 +1,97 @@
+
+#pragma once
+
+#include "NewPlacement.hpp"
+
+#include "primitives/stringobject.h"
+
+using namespace obj;
+using namespace tp;
+
+void StringObject::constructor(Object* self) {
+	new (&NDO_CAST(StringObject, self)->val) String();
+}
+
+void StringObject::destructor(StringObject* self) {
+	self->val.~String();
+}
+
+void StringObject::copy(Object* self, const Object* in) {
+	NDO_CAST(StringObject, self)->val = NDO_CAST(StringObject, in)->val;
+}
+
+StringObject* StringObject::create(String in) {
+	NDO_CASTV(StringObject, NDO->create("str"), out)->val = in;
+	return out;
+}
+
+void StringObject::from_int(StringObject* self, alni in) {
+	// self->val = in;
+}
+
+void StringObject::from_float(StringObject* self, alnf in) {
+	// self->val = in;
+}
+
+void StringObject::from_string(StringObject* self, String in) {
+	// self->val = in;
+}
+
+String StringObject::to_string(StringObject* self) {
+	return self->val;
+}
+
+alni StringObject::to_int(StringObject* self) {
+	return alni(self->val);
+}
+
+alnf StringObject::to_float(StringObject* self) {
+	return alnf(self->val);
+}
+
+static alni save_size(StringObject* self) {
+	// return self->val.save_size();
+	return {};
+}
+
+static void save(StringObject* self, Archiver& file_self) {
+	self->val.save(&file_self);
+}
+
+static void load(Archiver& file_self, StringObject* self) {
+	new (&self->val) tp::String();
+	self->val.load(&file_self);
+}
+
+alni allocated_size(StringObject* self) {
+	// return self->val.sizeAllocatedMem();
+	return 0;
+}
+
+static bool compare_strings(StringObject* left, StringObject* right) {
+	return left->val == right->val;
+}
+
+struct ObjectTypeConversions StringObjectTypeConversions = {
+	.from_int = (object_from_int)StringObject::from_int,
+	.from_float = (object_from_float)StringObject::from_float,
+	.from_string = (object_from_string)StringObject::from_string,
+	.to_string = (object_to_string)StringObject::to_string,
+	.to_int = (object_to_int)StringObject::to_int,
+	.to_float = (object_to_float)StringObject::to_float,
+};
+
+struct obj::ObjectType StringObject::TypeData = {
+	.base = NULL,
+	.constructor = StringObject::constructor,
+	.destructor = (object_destructor)StringObject::destructor,
+	.copy = StringObject::copy,
+	.size = sizeof(StringObject),
+	.name = "str",
+	.convesions = &StringObjectTypeConversions,
+	.save_size = (object_save_size)save_size,
+	.save = (object_save)save,
+	.load = (object_load)load,
+	.comparison = (object_compare) compare_strings,
+	.allocated_size = (object_allocated_size) allocated_size,
+};

Objects/private/primitives/typeobject.cpp

@@ -0,0 +1,80 @@
+
+#pragma once
+
+#include "NewPlacement.hpp"
+#include "primitives/typeobject.h"
+#include "primitives/nullobject.h"
+
+using namespace obj;
+using namespace tp;
+
+TypeObject* TypeObject::create(const ObjectType* type) {
+	NDO_CASTV(TypeObject, NDO->create("typeobject"), out);
+	out->mTypeRef = type;
+	return out;
+}
+
+static alni save_size(TypeObject* self) {
+	tp::String const nameid(self->mTypeRef->name);
+	return nameid.save_size();
+}
+
+static void save(TypeObject* self, Archiver& file_self) {
+	tp::String const nameid(self->mTypeRef->name);
+	nameid.save(&file_self);
+}
+
+static void load(Archiver& file_self, TypeObject* self) {
+	tp::String nameid;
+	nameid.load(&file_self);
+
+	auto idx = NDO->types.presents(nameid);
+
+	if (idx) {
+		self->mTypeRef = NDO->types.getSlotVal(idx);
+	}
+	else {
+		self->mTypeRef = &NullObject::TypeData;
+	}
+}
+
+static alni allocated_size(TypeObject* self) {
+	return sizeof(alni);
+}
+
+static void from_string(TypeObject* self, tp::String in) {
+	auto idx = NDO->types.presents(in);
+
+	if (idx) {
+		self->mTypeRef = NDO->types.getSlotVal(idx);
+	}
+	else {
+		self->mTypeRef = &NullObject::TypeData;
+	}
+}
+
+static String to_string(TypeObject* self) {
+	return self->mTypeRef->name;
+}
+
+bool comparator(TypeObject* left, TypeObject* right) {
+	return left->mTypeRef == right->mTypeRef;
+}
+
+static struct ObjectTypeConversions conversions = {
+	.from_string = (object_from_string) from_string,
+	.to_string = (object_to_string) to_string,
+};
+
+struct obj::ObjectType TypeObject::TypeData = {
+	.base = NULL,
+	//.constructor = (object_constructor) TypeObject::constructor,
+	.size = sizeof(TypeObject),
+	.name = "typeobject",
+	.convesions = &conversions,
+	.save_size = (object_save_size) save_size,
+	.save = (object_save) save,
+	.load = (object_load) load,
+	.comparison = (object_compare) comparator,
+	.allocated_size = (object_allocated_size) allocated_size,
+};