remove macros use in objects mofule

Objects/applications/GUI.cpp

@@ -161,8 +161,8 @@ void obj::ObjectsGUI::cdup() {
 }
 
 void obj::ObjectsGUI::preview(obj::Object* obj) {
-	if (NDO_CAST(obj::LinkObject, obj)) {
+	if (objects_api::cast<LinkObject>(obj)) {
-		NDO_CASTV(obj::LinkObject, obj, linko);
+		auto linko = objects_api::cast<LinkObject>(obj);
 
 		bool no_link_preview = !linko->getLink();
 		tp::alni max_depth = 5;
@@ -170,7 +170,7 @@ void obj::ObjectsGUI::preview(obj::Object* obj) {
 		tp::Map<tp::alni, tp::alni> link_lookup;
 		obj::LinkObject* link_iter = linko;
 		while (link_iter && link_iter->getLink() && !no_link_preview) {
-			link_iter = NDO_CAST(obj::LinkObject, link_iter->getLink());
+			link_iter = objects_api::cast<LinkObject>(link_iter->getLink());
 			depth_count++;
 
 			if (link_lookup.presents(tp::alni(link_iter))) {
@@ -192,13 +192,13 @@ void obj::ObjectsGUI::preview(obj::Object* obj) {
 		} else {
 			ImGui::Text("Link Is Null");
 		}
-	} else if (NDO_CAST(obj::IntObject, obj)) {
+	} else if (objects_api::cast<IntObject>(obj)) {
-		tp::alni& val = NDO_CAST(obj::IntObject, obj)->val;
+		tp::alni& val = objects_api::cast<IntObject>(obj)->val;
 		int gui_val = int(val);
 		ImGui::InputInt(" ", &gui_val);
 		val = tp::alni(gui_val);
-	} else if (NDO_CAST(obj::StringObject, obj)) {
+	} else if (objects_api::cast<StringObject>(obj)) {
-		NDO_CASTV(obj::StringObject, obj, stringo);
+		auto stringo = objects_api::cast<StringObject>(obj);
 		static char val[2048] = { " " };
 		if (stringo->val != val) {
 			assert(stringo->val.size() < 2048);
@@ -208,17 +208,17 @@ void obj::ObjectsGUI::preview(obj::Object* obj) {
 		if (stringo->val != val) {
 			stringo->val = val;
 		}
-	} else if (NDO_CAST(obj::BoolObject, obj)) {
+	} else if (objects_api::cast<BoolObject>(obj)) {
 		boolView((obj::BoolObject*) obj);
-	} else if (NDO_CAST(obj::FloatObject, obj)) {
+	} else if (objects_api::cast<FloatObject>(obj)) {
-		tp::alnf& val = NDO_CAST(obj::FloatObject, obj)->val;
+		tp::alnf& val = objects_api::cast<FloatObject>(obj)->val;
 		auto gui_val = float(val);
 		ImGui::InputFloat(" ", &gui_val);
 		val = tp::alnf(gui_val);
 
-	} else if (NDO_CAST(obj::EnumObject, obj)) {
+	} else if (objects_api::cast<EnumObject>(obj)) {
 		enumView((obj::EnumObject*) obj);
-	} else if (NDO_CAST(obj::ColorObject, obj)) {
+	} else if (objects_api::cast<ColorObject>(obj)) {
 		colorView((obj::ColorObject*) obj);
 	} else {
 		ImGui::Text(obj->type->name);
@@ -967,34 +967,34 @@ void obj::ObjectsGUI::explorer() {
 	ImGui::Separator();
 
 	ViewStackNode new_active;
-	if (NDO_CAST(obj::NullObject, mActive)) {
+	if (objects_api::cast<NullObject>(mActive)) {
 		new_active = nullView((obj::NullObject*) mActive);
-	} else if (NDO_CAST(obj::LinkObject, mActive)) {
+	} else if (objects_api::cast<LinkObject>(mActive)) {
 		new_active = linkoView((obj::LinkObject*) mActive);
-	} else if (NDO_CAST(obj::IntObject, mActive)) {
+	} else if (objects_api::cast<IntObject>(mActive)) {
 		new_active = intoView((obj::IntObject*) mActive);
-	} else if (NDO_CAST(obj::StringObject, mActive)) {
+	} else if (objects_api::cast<StringObject>(mActive)) {
 		new_active = stringView((obj::StringObject*) mActive);
-	} else if (NDO_CAST(obj::ListObject, mActive)) {
+	} else if (objects_api::cast<ListObject>(mActive)) {
 		new_active = listView((obj::ListObject*) mActive);
-	} else if (NDO_CAST(obj::DictObject, mActive)) {
+	} else if (objects_api::cast<DictObject>(mActive)) {
 		new_active = dictView((obj::DictObject*) mActive);
-	} else if (NDO_CAST(obj::InterpreterObject, mActive)) {
+	} else if (objects_api::cast<InterpreterObject>(mActive)) {
 		new_active = interpreterView((obj::InterpreterObject*) mActive);
-	} else if (NDO_CAST(obj::ClassObject, mActive)) {
+	} else if (objects_api::cast<ClassObject>(mActive)) {
 		new_active = classView((obj::ClassObject*) mActive);
-	} else if (NDO_CAST(obj::BoolObject, mActive)) {
+	} else if (objects_api::cast<BoolObject>(mActive)) {
 		new_active = boolView((obj::BoolObject*) mActive);
-	} else if (NDO_CAST(obj::FloatObject, mActive)) {
+	} else if (objects_api::cast<FloatObject>(mActive)) {
 		new_active = floatView((obj::FloatObject*) mActive);
-	} else if (NDO_CAST(obj::EnumObject, mActive)) {
+	} else if (objects_api::cast<EnumObject>(mActive)) {
 		new_active = enumView((obj::EnumObject*) mActive);
-	} else if (NDO_CAST(obj::MethodObject, mActive)) {
+	} else if (objects_api::cast<MethodObject>(mActive)) {
 		new_active = methodView((obj::MethodObject*) mActive);
-	} else if (NDO_CAST(obj::ColorObject, mActive)) {
+	} else if (objects_api::cast<ColorObject>(mActive)) {
 		new_active = colorView((obj::ColorObject*) mActive);
 	} else {
-		ImGui::Text("Preview is Unavaliable");
+		ImGui::Text("Preview is Unavailable");
 	}
 
 	if (new_active != 0) {

Objects/private/compiler/Constants.cpp

@@ -100,7 +100,7 @@ ConstObject* ConstObjectsPool::get(bool val) {
 }
 
 ConstObject* ConstObjectsPool::addMethod(const std::string& method_id, Object* method) {
-	ASSERT(NDO_CAST(MethodObject, method) && "Object is not a method object")
+	ASSERT(objects_api::cast<MethodObject>(method) && "Object is not a method object")
 	ASSERT(!mMethods.presents(method_id) && "Method Redefinition")
 	auto out = registerObject(method);
 	mMethods.put(method_id, out);

Objects/private/compiler/Functions.cpp

@@ -31,7 +31,8 @@ ConstObject* FunctionDefinition::defineLocal(const std::string& id) {
 	return const_str_id;
 }
 
-FunctionDefinition::FunctionDefinition(const std::string& function_id, const Buffer<std::string>& args, FunctionDefinition*) {
+FunctionDefinition::
+	FunctionDefinition(const std::string& function_id, const Buffer<std::string>& args, FunctionDefinition*) {
 	mFunctionId = function_id;
 	inst(Instruction(OpCode::SAVE_ARGS, (alni) args.size(), 1));
 	for (auto id : args) {
@@ -126,7 +127,7 @@ void FunctionDefinition::EvalStatement(Statement* stm) {
 				mLocals.put(func.mFunctionId, mConstants.get(func.mFunctionId));
 
 				// create and register const func object
-				auto function_obj = NDO_CAST(MethodObject, NDO->create("method"));
+				auto function_obj = objects_api::cast<MethodObject>(NDO->create("method"));
 				auto method_const_obj = mConstants.addMethod(func.mFunctionId, function_obj);
 
 				for (auto child_stm : stm_func_def->mStatements->mStatements) {
@@ -154,7 +155,7 @@ void FunctionDefinition::EvalStatement(Statement* stm) {
 				mLocals.put(func.mFunctionId, mConstants.get(func.mFunctionId));
 
 				// create and register const func object
-				auto function_obj = NDO_CAST(MethodObject, NDO->create("method"));
+				auto function_obj = objects_api::cast<MethodObject>(NDO->create("method"));
 				auto method_const_obj = mConstants.addMethod(func.mFunctionId, function_obj);
 
 				// compile function
@@ -410,7 +411,7 @@ alni instSize(const Instruction& inst) {
 
 void writeConst(ByteCode& out, alni& idx, uint2 data) {
 	for (auto byte : Range(sizeof(uint2))) {
-		out.mInstructions[idx] = OpCode((int1)(data >> byte * 8));
+		out.mInstructions[idx] = OpCode((int1) (data >> byte * 8));
 		idx++;
 	}
 }

Objects/private/core/Object.cpp

@@ -14,9 +14,7 @@ void obj::save_string(ArchiverOut& file, const std::string& string) {
 	file.writeBytes(string.c_str(), string.size());
 }
 
-ualni obj::save_string_size(const std::string& string) {
+ualni obj::save_string_size(const std::string& string) { return string.size() + sizeof(string.size()); }
-	return string.size() + sizeof(string.size());
-}
 
 void obj::load_string(ArchiverIn& file, std::string& out) {
 	typeof(out.size()) size;
@@ -29,7 +27,7 @@ void obj::load_string(ArchiverIn& file, std::string& out) {
 }
 
 Object* ObjectMemAllocate(const ObjectType* type);
-void ObjectMemDeallocate(Object* in);
+void ObjectMemDeallocate(Object* object);
 
 objects_api* obj::NDO = nullptr;
 
@@ -68,14 +66,14 @@ Object* objects_api::create(const std::string& name) {
 
 	setReferenceCount(obj_instance, 0);
 
-	NDO_CASTV(ClassObject, obj_instance, classobj);
+	auto classobj = objects_api::cast<ClassObject>(obj_instance);
 
 	if (classobj) {
 		auto idx = classobj->members->presents("__init__");
 		DEBUG_ASSERT(idx)
 		if (idx) {
 			auto constructor_obj = classobj->members->getSlotVal(idx);
-			NDO_CASTV(MethodObject, constructor_obj, constructor_method);
+			auto constructor_method = objects_api::cast<MethodObject>(constructor_obj);
 			if (constructor_method) {
 				interp->execAll(constructor_method, classobj);
 			}
@@ -102,7 +100,8 @@ bool objects_api::compare(Object* first, Object* second) {
 		}
 
 		// raw data comparison
-		return memCompare(first, second, first->type->size) == 0;
+		// TODO : reconsider
+		return memCompare(first->type, second->type, first->type->size - sizeof(Object) + sizeof(void*)) == 0;
 	}
 
 	return false;
@@ -110,7 +109,7 @@ bool objects_api::compare(Object* first, Object* second) {
 
 Object* objects_api::instantiate(Object* in) {
 	obj::Object* obj = NDO->create(in->type->name);
-	NDO->copy(obj, in);
+	tp::obj::objects_api::copy(obj, in);
 	return obj;
 }
 
@@ -163,19 +162,18 @@ void objects_api::destroy(Object* in) const {
 		return;
 	}
 
-	ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
+	if (in->refc > 1) {
-	if (mh->refc > 1) {
+		in->refc--;
-		mh->refc--;
 		return;
 	}
 
-	NDO_CASTV(ClassObject, in, classobj);
+	auto classobj = objects_api::cast<ClassObject>(in);
 	if (classobj) {
 		auto idx = classobj->members->presents("__del__");
 		DEBUG_ASSERT(idx)
 		if (idx) {
 			auto constructor_obj = classobj->members->getSlotVal(idx);
-			NDO_CASTV(MethodObject, constructor_obj, constructor_method);
+			auto constructor_method = objects_api::cast<MethodObject>(constructor_obj);
 			if (constructor_method) {
 				interp->execAll(constructor_method, classobj);
 			}
@@ -191,22 +189,6 @@ void objects_api::destroy(Object* in) const {
 	ObjectMemDeallocate(in);
 }
 
-halni objects_api::getReferenceCount(Object* in) {
-	ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
-	return (halni) mh->refc;
-}
-
-void objects_api::increaseReferenceCount(Object* in) {
-	ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
-	mh->refc++;
-}
-
-void objects_api::setReferenceCount(Object* in, halni count) {
-	ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
-	mh->refc = count;
-}
-
-
 void hierarchy_copy(Object* self, const Object* in, const ObjectType* type) {
 	if (type->base) {
 		hierarchy_copy(self, in, type->base);
@@ -226,14 +208,3 @@ void hierarchy_construct(Object* self, const ObjectType* type) {
 		type->constructor(self);
 	}
 }
-
-Object* obj::ndo_cast(const Object* in, const ObjectType* to_type) {
-	const ObjectType* typeIter = in->type;
-	while (typeIter) {
-		if (typeIter == to_type) {
-			return (Object*) in;
-		}
-		typeIter = typeIter->base;
-	}
-	return nullptr;
-}

Objects/private/core/ObjectSave.cpp

@@ -9,60 +9,48 @@
 using namespace tp;
 using namespace obj;
 
-ObjectMemHead* bottom = nullptr;
+Object* bottom = nullptr;
 ualni count = 0;
 
-struct ObjectsFileHeader {
-	char name[10] = { 0 };
-	char version[10] = { 0 };
-
-	ObjectsFileHeader(bool default_val = true) {
-		if (default_val) {
-			memCopy(&name, "objects", 8);
-			memCopy(&version, "0", 2);
-		}
-	}
-};
-
 Object* ObjectMemAllocate(const ObjectType* type) {
-	ObjectMemHead* memh = (ObjectMemHead*) malloc(type->size + sizeof(ObjectMemHead));
+	auto object = (Object*) malloc(type->size);
-	if (!memh) {
+
-		return nullptr;
+	if (!object) {
+		printf("Cant allocate memory for an object");
+		exit(0);
 	}
 
-	memh->down = nullptr;
+	object->down = nullptr;
-	memh->flags = 0;
+	object->flags = 0;
 
-	memh->refc = (alni) 1;
+	object->refc = (alni) 1;
 
 	if (bottom) {
-		bottom->down = memh;
+		bottom->down = object;
 	}
 
-	memh->up = bottom;
+	object->up = bottom;
-	bottom = memh;
+	bottom = object;
 
 	count++;
 
-	NDO_FROM_MEMH(memh)->type = type;
+	object->type = type;
-	return NDO_FROM_MEMH(memh);
+
+	return object;
 }
 
-void ObjectMemDeallocate(Object* in) {
+void ObjectMemDeallocate(Object* object) {
-	ObjectMemHead* memh = ((ObjectMemHead*) in) - 1;
+	if (object->up) {
-
+		object->up->down = object->down;
-	if (memh->up) {
-		memh->up->down = memh->down;
 	}
 
-	if (memh->down) {
+	if (object->down) {
-		memh->down->up = memh->up;
+		object->down->up = object->up;
 	} else {
-		bottom = memh->up;
+		bottom = object->up;
 	}
 
-	free(memh);
+	free(object);
-
 	count--;
 }
 
@@ -80,16 +68,28 @@ void obj::assertNoLeaks() {
 	if (bottom) {
 		printf("ERROR : not all objects are destroyed\n");
 		ualni idx = 0;
-		for (ObjectMemHead* memh = bottom; memh; memh = memh->up) {
+		for (Object* object = bottom; object; object = object->up) {
-			printf(" ===== Object - %i. Ref count - %i ===== \n", idx, memh->refc);
+			printf(" ===== Object - %llu. Ref count - %lli ===== \n", idx, object->refc);
-			logTypeData(NDO_FROM_MEMH(memh)->type);
+			logTypeData(object->type);
 			idx++;
 		}
 	}
 }
 
+struct ObjectsFileHeader {
+	char name[10] = { 0 };
+	char version[10] = { 0 };
+
+	explicit ObjectsFileHeader(bool default_val = true) {
+		if (default_val) {
+			memCopy(&name, "objects", 8);
+			memCopy(&version, "0", 2);
+		}
+	}
+};
+
 struct ObjectFileHead {
-	Object* load_head_adress = 0;
+	Object* load_head_adress = nullptr;
 	halni refc = 0;
 };
 
@@ -97,13 +97,11 @@ int1* loaded_file = nullptr;
 
 void objects_api::clear_object_flags() {
 	// clear all object flags
-	for (ObjectMemHead* iter = bottom; iter; iter = iter->up) {
+	for (Object* iter = bottom; iter; iter = iter->up) {
 		iter->flags = -1;
 	}
 }
 
-alni& getObjectFlags(Object* in) { return NDO_MEMH_FROM_NDO(in)->flags; }
-
 alni objsize_ram_util(Object* self, const ObjectType* type) {
 	alni out = 0;
 
@@ -128,11 +126,11 @@ alni objects_api::objsize_ram_recursive_util(Object* self, const ObjectType* typ
 	alni out = 0;
 
 	if (different_object) {
-		if (getObjectFlags(self) == 1) {
+		if (self->flags == 1) {
 			return 0;
 		}
 
-		getObjectFlags(self) = 1;
+		self->flags = 1;
 	}
 
 	if (type->allocated_size_recursive) {
@@ -177,7 +175,7 @@ alni objects_api::objsize_file(Object* self) { return objsize_file_util(self, se
 alni objsize_file_recursive_util(Object* self, const ObjectType* type) {
 	alni out = 0;
 
-	getObjectFlags(self) = 1;
+	self->flags = 1;
 
 	if (type->save_size) {
 		out += type->save_size(self);
@@ -186,7 +184,7 @@ alni objsize_file_recursive_util(Object* self, const ObjectType* type) {
 	if (type->childs_retrival) {
 		Buffer<Object*> childs = type->childs_retrival(self);
 		for (auto child : childs) {
-			if (getObjectFlags(child.data()) != 1) {
+			if (child.data()->flags != 1) {
 				out += objsize_file_recursive_util(child.data(), child.data()->type);
 			}
 		}
@@ -217,8 +215,8 @@ void object_recursive_save(ArchiverOut& ndf, Object* self, const ObjectType* typ
 
 alni objects_api::save(ArchiverOut& ndf, Object* in) {
 	// if already saved return file_adress
-	if (NDO_MEMH_FROM_NDO(in)->flags != -1) {
+	if (in->flags != -1) {
-		return NDO_MEMH_FROM_NDO(in)->flags;
+		return in->flags;
 	}
 
 	// save write adress for parent save function call
@@ -228,13 +226,13 @@ alni objects_api::save(ArchiverOut& ndf, Object* in) {
 	alni save_adress = ndf.getFreeAddress();
 
 	// save file_adress in memhead
-	NDO_MEMH_FROM_NDO(in)->flags = save_adress;
+	in->flags = save_adress;
 
 	// update write adress
 	ndf.setAddress(save_adress);
 
 	// save file object header
-	ObjectFileHead ofh = { 0, getReferenceCount(in) };
+	ObjectFileHead ofh = { 0, (halni) getReferenceCount(in) };
 	ndf << ofh;
 
 	save_string(ndf, in->type->name);

Objects/private/core/ScriptSection.cpp

@@ -141,7 +141,7 @@ void load_constants(ScriptSection* self, ArchiverIn& file, alni start_addr) {
 		file >> str_addr;
 
 		NDO->destroy(script->mReadable); // we already have string object in the script when creating script
-		script->mReadable = NDO_CAST(obj::StringObject, obj::NDO->load(file, str_addr));
+		script->mReadable = objects_api::cast<StringObject>(obj::NDO->load(file, str_addr));
 
 		file.setAddress(file.getAddress() + sizeof(alni)); // constants length
 

Objects/private/interpreter/Interpreter.cpp

@@ -145,7 +145,7 @@ void Interpreter::stepBytecodeIn() {
 			{
 				auto idx = loadConstDataIdx(bytecode);
 				auto const_obj = bytecode->mConstants[idx];
-				NDO_CASTV(StringObject, const_obj, local_id);
+				auto local_id = objects_api::cast<StringObject>(const_obj);
 				ASSERT(local_id && "Invalid Object Type");
 				auto local = mScopeStack.getLocal(local_id->val);
 				mOperandsStack.push(local);
@@ -267,7 +267,8 @@ void Interpreter::stepBytecodeIn() {
 
 				// class creation
 				auto local_class = mScopeStack.getLocal(type->val);
-				NDO_CASTV(MethodObject, local_class, method);
+
+				auto method = objects_api::cast<MethodObject>(local_class);
 				ASSERT(method);
 
 				// class is a function - execute it as a constructor
@@ -336,7 +337,7 @@ void Interpreter::stepBytecodeIn() {
 					NDO->increaseReferenceCount(argument);
 
 					auto argument_id = bytecode->mConstants[loadConstDataIdx(bytecode)];
-					NDO_CASTV(StringObject, argument_id, id);
+					auto id = objects_api::cast<StringObject>(argument_id);
 					DEBUG_ASSERT(id);
 					mScopeStack.addLocal(argument, id->val);
 					bytecode->mArgumentsLoaded++;
@@ -367,7 +368,7 @@ void Interpreter::stepBytecodeIn() {
 				auto obj = mOperandsStack.getOperand();
 
 				if (!mIsTypeMethod) {
-					NDO_CASTV(MethodObject, obj, method);
+					auto method = objects_api::cast<MethodObject>(obj);
 
 					mScopeStack.enterScope(false);
 					mCallStack.enter({ nullptr, method, 0 });
@@ -470,7 +471,8 @@ void Interpreter::stepBytecodeIn() {
 					mIsTypeMethod = true;
 
 				} else {
-					NDO_CASTV(ClassObject, parent, class_obj);
+					auto class_obj = objects_api::cast<ClassObject>(parent);
+
 					ASSERT(class_obj && "not a class object");
 					auto idx = class_obj->members->presents(child_id->val);
 					ASSERT(idx && "No child with such id");

Objects/private/primitives/BoolObject.cpp

@@ -10,7 +10,8 @@ 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);
+	auto out = objects_api::cast<BoolObject>(NDO->create("bool"));
+	out->val = alni(in);
 	return out;
 }
 
@@ -18,9 +19,7 @@ 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, const std::string& in) {
+void BoolObject::from_string(BoolObject* self, const std::string& in) { self->val = in == "true" || in == "True"; }
-	self->val = in == "true" || in == "True";
-}
 
 std::string BoolObject::to_string(BoolObject* self) { return std::to_string(bool(self->val)); }
 

Objects/private/primitives/ClassObject.cpp

@@ -7,13 +7,15 @@ using namespace tp;
 using namespace obj;
 
 void ClassObject::constructor(ClassObject* self) {
-	self->members = NDO_CAST(DictObject, NDO->create("dict"));
+	self->members = objects_api::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::copy(ClassObject* self, const ClassObject* blueprint) {
+	NDO->copy(self->members, blueprint->members);
+}
 
 void ClassObject::destructor(ClassObject* self) { NDO->destroy(self->members); }
 
@@ -37,8 +39,8 @@ void ClassObject::save(ClassObject* self, ArchiverOut& file_self) {
 void ClassObject::load(ArchiverIn& file_self, ClassObject* self) {
 	alni ndo_object_adress;
 	file_self >> ndo_object_adress;
-	self->members = NDO_CAST(DictObject, NDO->load(file_self, ndo_object_adress));
+	self->members = objects_api::cast<DictObject>(NDO->load(file_self, ndo_object_adress));
-	NDO->increaseReferenceCount(self->members);
+	tp::obj::objects_api::increaseReferenceCount(self->members);
 }
 
 tp::Buffer<Object*> childs_retrival(ClassObject* self) {
@@ -66,4 +68,5 @@ struct ObjectType ClassObject::TypeData = { .base = nullptr,
 																						.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 };
+																						.allocated_size_recursive =
+																							(object_allocated_size_recursive) allocated_size_recursive };

Objects/private/primitives/ColorObject.cpp

@@ -4,22 +4,26 @@
 using namespace tp;
 using namespace obj;
 
-void ColorObject::constructor(Object* self) { NDO_CAST(ColorObject, self)->mCol = tp::RGBA(1.f); }
+void ColorObject::constructor(ColorObject* self) { 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;
+	auto out = objects_api::cast<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_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)); }
+void ColorObject::from_float(ColorObject* self, alnf in) { self->mCol = tp::RGBA(tp::clamp((tp::halnf) in, 0.f, 1.f)); }
 
 std::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));
+	// 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 {};
 }
@@ -52,7 +56,7 @@ struct ObjectTypeAriphmetics ColorObject::TypeAriphm = {
 
 struct obj::ObjectType obj::ColorObject::TypeData = {
 	.base = nullptr,
-	.constructor = ColorObject::constructor,
+	.constructor = (object_constructor) ColorObject::constructor,
 	.destructor = nullptr,
 	.copy = (object_copy) ColorObject::copy,
 	.size = sizeof(ColorObject),

Objects/private/primitives/DictObject.cpp

@@ -5,16 +5,9 @@
 using namespace tp;
 using namespace obj;
 
-void DictObject::constructor(Object* self) {
+void DictObject::constructor(DictObject* self) { new (&self->items) Map<std::string, Object*>(); }
-	NDO_CASTV(DictObject, self, dict);
-
-	new (&dict->items) Map<std::string, Object*>();
-}
-
-void DictObject::copy(Object* in, const Object* target) {
-	NDO_CASTV(DictObject, in, self);
-	NDO_CASTV(DictObject, target, src);
 
+void DictObject::copy(DictObject* self, const DictObject* src) {
 	destructor(self);
 	constructor(self);
 
@@ -24,12 +17,11 @@ void DictObject::copy(Object* in, const Object* target) {
 	}
 }
 
-void DictObject::destructor(Object* self) {
+void DictObject::destructor(DictObject* self) {
-	NDO_CASTV(DictObject, self, dict);
+	for (auto item : self->items) {
-	for (auto item : dict->items) {
 		NDO->destroy(item->val);
 	}
-	dict->items.~Map();
+	self->items.~Map();
 }
 
 alni DictObject::save_size(DictObject* self) {
@@ -140,7 +132,8 @@ Object* DictObject::getSlotVal(tp::Map<std::string, Object*>::Idx idx) { return
 
 const tp::Map<std::string, Object*>& DictObject::getItems() const { return items; }
 
-static auto tm_get = TypeMethod{ .nameid = "get",
+static auto tm_get = TypeMethod{
+	.nameid = "get",
 	.descr = "gets the object",
 	.args = { { "str key", nullptr } },
 	.exec =
@@ -148,7 +141,7 @@ static auto tm_get = TypeMethod{ .nameid = "get",
 			auto const self = (DictObject*) tm->self;
 			auto str_key = tm->args[0].obj;
 
-																		 NDO_CASTV(StringObject, str_key, key);
+			auto key = objects_api::cast<StringObject>(str_key);
 			ASSERT(key);
 
 			auto idx = self->presents(key->val);
@@ -156,7 +149,8 @@ static auto tm_get = TypeMethod{ .nameid = "get",
 				tm->ret.obj = self->getSlotVal(idx);
 			}
 		},
-																 .ret = { "object", nullptr } };
+	.ret = { "object", nullptr },
+};
 
 static auto tm_put = TypeMethod{
 	.nameid = "put",
@@ -169,7 +163,7 @@ static auto tm_put = TypeMethod{
 			auto str_key = tm->args[0].obj;
 			auto obj = tm->args[1].obj;
 
-			NDO_CASTV(StringObject, str_key, key);
+			auto key = objects_api::cast<StringObject>(str_key);
 			ASSERT(key);
 
 			self->put(key->val, obj);
@@ -187,28 +181,33 @@ static auto tm_remove = TypeMethod{
 
 		auto str_key = tm->args[0].obj;
 		
-		NDO_CASTV(StringObject, str_key, key);
+		auto key = objects_api::cast<StringObject>(str_key);
 		ASSERT(key);
 
 		self->remove(key->val);
 	},
 };
 
-struct obj::ObjectType DictObject::TypeData = { .base = nullptr,
+struct obj::ObjectType DictObject::TypeData = {
-																								.constructor = DictObject::constructor,
+	.base = nullptr,
-																								.destructor = DictObject::destructor,
+	.constructor = (object_constructor) DictObject::constructor,
-																								.copy = DictObject::copy,
+	.destructor = (object_destructor) DictObject::destructor,
+	.copy = (object_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 = {
+	.type_methods = {
+		.methods = {
 			&tm_put,
 			&tm_remove,
 			&tm_get,
-																																	} } };
+		},
+	},
+};

Objects/private/primitives/FloatObject.cpp

@@ -8,7 +8,8 @@ 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);
+	auto out = objects_api::cast<FloatObject>(NDO->create("float"));
+	out->val = alnf(in);
 	return out;
 }
 
@@ -16,9 +17,7 @@ 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, const std::string& in) {
+void FloatObject::from_string(FloatObject* self, const std::string& in) { self->val = std::stof(in); }
-	self->val = std::stof(in);
-}
 
 std::string FloatObject::to_string(FloatObject* self) { return std::to_string(self->val); }
 

Objects/private/primitives/IntObject.cpp

@@ -4,28 +4,27 @@
 using namespace tp;
 using namespace obj;
 
-void IntObject::constructor(Object* self) { NDO_CAST(IntObject, self)->val = 0; }
+void IntObject::constructor(IntObject* self) { 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;
+	auto out = objects_api::cast<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_int(IntObject* self, alni in) { self->val = in; }
 
-void IntObject::from_float(Object* self, alnf in) { NDO_CAST(IntObject, self)->val = (alni) in; }
+void IntObject::from_float(IntObject* self, alnf in) { self->val = (alni) in; }
 
-void IntObject::from_string(Object* self, const std::string& in) {
+void IntObject::from_string(IntObject* self, const std::string& in) { self->val = std::stol(in); }
-	NDO_CAST(IntObject, self)->val = std::stol(in);
-}
 
-std::string IntObject::to_string(Object* self) { return std::to_string(NDO_CAST(IntObject, self)->val); }
+std::string IntObject::to_string(IntObject* self) { return std::to_string(self->val); }
 
-alni IntObject::to_int(Object* self) { return alni(NDO_CAST(IntObject, self)->val); }
+alni IntObject::to_int(IntObject* self) { return alni(self->val); }
 
-alnf IntObject::to_float(Object* self) { return alnf(NDO_CAST(IntObject, self)->val); }
+alnf IntObject::to_float(IntObject* self) { return alnf(self->val); }
 
 static alni save_size(IntObject* self) { return sizeof(alni); }
 
@@ -34,12 +33,12 @@ static void save(IntObject* self, ArchiverOut& file_self) { file_self << self->v
 static void load(ArchiverIn& file_self, IntObject* self) { file_self >> self->val; }
 
 struct ObjectTypeConversions IntObjectTypeConversions = {
-	.from_int = IntObject::from_int,
+	.from_int = (object_from_int) IntObject::from_int,
-	.from_float = IntObject::from_float,
+	.from_float = (object_from_float) IntObject::from_float,
-	.from_string = IntObject::from_string,
+	.from_string = (object_from_string) IntObject::from_string,
-	.to_string = IntObject::to_string,
+	.to_string = (object_to_string) IntObject::to_string,
-	.to_int = IntObject::to_int,
+	.to_int = (object_to_int) IntObject::to_int,
-	.to_float = IntObject::to_float,
+	.to_float = (object_to_float) IntObject::to_float,
 };
 
 void divide(IntObject* self, IntObject* in) { self->val /= in->val; }
@@ -59,7 +58,7 @@ struct ObjectTypeAriphmetics IntObject::TypeAriphm = {
 
 struct obj::ObjectType obj::IntObject::TypeData = {
 	.base = nullptr,
-	.constructor = IntObject::constructor,
+	.constructor = (object_constructor) IntObject::constructor,
 	.destructor = nullptr,
 	.copy = (object_copy) IntObject::copy,
 	.size = sizeof(IntObject),

Objects/private/primitives/InterpreterObject.cpp

@@ -15,7 +15,9 @@ void InterpreterObject::constructor(InterpreterObject* self) {
 
 void InterpreterObject::destructor(InterpreterObject* self) { self->mInterpreter.~Interpreter(); }
 
-void InterpreterObject::load(ArchiverIn& file_self, InterpreterObject* self) { new (&self->mInterpreter) Interpreter(); }
+void InterpreterObject::load(ArchiverIn& file_self, InterpreterObject* self) {
+	new (&self->mInterpreter) Interpreter();
+}
 
 bool InterpreterObject::running() { return !mInterpreter.finished(); }
 
@@ -35,7 +37,7 @@ void InterpreterObject::exec(obj::ClassObject* self, tp::InitialierList<Interpre
 		return;
 	}
 
-	NDO_CASTV(obj::MethodObject, target, method);
+	auto method = objects_api::cast<MethodObject>(target);
 	if (!method || !method->mScript->mBytecode.mInstructions.size()) {
 		return;
 	}
@@ -58,7 +60,7 @@ void InterpreterObject::debug() {
 		return;
 	}
 
-	NDO_CASTV(obj::MethodObject, target, method);
+	auto method = objects_api::cast<MethodObject>(target);
 	if (!method || !method->mScript->mBytecode.mInstructions.size()) {
 		return;
 	}

Objects/private/primitives/LinkObject.cpp

@@ -4,16 +4,16 @@
 using namespace tp;
 using namespace obj;
 
-void LinkObject::constructor(Object* self) { NDO_CAST(LinkObject, self)->link = 0; }
+void LinkObject::constructor(LinkObject* self) { self->link = nullptr; }
 
 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); }
+void LinkObject::copy(LinkObject* self, const LinkObject* in) { self->setLink(in->link); }
 
 LinkObject* LinkObject::create(Object* in) {
-	NDO_CASTV(LinkObject, NDO->create("link"), out)->link = in;
+	auto out = objects_api::cast<LinkObject>(NDO->create("link"));
 	return out;
 }
 
@@ -66,13 +66,20 @@ void LinkObject::setLink(Object* obj) {
 	link = obj;
 }
 
-static auto tm_set = TypeMethod{ .nameid = "set", .descr = "sets the link", .args = { { "target", nullptr } }, .exec = [](const TypeMethod* tm) {
+static auto tm_set = TypeMethod{
+	.nameid = "set",
+	.descr = "sets the link",
+	.args = { { "target", nullptr } },
+	.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",
+static auto tm_get = TypeMethod{
+	.nameid = "get",
 	.descr = "gets the link",
 	.exec =
 		[](const TypeMethod* tm) {
@@ -82,23 +89,32 @@ static auto tm_get = TypeMethod{ .nameid = "get",
 				tm->ret.obj = link;
 			}
 		},
-																 .ret = { "the link", nullptr } };
+	.ret = { "the link", nullptr },
+};
 
-struct obj::ObjectType LinkObject::TypeData = { .base = nullptr,
+struct obj::ObjectType LinkObject::TypeData = {
-																								.constructor = LinkObject::constructor,
+	.base = nullptr,
+
+	.constructor = (object_constructor) LinkObject::constructor,
 	.destructor = (object_destructor) LinkObject::destructor,
-																								.copy = LinkObject::copy,
+	.copy = (object_copy) LinkObject::copy,
 	.size = sizeof(LinkObject),
 	.name = "link",
+
 	.convesions = nullptr,
+
 	.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 = {
+	.type_methods = {
+		.methods = {
 			&tm_set,
 			&tm_get,
-																																	} } };
+		},
+	},
+};

Objects/private/primitives/ListObject.cpp

@@ -5,28 +5,22 @@
 using namespace tp;
 using namespace obj;
 
-void ListObject::constructor(Object* in) {
+void ListObject::constructor(ListObject* self) { new (&self->items) List<Object*>(); }
-	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);
 
+void ListObject::copy(ListObject* in, const ListObject* target) {
 	destructor(in);
+	constructor(in);
 
-	for (auto item : src->items) {
+	for (auto item : target->items) {
-		self->pushBack(NDO->instantiate(item.data()));
+		in->pushBack(objects_api::instantiate(item.data()));
 	}
 }
 
-void ListObject::destructor(Object* in) {
+void ListObject::destructor(ListObject* in) {
-	NDO_CASTV(ListObject, in, self);
+	for (auto item : in->items) {
-	for (auto item : self->items) {
 		NDO->destroy(item.data());
 	}
-	self->items.removeAll();
+	in->items.removeAll();
 }
 
 alni ListObject::save_size(ListObject* self) {
@@ -106,16 +100,20 @@ void ListObject::popBack() {
 
 const tp::List<Object*>& ListObject::getItems() const { return items; }
 
-struct obj::ObjectType obj::ListObject::TypeData = { .base = nullptr,
+struct obj::ObjectType obj::ListObject::TypeData = {
-																										 .constructor = ListObject::constructor,
+	.base = nullptr,
-																										 .destructor = ListObject::destructor,
+	.constructor = (object_constructor) ListObject::constructor,
-																										 .copy = ListObject::copy,
+	.destructor = (object_destructor) ListObject::destructor,
+	.copy = (object_copy) ListObject::copy,
 	.size = sizeof(ListObject),
 	.name = "list",
 	.convesions = nullptr,
+	
 	.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 };
+	.allocated_size_recursive = (object_allocated_size_recursive) allocated_size_recursive,
+};

Objects/private/primitives/Stringobject.cpp

@@ -5,14 +5,15 @@
 using namespace tp;
 using namespace obj;
 
-void StringObject::constructor(Object* self) { new (&NDO_CAST(StringObject, self)->val) std::string(); }
+void StringObject::constructor(StringObject* self) { new (&self->val) std::string(); }
 
 void StringObject::destructor(StringObject* self) { self->val.~basic_string(); }
 
-void StringObject::copy(Object* self, const Object* in) { NDO_CAST(StringObject, self)->val = NDO_CAST(StringObject, in)->val; }
+void StringObject::copy(StringObject* self, const StringObject* in) { self->val = in->val; }
 
 StringObject* StringObject::create(const std::string& in) {
-	NDO_CASTV(StringObject, NDO->create("str"), out)->val = in;
+	auto out = objects_api::cast<StringObject>(NDO->create("str"));
+	out->val = in;
 	return out;
 }
 
@@ -34,13 +35,9 @@ alni StringObject::to_int(StringObject* self) { return std::stoi(self->val); }
 
 alnf StringObject::to_float(StringObject* self) { return std::stof(self->val); }
 
-static alni save_size(StringObject* self) {
+static alni save_size(StringObject* self) { return save_string_size(self->val); }
-	return save_string_size(self->val);
-}
 
-static void save(StringObject* self, ArchiverOut& file_self) {
+static void save(StringObject* self, ArchiverOut& file_self) { save_string(file_self, self->val); }
-	save_string(file_self, self->val);
-}
 
 static void load(ArchiverIn& file_self, StringObject* self) {
 	new (&self->val) std::string();
@@ -65,9 +62,9 @@ struct ObjectTypeConversions StringObjectTypeConversions = {
 
 struct obj::ObjectType StringObject::TypeData = {
 	.base = nullptr,
-	.constructor = StringObject::constructor,
+	.constructor = (object_constructor) StringObject::constructor,
 	.destructor = (object_destructor) StringObject::destructor,
-	.copy = StringObject::copy,
+	.copy = (object_copy) StringObject::copy,
 	.size = sizeof(StringObject),
 	.name = "str",
 	.convesions = &StringObjectTypeConversions,

Objects/private/primitives/TypeObject.cpp

@@ -6,18 +6,14 @@ using namespace tp;
 using namespace obj;
 
 TypeObject* TypeObject::create(const ObjectType* type) {
-	NDO_CASTV(TypeObject, NDO->create("typeobject"), out);
+	auto out = objects_api::cast<TypeObject>(NDO->create("typeobject"));
 	out->mTypeRef = type;
 	return out;
 }
 
-static alni save_size(TypeObject* self) {
+static alni save_size(TypeObject* self) { return save_string_size(self->mTypeRef->name); }
-	return save_string_size(self->mTypeRef->name);
-}
 
-static void save(TypeObject* self, ArchiverOut& file_self) {
+static void save(TypeObject* self, ArchiverOut& file_self) { save_string(file_self, self->mTypeRef->name); }
-	save_string(file_self, self->mTypeRef->name);
-}
 
 static void load(ArchiverIn& file_self, TypeObject* self) {
 	std::string nameid;

Objects/public/core/Object.hpp

@@ -23,43 +23,27 @@ define base type
 define struct members
 implement construct, destruct and copy methods */
 
-
-#ifdef _DEBUG
-#define NDO_CAST(cast_type, ptr) ((cast_type*)ndo_cast(ptr, &cast_type::TypeData))
-#define NDO_CAST_ASSERT(cast_type, ptr) {assert(ndo_cast(ptr, &cast_type::TypeData))}
-#else
-#define NDO_CAST_ASSERT(cast_type, ptr) {assert(ndo_cast(ptr, &cast_type::TypeData))}
-#define NDO_CAST(cast_type, ptr) ((cast_type*)ndo_cast(ptr, &cast_type::TypeData))
-#endif
-
-#define NDO_CASTV(cast_type, ptr, var_name) cast_type* var_name = NDO_CAST(cast_type, ptr); var_name
-
-#define NDO_MEMH_FROM_NDO(ndo_ptr) (((ObjectMemHead*)ndo_ptr) - 1)
-#define NDO_FROM_MEMH(ndo_ptr) ((Object*)(ndo_ptr + 1))
-
 namespace tp::obj {
 
 	extern ModuleManifest gModuleObjects;
 
 	extern struct objects_api* NDO;
 
-	struct ObjectMemHead {
+	struct Object {
-		ObjectMemHead* up;
+		Object* up;
-		ObjectMemHead* down;
+		Object* down;
 		alni flags;
 		alni refc;
-	};
 
-	struct Object {
 		const struct ObjectType* type;
 	};
 
 	typedef void (*object_from_int)(Object* self, alni in);
 	typedef void (*object_from_float)(Object* self, alnf in);
 	typedef void (*object_from_string)(Object* self, const std::string& in);
-	typedef std::string(*object_to_string)(Object* self);
+	typedef std::string (*object_to_string)(Object* self);
-	typedef alni(*object_to_int)(Object* self);
+	typedef alni (*object_to_int)(Object* self);
-	typedef alnf(*object_to_float)(Object* self);
+	typedef alnf (*object_to_float)(Object* self);
 
 	struct ObjectTypeConversions {
 		object_from_int from_int;
@@ -86,7 +70,7 @@ namespace tp::obj {
 	typedef void (*object_destructor)(Object* self);
 	typedef void (*object_copy)(Object* self, const Object* target);
 
-	typedef alni(*object_save_size)(Object* self);
+	typedef alni (*object_save_size)(Object* self);
 	typedef void (*object_save)(Object*, ArchiverOut&);
 	typedef void (*object_load)(ArchiverIn&, Object*);
 
@@ -117,13 +101,12 @@ namespace tp::obj {
 		TypeMethods type_methods;
 	};
 
-
+#define SAVE_LOAD_MAX_CALLBACK_SLOTS 100
-	#define SAVE_LOAD_MAX_CALLBACK_SLOTS 100
+	typedef void(pre_save_callback)(void* self, ArchiverOut&);
-	typedef void (pre_save_callback)(void* self, ArchiverOut&);
+	typedef void(pre_load_callback)(void* self, ArchiverIn&);
-	typedef void (pre_load_callback)(void* self, ArchiverIn&);
+	typedef void(post_save_callback)(void* self, ArchiverOut&);
-	typedef void (post_save_callback)(void* self, ArchiverOut&);
+	typedef void(post_load_callback)(void* self, ArchiverIn&);
-	typedef void (post_load_callback)(void* self, ArchiverIn&);
+	typedef alni(slcb_size_callback)(void* self, ArchiverOut&);
-	typedef alni (slcb_size_callback)(void* self, ArchiverOut&);
 
 	struct save_load_callbacks {
 		void* self;
@@ -134,7 +117,6 @@ namespace tp::obj {
 		post_load_callback* post_load;
 	};
 
-
 	struct objects_api {
 
 		Map<std::string, const ObjectType*> types;
@@ -162,12 +144,13 @@ namespace tp::obj {
 
 		void destroy(Object* in) const;
 
-		static void increaseReferenceCount(Object* in);
+		static inline void increaseReferenceCount(Object* in) { in->refc++; }
-		static halni getReferenceCount(Object* in);
+		static inline alni getReferenceCount(Object* in) { return in->refc; }
-	private:
-		static void setReferenceCount(Object* in, halni count);
-	public:
 
+	private:
+		static inline void setReferenceCount(Object* in, halni count) { in->refc = count; }
+
+	public:
 		save_load_callbacks* sl_callbacks[SAVE_LOAD_MAX_CALLBACK_SLOTS]{};
 		alni sl_callbacks_load_idx = 0;
 
@@ -184,16 +167,26 @@ namespace tp::obj {
 		Object* load(const std::string& path);
 		alni save(ArchiverOut&, Object*);
 		Object* load(ArchiverIn&, alni file_adress);
+
+		template <typename Type>
+		static Type* cast(const Object* in) {
+			const ObjectType* typeIter = in->type;
+			while (typeIter) {
+				if (typeIter == &Type::TypeData) {
+					return (Type*) in;
+				}
+				typeIter = typeIter->base;
+			}
+			return nullptr;
+		}
 	};
 
 	void logTypeData(const ObjectType* type);
 	void assertNoLeaks();
 	ualni getObjCount();
 
-	Object* ndo_cast(const Object* in, const ObjectType* to_type);
-
 	template <typename Type>
 	Type* create() {
-		return (Type*)NDO->create(Type::TypeData.name);
+		return (Type*) NDO->create(Type::TypeData.name);
 	}
 }

Objects/public/interpreter/OperandsStack.hpp

@@ -10,12 +10,9 @@ namespace tp::obj {
 
 	class OperandStack {
 
-		enum : alni {
+		enum : alni { MAX_STACK_SIZE = 512 };
-			MAX_STACK_SIZE = 512
-		};
 
 	public:
-
 		Operand* mBuff;
 		ualni mIdx;
 
@@ -28,7 +25,7 @@ namespace tp::obj {
 		template <typename ObjectType>
 		ObjectType* getOperand() {
 			auto operand = getOperand();
-			auto ret = NDO_CAST(ObjectType, operand);
+			auto ret = objects_api::cast<ObjectType>(operand);
 			ASSERT(ret && "Operand Has Invalid Object Type");
 			return ret;
 		}

Objects/public/primitives/ClassObject.hpp

@@ -19,7 +19,7 @@ namespace tp::obj {
 		void addMember(Object* obj, const std::string& id);
 		void createMember(const std::string& type, const std::string& id);
 
-		template<typename Type>
+		template <typename Type>
 		Type* createMember(const std::string& id) {
 			auto out = NDO->create(Type::TypeData.name);
 			addMember(out, id);
@@ -27,19 +27,19 @@ namespace tp::obj {
 			return (Type*) out;
 		}
 
-		template<typename Type>
+		template <typename Type>
 		Type* getMember(const std::string& id) {
 			auto idx = members->presents(id);
 			if (bool(idx)) {
-				return ((Type*)ndo_cast(members->getSlotVal(idx), &Type::TypeData));
+				return objects_api::cast<Type>(members->getSlotVal(idx));
 			}
 			return NULL;
 		}
 
-		template<typename Type>
+		template <typename Type>
 		Type* getMemberAssert(const std::string& id) {
 			auto out = getMember<Type>(id);
-			assert(out && "invalid member access");
+			ASSERT(out && "invalid member access")
 			return out;
 		}
 	};

Objects/public/primitives/ColorObject.hpp

@@ -12,7 +12,7 @@ namespace tp::obj {
 		static ObjectType TypeData;
 		static ObjectTypeAriphmetics TypeAriphm;
 
-		static void constructor(Object* self);
+		static void constructor(ColorObject* self);
 		static void copy(ColorObject* self, const ColorObject* in);
 
 		static void from_int(ColorObject* self, alni in);

Objects/public/primitives/DictObject.hpp

@@ -6,9 +6,9 @@ namespace tp::obj {
 
 	struct DictObject : Object {
 		static ObjectType TypeData;
-		static void copy(Object* self, const Object* in);
+		static void copy(DictObject* self, const DictObject* in);
-		static void destructor(Object* self);
+		static void destructor(DictObject* self);
-		static void constructor(Object* self);
+		static void constructor(DictObject* self);
 
 		static alni save_size(DictObject* self);
 		static void save(DictObject* self, ArchiverOut& file_self);

Objects/public/primitives/IntObject.hpp

@@ -11,15 +11,15 @@ namespace tp::obj {
 		static ObjectType TypeData;
 		static ObjectTypeAriphmetics TypeAriphm;
 
-		static void constructor(Object* self);
+		static void constructor(IntObject* self);
 		static void copy(IntObject* self, const IntObject* in);
 		static IntObject* create(alni in);
 
-		static void from_int(Object* self, alni in);
+		static void from_int(IntObject* self, alni in);
-		static void from_float(Object* self, alnf in);
+		static void from_float(IntObject* self, alnf in);
-		static void from_string(Object* self, const std::string& in);
+		static void from_string(IntObject* self, const std::string& in);
-		static std::string to_string(Object* self);
+		static std::string to_string(IntObject* self);
-		static alni to_int(Object* self);
+		static alni to_int(IntObject* self);
-		static alnf to_float(Object* self);
+		static alnf to_float(IntObject* self);
 	};
 }

Objects/public/primitives/LinkObject.hpp

@@ -7,9 +7,10 @@ namespace tp::obj {
 
 	struct LinkObject : Object {
 		static ObjectType TypeData;
-		static void constructor(Object* self);
+
+		static void constructor(LinkObject* self);
 		static void destructor(LinkObject* self);
-		static void copy(Object* self, const Object* in);
+		static void copy(LinkObject* self, const LinkObject* in);
 		static LinkObject* create(Object* in);
 
 		static alni save_size(LinkObject* self);

Objects/public/primitives/ListObject.hpp

@@ -12,9 +12,9 @@ namespace tp::obj {
 
 	struct ListObject : Object {
 		static ObjectType TypeData;
-		static void constructor(Object* self);
+		static void constructor(ListObject* self);
-		static void copy(Object* self, const Object* in);
+		static void copy(ListObject* self, const ListObject* in);
-		static void destructor(Object* self);
+		static void destructor(ListObject* self);
 
 		static alni allocated_size_recursive(ListObject* self);
 		static alni allocated_size(ListObject* self);

Objects/public/primitives/StringObject.hpp

@@ -9,9 +9,10 @@ namespace tp::obj {
 		std::string val;
 
 		static ObjectType TypeData;
-		static void constructor(Object* self);
+		static void constructor(StringObject* self);
 		static void destructor(StringObject* self);
-		static void copy(Object* self, const Object* in);
+		static void copy(StringObject* self, const StringObject* in);
+
 		static StringObject* create(const std::string& in);
 
 		static void from_int(StringObject* self, alni in);

Objects/tests/TestCompiler.cpp

@@ -18,7 +18,7 @@ SUITE(Compiler) {
 
 		{
 			// no errors
-			auto method = NDO_CAST(MethodObject, NDO->create("method"));
+			auto method = objects_api::cast<MethodObject>(NDO->create("method"));
 
 			method->mScript->mReadable->val = "print 1 * 20 + 10;";
 			method->compile();
@@ -30,7 +30,7 @@ SUITE(Compiler) {
 
 		{
 			// with errors
-			auto method = NDO_CAST(MethodObject, NDO->create("method"));
+			auto method = objects_api::cast<MethodObject>(NDO->create("method"));
 
 			method->mScript->mReadable->val = "print undefinedVariable;";
 			method->compile();

Objects/tests/TestCore.cpp

@@ -13,7 +13,7 @@ SUITE(Core) {
 		objTestModule.initialize();
 
 		{
-			auto integer = NDO_CAST(IntObject, NDO->create("int"));
+			auto integer = objects_api::cast<IntObject>(NDO->create("int"));
 
 			integer->val = 10;
 
@@ -25,8 +25,8 @@ SUITE(Core) {
 			printf("%s\n", NDO->toString(savedInt).c_str());
 
 			CHECK(NDO->compare(integer, savedInt));
-			CHECK(NDO_CAST(IntObject, savedInt));
+			CHECK(objects_api::cast<IntObject>(savedInt));
-			CHECK(integer->val == NDO_CAST(IntObject, savedInt)->val);
+			CHECK(integer->val == objects_api::cast<IntObject>(savedInt)->val);
 
 			NDO->destroy(integer);
 			NDO->destroy(savedInt);

Objects/tests/TestInterpreter.cpp

@@ -49,8 +49,8 @@ SUITE(Interpreter) {
 		objTestModule.initialize();
 
 		{
-			auto method = NDO_CAST(MethodObject, NDO->create("method"));
+			auto method = objects_api::cast<MethodObject>(NDO->create("method"));
-			auto interpreter = NDO_CAST(InterpreterObject, NDO->create("interpreter"));
+			auto interpreter = objects_api::cast<InterpreterObject>(NDO->create("interpreter"));
 
 			interpreter->getMember<LinkObject>("target method")->setLink(method);
 
@@ -71,8 +71,8 @@ SUITE(Interpreter) {
 		objTestModule.initialize();
 
 		{
-			auto method = NDO_CAST(MethodObject, NDO->create("method"));
+			auto method = objects_api::cast<MethodObject>(NDO->create("method"));
-			auto interpreter = NDO_CAST(InterpreterObject, NDO->create("interpreter"));
+			auto interpreter = objects_api::cast<InterpreterObject>(NDO->create("interpreter"));
 
 			interpreter->getMember<LinkObject>("target method")->setLink(method);
 
@@ -83,7 +83,7 @@ SUITE(Interpreter) {
 
 			NDO->save(interpreter, "interp.o");
 
-			auto interpreterLoaded = NDO_CAST(InterpreterObject, NDO->load("interp.o"));
+			auto interpreterLoaded = objects_api::cast<InterpreterObject>(NDO->load("interp.o"));
 
 			interpreterLoaded->exec();
 
@@ -102,8 +102,8 @@ SUITE(Interpreter) {
 		{
 			auto compileStartCount = getObjCount();
 
-			auto method = NDO_CAST(MethodObject, NDO->create("method"));
+			auto method = objects_api::cast<MethodObject>(NDO->create("method"));
-			auto interpreter = NDO_CAST(InterpreterObject, NDO->create("interpreter"));
+			auto interpreter = objects_api::cast<InterpreterObject>(NDO->create("interpreter"));
 
 			interpreter->getMember<LinkObject>("target method")->setLink(method);
 
@@ -143,8 +143,8 @@ SUITE(Interpreter) {
 		objTestModule.initialize();
 
 		{
-			auto method = NDO_CAST(MethodObject, NDO->create("method"));
+			auto method = objects_api::cast<MethodObject>(NDO->create("method"));
-			auto interpreter = NDO_CAST(InterpreterObject, NDO->create("interpreter"));
+			auto interpreter = objects_api::cast<InterpreterObject>(NDO->create("interpreter"));
 
 			interpreter->getMember<LinkObject>("target method")->setLink(method);
 

Objects/tests/TestPrimitives.cpp

@@ -16,19 +16,19 @@ SUITE(PrimitiveObjects) {
 		objTestModule.initialize();
 
 		{
-			auto integer = NDO_CAST(IntObject, NDO->create("int"));
+			auto integer = objects_api::cast<IntObject>(NDO->create("int"));
 			integer->val = 10;
 
-			auto dict = NDO_CAST(DictObject, NDO->create("dict"));
+			auto dict = objects_api::cast<DictObject>(NDO->create("dict"));
 
 			dict->put("val", integer);
 
 			NDO->save(dict, "dict.o");
 
-			auto dictLoaded = NDO_CAST(DictObject, NDO->load("dict.o"));
+			auto dictLoaded = objects_api::cast<DictObject>(NDO->load("dict.o"));
 
 			CHECK(dictLoaded->presents("val").isValid());
-			CHECK(NDO_CAST(IntObject, dictLoaded->get("val"))->val == 10);
+			CHECK(objects_api::cast<IntObject>(dictLoaded->get("val"))->val == 10);
 
 			NDO->destroy(dict);
 			NDO->destroy(dictLoaded);