ilusha/Modules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

remove macros use in objects mofule

Browse source
This commit is contained in:
IlyaShurupov 2024-03-24 21:55:25 +03:00 • committed by Ilya Shurupov
parent c6260f7c48
commit 9e2e7f5809
31 changed files with 362 additions and 386 deletions
Download patch file Download diff file Expand all files Collapse all files

7
Objects/private/primitives/BoolObject.cpp
View file

@ -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) {
self->val = in == "true" || in == "True";
}
void BoolObject::from_string(BoolObject* self, const std::string& in) { self->val = in == "true" || in == "True"; }
std::string BoolObject::to_string(BoolObject* self) { return std::to_string(bool(self->val)); }

13
Objects/private/primitives/ClassObject.cpp
View file

@ -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));
NDO->increaseReferenceCount(self->members);
self->members = objects_api::cast<DictObject>(NDO->load(file_self, ndo_object_adress));
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 };

16
Objects/private/primitives/ColorObject.cpp
View file

@ -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),

93
Objects/private/primitives/DictObject.cpp
View file

@ -5,16 +5,9 @@
using namespace tp;
using namespace obj;
void DictObject::constructor(Object* self) {
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::constructor(DictObject* self) { new (&self->items) Map<std::string, Object*>(); }
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) {
NDO_CASTV(DictObject, self, dict);
for (auto item : dict->items) {
void DictObject::destructor(DictObject* self) {
for (auto item : self->items) {
NDO->destroy(item->val);
}
dict->items.~Map();
self->items.~Map();
}
alni DictObject::save_size(DictObject* self) {
@ -140,23 +132,25 @@ 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",
.descr = "gets the object",
.args = { { "str key", nullptr } },
.exec =
[](const TypeMethod* tm) {
auto const self = (DictObject*) tm->self;
auto str_key = tm->args[0].obj;
static auto tm_get = TypeMethod{
.nameid = "get",
.descr = "gets the object",
.args = { { "str key", nullptr } },
.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 key = objects_api::cast<StringObject>(str_key);
ASSERT(key);
auto idx = self->presents(key->val);
if (idx) {
tm->ret.obj = self->getSlotVal(idx);
}
},
.ret = { "object", nullptr } };
auto idx = self->presents(key->val);
if (idx) {
tm->ret.obj = self->getSlotVal(idx);
}
},
.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,
.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,
struct obj::ObjectType DictObject::TypeData = {
.base = nullptr,
.constructor = (object_constructor) DictObject::constructor,
.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,
.type_methods = { .methods = {
&tm_put,
&tm_remove,
&tm_get,
} } };
.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,
},
},
};

7
Objects/private/primitives/FloatObject.cpp
View file

@ -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) {
self->val = std::stof(in);
}
void FloatObject::from_string(FloatObject* self, const std::string& in) { self->val = std::stof(in); }
std::string FloatObject::to_string(FloatObject* self) { return std::to_string(self->val); }

33
Objects/private/primitives/IntObject.cpp
View file

@ -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) {
NDO_CAST(IntObject, self)->val = std::stol(in);
}
void IntObject::from_string(IntObject* self, const std::string& in) { 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_float = IntObject::from_float,
.from_string = IntObject::from_string,
.to_string = IntObject::to_string,
.to_int = IntObject::to_int,
.to_float = IntObject::to_float,
.from_int = (object_from_int) IntObject::from_int,
.from_float = (object_from_float) IntObject::from_float,
.from_string = (object_from_string) IntObject::from_string,
.to_string = (object_to_string) IntObject::to_string,
.to_int = (object_to_int) IntObject::to_int,
.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),

8
Objects/private/primitives/InterpreterObject.cpp
View file

@ -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;
}

88
Objects/private/primitives/LinkObject.cpp
View file

@ -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,39 +66,55 @@ 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) {
auto const self = (LinkObject*) tm->self;
auto const target = tm->args[0].obj;
self->setLink(target);
} };
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",
.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", nullptr } };
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", nullptr },
};
struct obj::ObjectType LinkObject::TypeData = { .base = nullptr,
.constructor = LinkObject::constructor,
.destructor = (object_destructor) LinkObject::destructor,
.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,
struct obj::ObjectType LinkObject::TypeData = {
.base = nullptr,
.type_methods = { .methods = {
&tm_set,
&tm_get,
} } };
.constructor = (object_constructor) LinkObject::constructor,
.destructor = (object_destructor) LinkObject::destructor,
.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 = {
&tm_set,
&tm_get,
},
},
};

52
Objects/private/primitives/ListObject.cpp
View file

@ -5,28 +5,22 @@
using namespace tp;
using namespace obj;
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);
void ListObject::constructor(ListObject* self) { new (&self->items) List<Object*>(); }
void ListObject::copy(ListObject* in, const ListObject* target) {
destructor(in);
constructor(in);
for (auto item : src->items) {
self->pushBack(NDO->instantiate(item.data()));
for (auto item : target->items) {
in->pushBack(objects_api::instantiate(item.data()));
}
}
void ListObject::destructor(Object* in) {
NDO_CASTV(ListObject, in, self);
for (auto item : self->items) {
void ListObject::destructor(ListObject* in) {
for (auto item : in->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,
.constructor = ListObject::constructor,
.destructor = ListObject::destructor,
.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 };
struct obj::ObjectType obj::ListObject::TypeData = {
.base = nullptr,
.constructor = (object_constructor) ListObject::constructor,
.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,
};

19
Objects/private/primitives/Stringobject.cpp
View file

@ -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) {
return save_string_size(self->val);
}
static alni save_size(StringObject* self) { return save_string_size(self->val); }
static void save(StringObject* self, ArchiverOut& file_self) {
save_string(file_self, self->val);
}
static void save(StringObject* self, ArchiverOut& file_self) { 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,

10
Objects/private/primitives/TypeObject.cpp
View file

@ -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) {
return save_string_size(self->mTypeRef->name);
}
static alni save_size(TypeObject* self) { return save_string_size(self->mTypeRef->name); }
static void save(TypeObject* self, ArchiverOut& file_self) {
save_string(file_self, self->mTypeRef->name);
}
static void save(TypeObject* self, ArchiverOut& file_self) { save_string(file_self, self->mTypeRef->name); }
static void load(ArchiverIn& file_self, TypeObject* self) {
std::string nameid;