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

2
Objects/private/compiler/Constants.cpp
View file

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

9
Objects/private/compiler/Functions.cpp
View file

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

51
Objects/private/core/Object.cpp
View file

@ -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) {
return string.size() + sizeof(string.size());
}
ualni obj::save_string_size(const std::string& string) { 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 (mh->refc > 1) {
mh->refc--;
if (in->refc > 1) {
in->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;
}

98
Objects/private/core/ObjectSave.cpp
View file

@ -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));
if (!memh) {
return nullptr;
auto object = (Object*) malloc(type->size);
if (!object) {
printf("Cant allocate memory for an object");
exit(0);
}
memh->down = nullptr;
memh->flags = 0;
object->down = nullptr;
object->flags = 0;
memh->refc = (alni) 1;
object->refc = (alni) 1;
if (bottom) {
bottom->down = memh;
bottom->down = object;
}
memh->up = bottom;
bottom = memh;
object->up = bottom;
bottom = object;
count++;
NDO_FROM_MEMH(memh)->type = type;
return NDO_FROM_MEMH(memh);
object->type = type;
return object;
}
void ObjectMemDeallocate(Object* in) {
ObjectMemHead* memh = ((ObjectMemHead*) in) - 1;
if (memh->up) {
memh->up->down = memh->down;
void ObjectMemDeallocate(Object* object) {
if (object->up) {
object->up->down = object->down;
}
if (memh->down) {
memh->down->up = memh->up;
if (object->down) {
object->down->up = object->up;
} else {
bottom = memh->up;
bottom = object->up;
}
free(memh);
free(object);
count--;
}
@ -74,22 +62,34 @@ void obj::logTypeData(const ObjectType* type) {
}
}
ualni obj::getObjCount() { return count; }
ualni obj::getObjCount() { return count; }
void obj::assertNoLeaks() {
if (bottom) {
printf("ERROR : not all objects are destroyed\n");
ualni idx = 0;
for (ObjectMemHead* memh = bottom; memh; memh = memh->up) {
printf(" ===== Object - %i. Ref count - %i ===== \n", idx, memh->refc);
logTypeData(NDO_FROM_MEMH(memh)->type);
for (Object* object = bottom; object; object = object->up) {
printf(" ===== Object - %llu. Ref count - %lli ===== \n", idx, object->refc);
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) {
return NDO_MEMH_FROM_NDO(in)->flags;
if (in->flags != -1) {
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);

6
Objects/private/core/ScriptSection.cpp
View file

@ -65,7 +65,7 @@ alni ScriptSection::get_script_file_adress(Script* in) { return get_script_head_
alni ScriptSection::save_script_table_to_file_size(ScriptSection* self, ArchiverOut& file) {
alni size = 0;
size += 5; // header
size += 5; // header
size += sizeof(alni); // scripts length
for (auto iter : self->mScripts) {
@ -84,7 +84,7 @@ alni ScriptSection::save_script_table_to_file_size(ScriptSection* self, Archiver
}
size += sizeof(alni); // objects mem offset
size += 5; // header
size += 5; // header
return size;
}
@ -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

12
Objects/private/interpreter/Interpreter.cpp
View file

@ -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");

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;