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
parent 0fb9326c08
commit 7927226484
31 changed files with 362 additions and 386 deletions
Download patch file Download diff file Expand all files Collapse all files

52
Objects/applications/GUI.cpp
View file

@ -161,8 +161,8 @@ void obj::ObjectsGUI::cdup() {
}
void obj::ObjectsGUI::preview(obj::Object* obj) {
if (NDO_CAST(obj::LinkObject, obj)) {
NDO_CASTV(obj::LinkObject, obj, linko);
if (objects_api::cast<LinkObject>(obj)) {
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)) {
tp::alni& val = NDO_CAST(obj::IntObject, obj)->val;
} else if (objects_api::cast<IntObject>(obj)) {
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)) {
NDO_CASTV(obj::StringObject, obj, stringo);
} else if (objects_api::cast<StringObject>(obj)) {
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)) {
tp::alnf& val = NDO_CAST(obj::FloatObject, obj)->val;
} else if (objects_api::cast<FloatObject>(obj)) {
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) {

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

96
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--;
}
@ -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) {
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);

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

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

47
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,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,
.constructor = DictObject::constructor,
.destructor = DictObject::destructor,
.copy = DictObject::copy,
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,
.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,
} } };
},
},
};

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

40
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,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,
.constructor = LinkObject::constructor,
struct obj::ObjectType LinkObject::TypeData = {
.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,
} } };
},
},
};

36
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,
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 };
.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;

71
Objects/public/core/Object.hpp
View file

@ -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 {
ObjectMemHead* up;
ObjectMemHead* down;
struct Object {
Object* up;
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 alni(*object_to_int)(Object* self);
typedef alnf(*object_to_float)(Object* self);
typedef std::string (*object_to_string)(Object* self);
typedef alni (*object_to_int)(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
typedef void (pre_save_callback)(void* self, ArchiverOut&);
typedef void (pre_load_callback)(void* self, ArchiverIn&);
typedef void (post_save_callback)(void* self, ArchiverOut&);
typedef void (post_load_callback)(void* self, ArchiverIn&);
typedef alni (slcb_size_callback)(void* self, ArchiverOut&);
#define SAVE_LOAD_MAX_CALLBACK_SLOTS 100
typedef void(pre_save_callback)(void* self, ArchiverOut&);
typedef void(pre_load_callback)(void* self, ArchiverIn&);
typedef void(post_save_callback)(void* self, ArchiverOut&);
typedef void(post_load_callback)(void* self, ArchiverIn&);
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 halni getReferenceCount(Object* in);
private:
static void setReferenceCount(Object* in, halni count);
public:
static inline void increaseReferenceCount(Object* in) { in->refc++; }
static inline alni getReferenceCount(Object* in) { return in->refc; }
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);
}
}

7
Objects/public/interpreter/OperandsStack.hpp
View file

@ -10,12 +10,9 @@ namespace tp::obj {
class OperandStack {
enum : alni {
MAX_STACK_SIZE = 512
};
enum : alni { 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;
}

10
Objects/public/primitives/ClassObject.hpp
View file

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

2
Objects/public/primitives/ColorObject.hpp
View file

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

6
Objects/public/primitives/DictObject.hpp
View file

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

14
Objects/public/primitives/IntObject.hpp
View file

@ -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_float(Object* self, alnf in);
static void from_string(Object* self, const std::string& in);
static std::string to_string(Object* self);
static alni to_int(Object* self);
static alnf to_float(Object* self);
static void from_int(IntObject* self, alni in);
static void from_float(IntObject* self, alnf in);
static void from_string(IntObject* self, const std::string& in);
static std::string to_string(IntObject* self);
static alni to_int(IntObject* self);
static alnf to_float(IntObject* self);
};
}

5
Objects/public/primitives/LinkObject.hpp
View file

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

6
Objects/public/primitives/ListObject.hpp
View file

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

5
Objects/public/primitives/StringObject.hpp
View file

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

4
Objects/tests/TestCompiler.cpp
View file

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

6
Objects/tests/TestCore.cpp
View file

@ -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(integer->val == NDO_CAST(IntObject, savedInt)->val);
CHECK(objects_api::cast<IntObject>(savedInt));
CHECK(integer->val == objects_api::cast<IntObject>(savedInt)->val);
NDO->destroy(integer);
NDO->destroy(savedInt);

18
Objects/tests/TestInterpreter.cpp
View file

@ -49,8 +49,8 @@ SUITE(Interpreter) {
objTestModule.initialize();
{
auto method = NDO_CAST(MethodObject, NDO->create("method"));
auto interpreter = NDO_CAST(InterpreterObject, NDO->create("interpreter"));
auto method = objects_api::cast<MethodObject>(NDO->create("method"));
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 interpreter = NDO_CAST(InterpreterObject, NDO->create("interpreter"));
auto method = objects_api::cast<MethodObject>(NDO->create("method"));
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 interpreter = NDO_CAST(InterpreterObject, NDO->create("interpreter"));
auto method = objects_api::cast<MethodObject>(NDO->create("method"));
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 interpreter = NDO_CAST(InterpreterObject, NDO->create("interpreter"));
auto method = objects_api::cast<MethodObject>(NDO->create("method"));
auto interpreter = objects_api::cast<InterpreterObject>(NDO->create("interpreter"));
interpreter->getMember<LinkObject>("target method")->setLink(method);

8
Objects/tests/TestPrimitives.cpp
View file

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