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

Apply formating to all files. CLeanup

Browse source
This commit is contained in:
IlyaShurupov 2023-10-22 17:07:28 +03:00
parent 43e374f269
commit 744c01c5d0
928 changed files with 14515 additions and 21480 deletions
Download patch file Download diff file Expand all files Collapse all files

132
Objects/private/primitives/boolobject.cpp
View file

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

154
Objects/private/primitives/classobject.cpp
View file

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

148
Objects/private/primitives/colorobject.cpp
View file

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

451
Objects/private/primitives/dictobject.cpp
View file

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

357
Objects/private/primitives/enumobject.cpp
View file

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

172
Objects/private/primitives/floatobject.cpp
View file

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

158
Objects/private/primitives/interpreterobject.cpp
View file

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

176
Objects/private/primitives/intobject.cpp
View file

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

242
Objects/private/primitives/linkobject.cpp
View file

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

270
Objects/private/primitives/listobject.cpp
View file

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

139
Objects/private/primitives/methodobject.cpp
View file

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

108
Objects/private/primitives/nullobject.cpp
View file

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

172
Objects/private/primitives/stringobject.cpp
View file

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

150
Objects/private/primitives/typeobject.cpp
View file

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