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 • committed by Ilya Shurupov
parent b4ae5dde77
commit 91fb72bd49
928 changed files with 14515 additions and 21479 deletions
Download patch file Download diff file Expand all files Collapse all files

95
Objects/applications/Compiler.cpp
View file

@ -1,49 +1,48 @@
#include "Compiler/Compiler.h"
#include "primitives/primitives.h"
#include "MethodObject/MethodObject.h"
#include "log.h"
using namespace osc;
using namespace tp;
using namespace obj;
int main(int argc, char* argv[]) {
tp::alloc_init();
string::Initialize();
Logger::init();
objects_init();
primitives_define_types();
MethodObject::Initialize();
{
Compiler compiler;
tp::string script;
RelAssert(argc == 2 && "Invalid Arguments");
script.loadFile(argv[1]);
compiler.compile(script);
GLog->write("oscc : compilation finished", 1);
}
try {
MethodObject::UnInitialize();
objects_finalize();
primitives_uninitialize();
Logger::deinit();
string::UnInitialize();
tp::alloc_uninit();
}
catch (...) {
tp::terminate();
}
#include "Compiler/Compiler.h"
#include "MethodObject/MethodObject.h"
#include "log.h"
#include "primitives/primitives.h"
using namespace osc;
using namespace tp;
using namespace obj;
int main(int argc, char* argv[]) {
tp::alloc_init();
string::Initialize();
Logger::init();
objects_init();
primitives_define_types();
MethodObject::Initialize();
{
Compiler compiler;
tp::string script;
RelAssert(argc == 2 && "Invalid Arguments");
script.loadFile(argv[1]);
compiler.compile(script);
GLog->write("oscc : compilation finished", 1);
}
try {
MethodObject::UnInitialize();
objects_finalize();
primitives_uninitialize();
Logger::deinit();
string::UnInitialize();
tp::alloc_uninit();
} catch (...) {
tp::terminate();
}
}

286
Objects/applications/GUI.cpp
View file

@ -20,9 +20,7 @@ namespace ImGui {
bool ishovered = false;
tp::Vec2F p1;
tp::Vec2F p2;
operator bool() {
return opened;
}
operator bool() { return opened; }
};
PopupData HoverPopupBegin(const char* id, tp::Vec2F size, tp::Vec2F pos = tp::Vec2F(-1), int flags = 0);
@ -40,8 +38,7 @@ ImGui::PopupData ImGui::HoverPopupBegin(const char* str_id, tp::Vec2F size, tp::
if (pos_p == tp::Vec2F(-1)) {
pos = GImGui->CurrentWindow->DC.CursorPos;
}
else {
} else {
pos.x = pos_p.x;
pos.y = pos_p.y;
}
@ -62,7 +59,6 @@ ImGui::PopupData ImGui::HoverPopupBegin(const char* str_id, tp::Vec2F size, tp::
out.p1 = { pos.x, pos.y };
out.p2 = out.p1;
out.p2.x += ImGui::GetWindowWidth();
}
return out;
}
@ -87,7 +83,6 @@ void ImGui::HoverPopupEnd(ImGui::PopupData& in) {
EndPopup();
}
obj::ObjectsGUI::~ObjectsGUI() {
if (mClipboard) {
obj::NDO->destroy(mClipboard);
@ -109,9 +104,7 @@ void obj::ObjectsGUI::setClipboard(obj::Object* obj) {
}
}
obj::Object* obj::ObjectsGUI::getClipboard() {
return mClipboard;
}
obj::Object* obj::ObjectsGUI::getClipboard() { return mClipboard; }
obj::Object* imgui_object_create_menu(obj::TypeGroups* type_group = NULL) {
@ -134,8 +127,7 @@ obj::Object* imgui_object_create_menu(obj::TypeGroups* type_group = NULL) {
if (ImGui::Button((childo->key).read(), { 100, 0 })) {
if (childo->key == "null") {
newo = NDO_NULL;
}
else {
} else {
newo = obj::NDO->create(childo->key);
}
}
@ -144,9 +136,7 @@ obj::Object* imgui_object_create_menu(obj::TypeGroups* type_group = NULL) {
return newo;
}
obj::ObjectsGUI::ObjectsGUI() {
assert(obj::NDO && "Objects library is not initialized");
}
obj::ObjectsGUI::ObjectsGUI() { assert(obj::NDO && "Objects library is not initialized"); }
void obj::ObjectsGUI::cd(obj::Object* child, tp::String name) {
mActive = child;
@ -178,8 +168,7 @@ void obj::ObjectsGUI::preview(obj::Object* obj) {
if (link_lookup.presents(tp::alni(link_iter))) {
no_link_preview = true;
}
else {
} else {
link_lookup.put(tp::alni(link_iter), 0);
}
no_link_preview |= max_depth < depth_count;
@ -190,22 +179,18 @@ void obj::ObjectsGUI::preview(obj::Object* obj) {
ImGui::Text("=> ");
ImGui::SameLine();
preview(linko->getLink());
}
else {
} else {
ImGui::Text("Max preview depth exceeded");
}
}
else {
} else {
ImGui::Text("Link Is Null");
}
}
else if (NDO_CAST(obj::IntObject, obj)) {
} else if (NDO_CAST(obj::IntObject, obj)) {
tp::alni& val = NDO_CAST(obj::IntObject, obj)->val;
int gui_val = int(val);
ImGui::InputInt(" ", &gui_val);
val = tp::alni(gui_val);
}
else if (NDO_CAST(obj::StringObject, obj)) {
} else if (NDO_CAST(obj::StringObject, obj)) {
NDO_CASTV(obj::StringObject, obj, stringo);
static char val[2048] = { " " };
if (stringo->val != val) {
@ -216,25 +201,21 @@ void obj::ObjectsGUI::preview(obj::Object* obj) {
if (stringo->val != val) {
stringo->val = val;
}
}
else if (NDO_CAST(obj::BoolObject, obj)) {
boolView((obj::BoolObject*)obj);
}
else if (NDO_CAST(obj::FloatObject, obj)) {
} else if (NDO_CAST(obj::BoolObject, obj)) {
boolView((obj::BoolObject*) obj);
} else if (NDO_CAST(obj::FloatObject, obj)) {
tp::alnf& val = NDO_CAST(obj::FloatObject, obj)->val;
auto gui_val = float(val);
ImGui::InputFloat(" ", &gui_val);
val = tp::alnf(gui_val);
}
else if (NDO_CAST(obj::EnumObject, obj)) {
enumView((obj::EnumObject*)obj);
}
else if (NDO_CAST(obj::ColorObject, obj)) {
colorView((obj::ColorObject*)obj);
}
else {
ImGui::Text(obj->type->name); ImGui::SameLine();
} else if (NDO_CAST(obj::EnumObject, obj)) {
enumView((obj::EnumObject*) obj);
} else if (NDO_CAST(obj::ColorObject, obj)) {
colorView((obj::ColorObject*) obj);
} else {
ImGui::Text(obj->type->name);
ImGui::SameLine();
ImGui::Text(" (No Preview) ");
}
}
@ -261,12 +242,15 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::interpreterView(obj::Interpreter
}
// running state
BeginChild("dockable"); {
BeginChild("dockable");
{
auto id = ImGui::GetCurrentWindow()->ID;
DockSpace(id);
} EndChild();
}
EndChild();
Begin("ByteCodeView"); {
Begin("ByteCodeView");
{
if (Button("Step")) {
interp.stepBytecode();
@ -299,21 +283,21 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::interpreterView(obj::Interpreter
const auto bytecode = interp.mCallStack.getBytecode();
tp::halni idx = 0;
for (auto ip = 0; ip < bytecode->mInstructions.size(); ) {
for (auto ip = 0; ip < bytecode->mInstructions.size();) {
auto opcode = bytecode->mInstructions[ip];
auto info = obj::gOpcodeInfos.fetch(opcode);
PushID(info.name);
TextColored(ImVec4(1.f, 1.f, 1.f, 0.5f), "%i", idx); SameLine();
TextColored(ImVec4(1.f, 1.f, 1.f, 0.5f), "%i", idx);
SameLine();
if (bytecode->mInstructionIdx == ip) {
TextColored(ImVec4(1.f, 0.5f, 0.5f, 1.f), info.name);
}
else {
} else {
Text(info.name);
}
// INFO
auto hd = HoverPopupBegin(tp::String((tp::alni)ip).read(), { 400, 250 });
auto hd = HoverPopupBegin(tp::String((tp::alni) ip).read(), { 400, 250 });
if (hd) {
Text(info.desc);
if (info.operands.len) {
@ -339,43 +323,45 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::interpreterView(obj::Interpreter
}
EndChild();
} End();
}
End();
Begin("SourceCodeView"); {
stringView(interp.mCallStack.mStack.last().mMethod->mScript->mReadable);
} End();
Begin("SourceCodeView");
{ stringView(interp.mCallStack.mStack.last().mMethod->mScript->mReadable); }
End();
Begin("OperandStack"); {
Begin("OperandStack");
{
if (!interp.mOperandsStack.mIdx) {
Text("No Operands");
}
for (auto i = 0; i < interp.mOperandsStack.mIdx; i++) {
auto operand = interp.mOperandsStack.mBuff[i];
tp::alni operand_val = (tp::alni)operand;
tp::alni operand_val = (tp::alni) operand;
if (operand_val == NULL) {
Text("NULL");
}
else if (tp::uint2(operand_val) == NULL) {
} else if (tp::uint2(operand_val) == NULL) {
Text("2 BYTE VAL : %i", tp::uint2(operand_val));
}
else {
} else {
if (Selectable(operand->type->name, false, 0, ImVec2(100, 0))) {
End();
return { operand, "operand" };
}
SameLine();
PushID((tp::alni)operand);
PushID((tp::alni) operand);
preview(operand);
PopID();
}
}
} End();
}
End();
Begin("ScopeStack"); {
Begin("ScopeStack");
{
for (auto i = 0; i < interp.mScopeStack.mIdx; i++) {
if (TreeNode(tp::String((tp::alni)i).read())) {
if (TreeNode(tp::String((tp::alni) i).read())) {
auto& scope = interp.mScopeStack.mBuff[i];
@ -412,9 +398,11 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::interpreterView(obj::Interpreter
TreePop();
}
}
} End();
}
End();
Begin("CallStack"); {
Begin("CallStack");
{
for (auto i = 0; i < interp.mCallStack.mStack.size(); i++) {
auto method = interp.mCallStack.mStack[i].mMethod;
PushID(i);
@ -425,9 +413,11 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::interpreterView(obj::Interpreter
}
PopID();
}
} End();
}
End();
Begin("ConstPool"); {
Begin("ConstPool");
{
auto bc = interp.mCallStack.getBytecode();
tp::alni idx = 0;
for (auto const_obj : bc->mConstants) {
@ -435,14 +425,15 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::interpreterView(obj::Interpreter
if (Button(const_obj.data()->type->name)) {
End();
PopID();
return {const_obj.data(), tp::String(idx)};
return { const_obj.data(), tp::String(idx) };
}
SameLine();
preview(const_obj.data());
PopID();
idx++;
}
} End();
}
End();
return {};
}
@ -452,7 +443,6 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::colorView(obj::ColorObject* in)
return {};
}
obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::enumView(obj::EnumObject* obj) {
if (!obj->entries) {
@ -504,8 +494,7 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::linkoView(obj::LinkObject* obj)
if (ImGui::Selectable("View")) {
return { obj->getLink(), "adress" };
}
}
else {
} else {
ImGui::Text("Link Is Null");
}
@ -524,10 +513,11 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::linkoView(obj::LinkObject* obj)
}
obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::intoView(obj::IntObject* obj) {
ImGui::Text("Int Value: "); ImGui::SameLine();
int val = (int)obj->val;
ImGui::Text("Int Value: ");
ImGui::SameLine();
int val = (int) obj->val;
ImGui::InputInt(" ", &val);
obj->val = (tp::alni)val;
obj->val = (tp::alni) val;
return {};
}
@ -581,20 +571,18 @@ void obj::ObjectsGUI::dictViewEdit(obj::DictObject* dict, tp::String key, obj::O
if (key.size() > 100) {
ImGui::Text("name is too large");
}
else {
} else {
if (mLastNameEditObject != obj) {
tp::memCopy(mNameEdit, key.read(), key.size() + 1);
mLastNameEditObject = obj;
}
if (ImGui::InputTextEx(" ", "new name", mNameEdit, 100, { 140 , 30 }, ImGuiInputTextFlags_EnterReturnsTrue)) {
if (ImGui::InputTextEx(" ", "new name", mNameEdit, 100, { 140, 30 }, ImGuiInputTextFlags_EnterReturnsTrue)) {
auto idx = dict->presents(mNameEdit);
if (bool(idx)) {
//Notify("Object with such name Already Exists");
}
else {
// Notify("Object with such name Already Exists");
} else {
obj::NDO->refinc(obj);
dict->remove(key);
auto id = tp::String(mNameEdit);
@ -620,7 +608,8 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::dictView(obj::DictObject* obj) {
bool popup = false;
auto table_flags = ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable;
ImGui::BeginChild("frame", { 0, 0 }, 0, ImGuiWindowFlags_NoBackground); {
ImGui::BeginChild("frame", { 0, 0 }, 0, ImGuiWindowFlags_NoBackground);
{
if (!obj->getItems().size()) {
ImGui::Text("Dictinary Is Empty. ");
}
@ -629,27 +618,27 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::dictView(obj::DictObject* obj) {
ImGui::TableSetupColumn("name");
ImGui::TableSetupColumn("info");
for (auto childo : obj->getItems()) {
ImGui::TableNextRow(0, 30);
ImGui::TableSetColumnIndex(0);
if (ImGui::Selectable(childo->key.read())) {
ImGui::EndTable();
ImGui::EndChild();
return { childo->val, { tp::String(childo->val->type->name) + tp::String(" ") + childo->key } };
return { childo->val, { tp::String(childo->val->type->name) + tp::String(" ") + childo->key } };
}
dictViewEdit(obj, childo->key, childo->val, popup);
ImGui::TableSetColumnIndex(1);
ImGui::PushID((int)childo->key.read()[0]);
ImGui::PushID((int) childo->key.read()[0]);
preview(childo->val);
ImGui::PopID();
}
ImGui::EndTable();
}
} ImGui::EndChild();
}
ImGui::EndChild();
if (!popup) {
dictViewDrawCreate(obj);
@ -678,7 +667,7 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::listView(obj::ListObject* obj) {
ImGui::TableSetColumnIndex(0);
if (ImGui::Selectable(tp::String(idx).read())) {
out = ViewStackNode(childo.data(), { tp::String(childo->type->name) + tp::String("at") + tp::String(idx) } );
out = ViewStackNode(childo.data(), { tp::String(childo->type->name) + tp::String("at") + tp::String(idx) });
break;
}
@ -718,7 +707,7 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::listView(obj::ListObject* obj) {
ImGui::TableSetColumnIndex(1);
ImGui::PushID((int)idx);
ImGui::PushID((int) idx);
preview(childo.data());
ImGui::PopID();
@ -758,7 +747,7 @@ void drawStrView(tp::String& in) {
}
ImGui::BeginChild("str_edit");
ImGui::InputTextMultiline(" ", val, 2048, { ImGui::GetWindowWidth() , ImGui::GetWindowHeight() });
ImGui::InputTextMultiline(" ", val, 2048, { ImGui::GetWindowWidth(), ImGui::GetWindowHeight() });
ImGui::EndChild();
if (in != val) {
@ -811,16 +800,15 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::classView(obj::ClassObject* self
ImGui::EndTable();
ImGui::TreePop();
ImGui::EndChild();
return { childo->val, { tp::String(childo->val->type->name) + childo->key } };
return { childo->val, { tp::String(childo->val->type->name) + childo->key } };
}
dictViewEdit(dict, childo->key, childo->val, popup);
ImGui::TableSetColumnIndex(1);
ImGui::PushID((int)idx);
ImGui::PushID((int) idx);
preview(childo->val);
ImGui::PopID();
}
ImGui::EndTable();
@ -829,13 +817,13 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::classView(obj::ClassObject* self
ImGui::TreePop();
}
if (n_methods && ImGui::TreeNodeBehavior(window->GetID("Methods"), tree_flags, "Methods", 0) ) {
if (n_methods && ImGui::TreeNodeBehavior(window->GetID("Methods"), tree_flags, "Methods", 0)) {
for (auto childo : dict->getItems()) {
if (childo->val->type == &obj::MethodObject::TypeData) {
if (ImGui::Selectable(childo->key.read())) {
ImGui::TreePop();
ImGui::EndChild();
return { childo->val, { tp::String(childo->val->type->name) + childo->key } };
return { childo->val, { tp::String(childo->val->type->name) + childo->key } };
}
dictViewEdit(dict, childo->key, childo->val, popup);
}
@ -865,8 +853,7 @@ obj::ObjectsGUI::ViewStackNode obj::ObjectsGUI::methodView(obj::MethodObject* in
interp.execAll(in);
}
}
else {
} else {
if (ImGui::Button("Compile")) {
in->compile();
}
@ -897,13 +884,14 @@ void obj::ObjectsGUI::explorer() {
tp::alni idx = 0;
for (auto childo = rev_path.last(); childo; childo = childo->prev) {
ImGui::PushID((int)idx);
ImGui::PushID((int) idx);
bool go_back = false;
if (childo == rev_path.last()) {
go_back = ImGui::Button(childo->data->id.read()); ImGui::SameLine();
}
else {
go_back = ImGui::Button((childo->data->id).read()); ImGui::SameLine();
go_back = ImGui::Button(childo->data->id.read());
ImGui::SameLine();
} else {
go_back = ImGui::Button((childo->data->id).read());
ImGui::SameLine();
}
ImGui::PopID();
@ -919,7 +907,7 @@ void obj::ObjectsGUI::explorer() {
if (ImGui::Selectable("Instantiate ")) {
setClipboard(obj::NDO->instatiate(curretn_object));
//Notify("Object copied to clipboard");
// Notify("Object copied to clipboard");
}
ImGui::Separator();
@ -929,22 +917,22 @@ void obj::ObjectsGUI::explorer() {
ImGui::InputTextEx(" ", "save path", path_str, 100, { 100, 30 }, 0);
bool save_object = ImGui::Button("Save Object");
ImGui::SameLine(); ImGui::Checkbox("Compressed", &compressed);
ImGui::SameLine();
ImGui::Checkbox("Compressed", &compressed);
bool load_object = ImGui::Button("Load Object");
if (save_object) {
obj::NDO->save(curretn_object, path_str, compressed);
//Notify("Object saved");
// Notify("Object saved");
}
if (load_object) {
obj::Object* loadedo = obj::NDO->load(path_str);
if (loadedo) {
setClipboard(loadedo);
//Notify("Object copied to clipboard");
}
else {
//Notify("Can't load Object");
// Notify("Object copied to clipboard");
} else {
// Notify("Can't load Object");
}
}
@ -968,45 +956,32 @@ void obj::ObjectsGUI::explorer() {
ViewStackNode new_active;
if (NDO_CAST(obj::NullObject, mActive)) {
new_active = nullView((obj::NullObject*)mActive);
}
else if (NDO_CAST(obj::LinkObject, mActive)) {
new_active = linkoView((obj::LinkObject*)mActive);
}
else if (NDO_CAST(obj::IntObject, mActive)) {
new_active = intoView((obj::IntObject*)mActive);
}
else if (NDO_CAST(obj::StringObject, mActive)) {
new_active = stringView((obj::StringObject*)mActive);
}
else if (NDO_CAST(obj::ListObject, mActive)) {
new_active = listView((obj::ListObject*)mActive);
}
else if (NDO_CAST(obj::DictObject, mActive)) {
new_active = dictView((obj::DictObject*)mActive);
}
else if (NDO_CAST(obj::InterpreterObject, mActive)) {
new_active = interpreterView((obj::InterpreterObject*)mActive);
}
else if (NDO_CAST(obj::ClassObject, mActive)) {
new_active = classView((obj::ClassObject*)mActive);
}
else if (NDO_CAST(obj::BoolObject, mActive)) {
new_active = boolView((obj::BoolObject*)mActive);
}
else if (NDO_CAST(obj::FloatObject, mActive)) {
new_active = floatView((obj::FloatObject*)mActive);
}
else if (NDO_CAST(obj::EnumObject, mActive)) {
new_active = enumView((obj::EnumObject*)mActive);
}
else if (NDO_CAST(obj::MethodObject, mActive)) {
new_active = methodView((obj::MethodObject*)mActive);
}
else if (NDO_CAST(obj::ColorObject, mActive)) {
new_active = colorView((obj::ColorObject*)mActive);
}
else {
new_active = nullView((obj::NullObject*) mActive);
} else if (NDO_CAST(obj::LinkObject, mActive)) {
new_active = linkoView((obj::LinkObject*) mActive);
} else if (NDO_CAST(obj::IntObject, mActive)) {
new_active = intoView((obj::IntObject*) mActive);
} else if (NDO_CAST(obj::StringObject, mActive)) {
new_active = stringView((obj::StringObject*) mActive);
} else if (NDO_CAST(obj::ListObject, mActive)) {
new_active = listView((obj::ListObject*) mActive);
} else if (NDO_CAST(obj::DictObject, mActive)) {
new_active = dictView((obj::DictObject*) mActive);
} else if (NDO_CAST(obj::InterpreterObject, mActive)) {
new_active = interpreterView((obj::InterpreterObject*) mActive);
} else if (NDO_CAST(obj::ClassObject, mActive)) {
new_active = classView((obj::ClassObject*) mActive);
} else if (NDO_CAST(obj::BoolObject, mActive)) {
new_active = boolView((obj::BoolObject*) mActive);
} else if (NDO_CAST(obj::FloatObject, mActive)) {
new_active = floatView((obj::FloatObject*) mActive);
} else if (NDO_CAST(obj::EnumObject, mActive)) {
new_active = enumView((obj::EnumObject*) mActive);
} else if (NDO_CAST(obj::MethodObject, mActive)) {
new_active = methodView((obj::MethodObject*) mActive);
} else if (NDO_CAST(obj::ColorObject, mActive)) {
new_active = colorView((obj::ColorObject*) mActive);
} else {
ImGui::Text("Preview is Unavaliable");
}
@ -1028,8 +1003,7 @@ void obj::ObjectsGUI::properties(const obj::ObjectType* type, bool top_of_tree_v
if (ImGui::TreeNode("Description ")) {
if (type->description) {
ImGui::Text(type->description);
}
else {
} else {
ImGui::Text("Description is not given");
}
ImGui::TreePop();
@ -1052,7 +1026,7 @@ void obj::ObjectsGUI::properties(const obj::ObjectType* type, bool top_of_tree_v
ImGui::TreePop();
}
//if (ImGui::TreeNode("Full Type Hierarchy")) {
// if (ImGui::TreeNode("Full Type Hierarchy")) {
ImGui::Text("RAM : ");
ImGui::Indent();
@ -1067,16 +1041,15 @@ void obj::ObjectsGUI::properties(const obj::ObjectType* type, bool top_of_tree_v
ImGui::Text("With Object Links : %i bytes", obj::NDO->objsize_file_recursive(mActive));
ImGui::Unindent();
//ImGui::TreePop();
//}
// ImGui::TreePop();
//}
ImGui::TreePop();
}
if (ImGui::TreeNode("Base Type")) {
if (type->base) {
properties(type->base, false);
}
else {
} else {
ImGui::Text("No base type");
}
ImGui::TreePop();
@ -1099,8 +1072,7 @@ void obj::ObjectsGUI::draw() {
}
ImGui::End();
}
else {
} else {
ImGui::Text("ViewStack is Empty");
}

4
Objects/applications/GUIEntry.cpp
View file

@ -28,9 +28,7 @@ public:
}
}
~GUIWindow() {
Window::destroyWindow(window);
}
~GUIWindow() { Window::destroyWindow(window); }
};
int main() {

114
Objects/applications/Interpreter.cpp
View file

@ -1,58 +1,58 @@
#include "MethodObject/methodobject.h"
#include "primitives/primitives.h"
#include "Interpreter/Interpreter.h"
#include "log.h"
using namespace osc;
using namespace tp;
using namespace obj;
int main(int argc, char* argv[]) {
tp::alloc_init();
string::Initialize();
Logger::init();
objects_init();
primitives_define_types();
MethodObject::Initialize();
{
time_ms load_start = get_time();
RelAssert(argc == 2 && "Invalid Arguments");
auto obj = NDO->load(argv[1]);
RelAssert(obj && "Failed to Load the File");
RelAssert(obj->type == &MethodObject::TypeData && "Innvalid file content");
Interpreter interp;
NDO_CASTV(MethodObject, obj, method);
RelAssert(method->mScript && "Innvalid file content");
time_ms load_end = get_time();
GLog->write("\noscvm - execution started\n");
time_ms exec_start = get_time();
interp.exec(&method->mScript->mBytecode);
time_ms exec_end = get_time();
auto exec_time = (exec_end - exec_start);
auto load_time = (load_end - load_start);
GLog->write(sfmt("\noscvm - execution finished (Load : %f Exec : %f)", load_time, exec_time));
}
try {
MethodObject::UnInitialize();
objects_finalize();
primitives_uninitialize();
Logger::deinit();
string::UnInitialize();
tp::alloc_uninit();
} catch (...) {
tp::terminate();
}
#include "MethodObject/methodobject.h"
#include "primitives/primitives.h"
#include "Interpreter/Interpreter.h"
#include "log.h"
using namespace osc;
using namespace tp;
using namespace obj;
int main(int argc, char* argv[]) {
tp::alloc_init();
string::Initialize();
Logger::init();
objects_init();
primitives_define_types();
MethodObject::Initialize();
{
time_ms load_start = get_time();
RelAssert(argc == 2 && "Invalid Arguments");
auto obj = NDO->load(argv[1]);
RelAssert(obj && "Failed to Load the File");
RelAssert(obj->type == &MethodObject::TypeData && "Innvalid file content");
Interpreter interp;
NDO_CASTV(MethodObject, obj, method);
RelAssert(method->mScript && "Innvalid file content");
time_ms load_end = get_time();
GLog->write("\noscvm - execution started\n");
time_ms exec_start = get_time();
interp.exec(&method->mScript->mBytecode);
time_ms exec_end = get_time();
auto exec_time = (exec_end - exec_start);
auto load_time = (load_end - load_start);
GLog->write(sfmt("\noscvm - execution finished (Load : %f Exec : %f)", load_time, exec_time));
}
try {
MethodObject::UnInitialize();
objects_finalize();
primitives_uninitialize();
Logger::deinit();
string::UnInitialize();
tp::alloc_uninit();
} catch (...) {
tp::terminate();
}
}

174
Objects/applications/TestEntry.cpp
View file

@ -1,87 +1,89 @@
#include "primitives/methodobject.h"
#include "primitives/primitives.h"
#include "interpreter/interpreter.h"
#include "compiler/function.h"
using namespace tp;
using namespace obj;
void TestCompile(ByteCode& bytecode) {
using namespace BCgen;
Genereate(bytecode,
StmScope({
StmDefFunc("main", {}, {
StmDefLocal("i1", ExprConst(1)),
StmDefLocal("i2", ExprConst(2)),
//StmDefFunc("add", {"first", "second"}, {
// StmReturn(ExprAdd(ExprLocal("first"), ExprLocal("second")))
//}),
StmPrint(ExprLocal("i1")),
StmPrint(ExprConst(" + ")),
StmPrint(ExprLocal("i2")),
StmPrint(ExprConst(" = ")),
StmPrint(ExprFunc("add")->ExprCall({ ExprLocal("i1"), ExprLocal("i2") })),
StmPrint(ExprConst("\n")),
}),
StmPrint(ExprBoolNot(ExprConst(0))),
StmWhile(ExprConst(false), StmScope({
StmIgnore(ExprFunc("main")->ExprCall({}))
})
),
StmIf(ExprConst(true),
StmScope({
//StmIgnore(ExprFunc("main")->ExprCall({})),
//StmPrint(ExprConst("true")),
}),
StmScope({
//StmPrint(ExprConst("false")),
})
)
})
);
}
int main(int argc, char* argv[]) {
tp::alloc_init();
string::Initialize();
Logger::init();
objects_init();
primitives_define_types();
MethodObject::Initialize();
{
Interpreter interp;
ByteCode bytecode;
TestCompile(bytecode);
GLog->write(" >> Exec: start \n");
auto start = get_time();
interp.exec(&bytecode);
auto end = get_time();
GLog->write(sfmt("\n >> Exec time %i ms", end - start));
}
MethodObject::UnInitialize();
objects_finalize();
primitives_uninitialize();
Logger::deinit();
string::UnInitialize();
tp::alloc_uninit();
#include "primitives/methodobject.h"
#include "primitives/primitives.h"
#include "interpreter/interpreter.h"
#include "compiler/function.h"
using namespace tp;
using namespace obj;
void TestCompile(ByteCode& bytecode) {
using namespace BCgen;
Genereate(
bytecode,
StmScope({
StmDefFunc(
"main",
{},
{
StmDefLocal("i1", ExprConst(1)),
StmDefLocal("i2", ExprConst(2)),
// StmDefFunc("add", {"first", "second"}, {
// StmReturn(ExprAdd(ExprLocal("first"), ExprLocal("second")))
//}),
StmPrint(ExprLocal("i1")),
StmPrint(ExprConst(" + ")),
StmPrint(ExprLocal("i2")),
StmPrint(ExprConst(" = ")),
StmPrint(ExprFunc("add")->ExprCall({ ExprLocal("i1"), ExprLocal("i2") })),
StmPrint(ExprConst("\n")),
}
),
StmPrint(ExprBoolNot(ExprConst(0))),
StmWhile(ExprConst(false), StmScope({ StmIgnore(ExprFunc("main")->ExprCall({})) })),
StmIf(
ExprConst(true),
StmScope({
// StmIgnore(ExprFunc("main")->ExprCall({})),
// StmPrint(ExprConst("true")),
}),
StmScope({
// StmPrint(ExprConst("false")),
})
) })
);
}
int main(int argc, char* argv[]) {
tp::alloc_init();
string::Initialize();
Logger::init();
objects_init();
primitives_define_types();
MethodObject::Initialize();
{
Interpreter interp;
ByteCode bytecode;
TestCompile(bytecode);
GLog->write(" >> Exec: start \n");
auto start = get_time();
interp.exec(&bytecode);
auto end = get_time();
GLog->write(sfmt("\n >> Exec time %i ms", end - start));
}
MethodObject::UnInitialize();
objects_finalize();
primitives_uninitialize();
Logger::deinit();
string::UnInitialize();
tp::alloc_uninit();
}

141
Objects/applications/test.cpp
View file

@ -1,75 +1,68 @@
#include "primitives/primitives.h"
#include "compiler/function.h"
#include "interpreter/interpreter.h"
#include "CmdArgParser.h"
void compile(char argc, const char* argv[]) {
tp::CmdArgParser args = {
{ "script", tp::CmdArgParser::Arg::FILE_IN },
{ "out", "out.mo" }
};
if (!args.parse(argc, argv, true)) {
return;
}
auto& script_file = args.getFile("script");
auto outpath = args.getString("out");
tp::string script;
script.loadFile(&script_file);
auto method = obj::MethodObject::create(script);
obj::NDO->save(method, outpath);
}
void execute(char argc, const char* argv[]) {
tp::CmdArgParser args = {
{ "object_path", tp::CmdArgParser::Arg::STR },
{ "debug", false }
};
if (!args.parse(argc, argv, true)) {
return;
}
auto object_path = args.getString("object_path");
auto debug = args.getBool("debug");
auto obj = obj::NDO->load(object_path);
if (!obj) {
printf("Invalid Object File\n");
return;
}
NDO_CASTV(obj::MethodObject, obj, method);
if (!method) {
printf("Object Is Not A Method\n");
return;
}
obj::Interpreter interpreter;
interpreter.execAll(method);
}
int main(char argc, const char* argv[]) {
tp::ModuleManifest* ModuleDependencies[] = { &obj::gModuleObjects, NULL };
tp::ModuleManifest TestModule("Test", NULL, NULL, ModuleDependencies);
if (!TestModule.initialize()) {
return 1;
}
#ifdef OBC
compile(argc, argv);
#elif OBVM
execute(argc, argv);
#endif // OBC
TestModule.deinitialize();
#include "primitives/primitives.h"
#include "compiler/function.h"
#include "interpreter/interpreter.h"
#include "CmdArgParser.h"
void compile(char argc, const char* argv[]) {
tp::CmdArgParser args = { { "script", tp::CmdArgParser::Arg::FILE_IN }, { "out", "out.mo" } };
if (!args.parse(argc, argv, true)) {
return;
}
auto& script_file = args.getFile("script");
auto outpath = args.getString("out");
tp::string script;
script.loadFile(&script_file);
auto method = obj::MethodObject::create(script);
obj::NDO->save(method, outpath);
}
void execute(char argc, const char* argv[]) {
tp::CmdArgParser args = { { "object_path", tp::CmdArgParser::Arg::STR }, { "debug", false } };
if (!args.parse(argc, argv, true)) {
return;
}
auto object_path = args.getString("object_path");
auto debug = args.getBool("debug");
auto obj = obj::NDO->load(object_path);
if (!obj) {
printf("Invalid Object File\n");
return;
}
NDO_CASTV(obj::MethodObject, obj, method);
if (!method) {
printf("Object Is Not A Method\n");
return;
}
obj::Interpreter interpreter;
interpreter.execAll(method);
}
int main(char argc, const char* argv[]) {
tp::ModuleManifest* ModuleDependencies[] = { &obj::gModuleObjects, NULL };
tp::ModuleManifest TestModule("Test", NULL, NULL, ModuleDependencies);
if (!TestModule.initialize()) {
return 1;
}
#ifdef OBC
compile(argc, argv);
#elif OBVM
execute(argc, argv);
#endif // OBC
TestModule.deinitialize();
}

291
Objects/private/compiler/constants.cpp
View file

@ -1,148 +1,145 @@
#include "NewPlacement.hpp"
#include "compiler/constants.h"
#include "primitives/primitives.h"
#include "primitives/methodobject.h"
using namespace obj;
using namespace tp;
using namespace BCgen;
ConstObject::ConstObject() {}
ConstObject::ConstObject(obj::Object* mObj) : mObj(mObj) {}
ConstObjectsPool::~ConstObjectsPool() {
if (mDelete) {
for (auto obj : mStrings) {
obj::NDO->destroy(obj->val->mObj);
}
for (auto obj : mIntegers) {
obj::NDO->destroy(obj->val->mObj);
}
for (auto obj : mFloats) {
obj::NDO->destroy(obj->val->mObj);
}
for (auto obj : mMethods) {
obj::NDO->destroy(obj->val->mObj);
}
if (mBoolFalse.mObj) {
obj::NDO->destroy(mBoolFalse.mObj);
}
if (mBoolTrue.mObj) {
obj::NDO->destroy(mBoolTrue.mObj);
}
}
for (auto obj : mStrings) {
delete obj->val;
}
for (auto obj : mIntegers) {
delete obj->val;
}
for (auto obj : mFloats) {
delete obj->val;
}
}
ConstObject* ConstObjectsPool::registerObject(obj::Object* obj) {
ConstObject* out = new ConstObject(obj);
mTotalObjects++;
return out;
}
ConstObject* ConstObjectsPool::get(tp::alni val) {
auto idx = mIntegers.presents(val);
ConstObject* const_obj = NULL;
if (idx) {
const_obj = mIntegers.getSlotVal(idx);
}
else {
const_obj = registerObject(IntObject::create(val));
mIntegers.put(val, const_obj);
}
return const_obj;
}
ConstObject* ConstObjectsPool::get(tp::String val) {
auto idx = mStrings.presents(val);
ConstObject* const_obj = NULL;
if (idx) {
const_obj = mStrings.getSlotVal(idx);
}
else {
const_obj = registerObject(StringObject::create(val));
mStrings.put(val, const_obj);
}
return const_obj;
}
ConstObject* ConstObjectsPool::get(tp::alnf val) {
auto idx = mFloats.presents(val);
ConstObject* const_obj = NULL;
if (idx) {
const_obj = mFloats.getSlotVal(idx);
}
else {
const_obj = registerObject(FloatObject::create(val));
mFloats.put(val, const_obj);
}
return const_obj;
}
ConstObject* ConstObjectsPool::get(bool val) {
if (val) {
if (!mBoolTrue.mObj) {
mBoolTrue.mObj = BoolObject::create(val);
mTotalObjects++;
}
return &mBoolTrue;
}
else {
if (!mBoolFalse.mObj) {
mBoolFalse.mObj = BoolObject::create(val);
mTotalObjects++;
}
return &mBoolFalse;
}
}
ConstObject* ConstObjectsPool::addMethod(tp::String method_id, obj::Object* method) {
ASSERT(NDO_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);
return out;
}
void ConstObjectsPool::save(tp::Buffer<ConstData>& out) {
out.reserve(mTotalObjects);
tp::alni data_idx = 0;
for (auto obj : mMethods) {
out[data_idx] = obj->val->mObj;
obj->val->mConstIdx = data_idx;
data_idx++;
}
for (auto obj : mStrings) {
out[data_idx] = obj->val->mObj;
obj->val->mConstIdx = data_idx;
data_idx++;
}
for (auto obj : mIntegers) {
out[data_idx] = obj->val->mObj;
obj->val->mConstIdx = data_idx;
data_idx++;
}
for (auto obj : mFloats) {
out[data_idx] = obj->val->mObj;
obj->val->mConstIdx = data_idx;
data_idx++;
}
if (mBoolFalse.mObj) {
out[data_idx] = mBoolFalse.mObj;
mBoolFalse.mConstIdx = data_idx;
data_idx++;
}
if (mBoolTrue.mObj) {
out[data_idx] = mBoolTrue.mObj;
mBoolTrue.mConstIdx = data_idx;
}
mDelete = false;
#include "compiler/constants.h"
#include "NewPlacement.hpp"
#include "primitives/methodobject.h"
#include "primitives/primitives.h"
using namespace obj;
using namespace tp;
using namespace BCgen;
ConstObject::ConstObject() {}
ConstObject::ConstObject(obj::Object* mObj) :
mObj(mObj) {}
ConstObjectsPool::~ConstObjectsPool() {
if (mDelete) {
for (auto obj : mStrings) {
obj::NDO->destroy(obj->val->mObj);
}
for (auto obj : mIntegers) {
obj::NDO->destroy(obj->val->mObj);
}
for (auto obj : mFloats) {
obj::NDO->destroy(obj->val->mObj);
}
for (auto obj : mMethods) {
obj::NDO->destroy(obj->val->mObj);
}
if (mBoolFalse.mObj) {
obj::NDO->destroy(mBoolFalse.mObj);
}
if (mBoolTrue.mObj) {
obj::NDO->destroy(mBoolTrue.mObj);
}
}
for (auto obj : mStrings) {
delete obj->val;
}
for (auto obj : mIntegers) {
delete obj->val;
}
for (auto obj : mFloats) {
delete obj->val;
}
}
ConstObject* ConstObjectsPool::registerObject(obj::Object* obj) {
ConstObject* out = new ConstObject(obj);
mTotalObjects++;
return out;
}
ConstObject* ConstObjectsPool::get(tp::alni val) {
auto idx = mIntegers.presents(val);
ConstObject* const_obj = NULL;
if (idx) {
const_obj = mIntegers.getSlotVal(idx);
} else {
const_obj = registerObject(IntObject::create(val));
mIntegers.put(val, const_obj);
}
return const_obj;
}
ConstObject* ConstObjectsPool::get(tp::String val) {
auto idx = mStrings.presents(val);
ConstObject* const_obj = NULL;
if (idx) {
const_obj = mStrings.getSlotVal(idx);
} else {
const_obj = registerObject(StringObject::create(val));
mStrings.put(val, const_obj);
}
return const_obj;
}
ConstObject* ConstObjectsPool::get(tp::alnf val) {
auto idx = mFloats.presents(val);
ConstObject* const_obj = NULL;
if (idx) {
const_obj = mFloats.getSlotVal(idx);
} else {
const_obj = registerObject(FloatObject::create(val));
mFloats.put(val, const_obj);
}
return const_obj;
}
ConstObject* ConstObjectsPool::get(bool val) {
if (val) {
if (!mBoolTrue.mObj) {
mBoolTrue.mObj = BoolObject::create(val);
mTotalObjects++;
}
return &mBoolTrue;
} else {
if (!mBoolFalse.mObj) {
mBoolFalse.mObj = BoolObject::create(val);
mTotalObjects++;
}
return &mBoolFalse;
}
}
ConstObject* ConstObjectsPool::addMethod(tp::String method_id, obj::Object* method) {
ASSERT(NDO_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);
return out;
}
void ConstObjectsPool::save(tp::Buffer<ConstData>& out) {
out.reserve(mTotalObjects);
tp::alni data_idx = 0;
for (auto obj : mMethods) {
out[data_idx] = obj->val->mObj;
obj->val->mConstIdx = data_idx;
data_idx++;
}
for (auto obj : mStrings) {
out[data_idx] = obj->val->mObj;
obj->val->mConstIdx = data_idx;
data_idx++;
}
for (auto obj : mIntegers) {
out[data_idx] = obj->val->mObj;
obj->val->mConstIdx = data_idx;
data_idx++;
}
for (auto obj : mFloats) {
out[data_idx] = obj->val->mObj;
obj->val->mConstIdx = data_idx;
data_idx++;
}
if (mBoolFalse.mObj) {
out[data_idx] = mBoolFalse.mObj;
mBoolFalse.mConstIdx = data_idx;
data_idx++;
}
if (mBoolTrue.mObj) {
out[data_idx] = mBoolTrue.mObj;
mBoolTrue.mConstIdx = data_idx;
}
mDelete = false;
}

163
Objects/private/compiler/expression.cpp
View file

@ -1,70 +1,93 @@
#include "NewPlacement.hpp"
#include "compiler/expression.h"
using namespace obj;
using namespace BCgen;
Expression::Expression() {}
Expression::Expression(Type type) : mType(type) {}
ExpressionChild* Expression::ExprChild(tp::String id) {
return new ExpressionChild(this, id);
}
ExpressionCall* Expression::ExprCall(tp::InitialierList<Expression*> args) {
return new ExpressionCall(this, args);
}
ExpressionLocal* obj::BCgen::ExprLocal(tp::String id) {
return new ExpressionLocal(id);
}
ExpressionSelf* obj::BCgen::ExprSelf() {
return new ExpressionSelf();
}
ExpressionNew* obj::BCgen::ExprNew(tp::String type) {
return new ExpressionNew(type);
}
ExpressionAriphm* obj::BCgen::ExprAriphm(Expression* left, Expression* right, OpCode type) {
return new ExpressionAriphm(left, right, type);
}
ExpressionFunc* obj::BCgen::ExprFunc(tp::String id) {
return new ExpressionFunc(id);
}
ExpressionBoolean* obj::BCgen::ExprBool(Expression* left, Expression* right, obj::OpCode type) {
return new ExpressionBoolean(left, right, ExpressionBoolean::BoolType(type));
}
ExpressionBoolean* obj::BCgen::ExprBoolNot(Expression* invert) {
return new ExpressionBoolean(invert);
}
ExpressionBoolean::ExpressionBoolean(Expression* left, Expression* right, BoolType type)
: Expression(Type::BOOLEAN), mLeft(left), mRight(right), mBoolType(type) {
}
ExpressionBoolean::ExpressionBoolean(Expression* invert)
: Expression(Type::BOOLEAN), mLeft(invert), mBoolType(BoolType::NOT){
}
ExpressionCall::ExpressionCall(Expression * mParent, tp::InitialierList<Expression*> args) : Expression(Type::CALL), mParent(mParent) {
mArgs = args;
}
ExpressionNew::ExpressionNew(tp::String type) : Expression(Type::NEW), mNewType(type) {}
ExpressionLocal::ExpressionLocal(tp::String id) : Expression(Type::LOCAL), mLocalId(id) {}
ExpressionSelf::ExpressionSelf() : Expression(Type::SELF) {}
ExpressionChild::ExpressionChild(Expression* mParent, tp::String id) : Expression(Type::CHILD), mParent(mParent), mLocalId(id) {}
ExpressionAriphm::ExpressionAriphm(Expression* left, Expression* right, OpCode type) : Expression(Type::ARIPHM), mLeft(left), mRight(right), mOpType(type) {}
ExpressionFunc::ExpressionFunc(tp::String id) : Expression(Type::FUNC), mFuncId(id) {}
ExpressionConst::ExpressionConst(tp::String val) : Expression(Type::CONST), mConstType(STR), str(val) {}
ExpressionConst::ExpressionConst(const char* val) : Expression(Type::CONST), mConstType(STR), str(val) {}
ExpressionConst::ExpressionConst(tp::int4 val) : Expression(Type::CONST), mConstType(INT), integer(val) {}
ExpressionConst::ExpressionConst(tp::flt4 val) : Expression(Type::CONST), mConstType(FLT), floating(val) {}
ExpressionConst::ExpressionConst(tp::alni val) : Expression(Type::CONST), mConstType(INT), integer(val) {}
ExpressionConst::ExpressionConst(tp::alnf val) : Expression(Type::CONST), mConstType(FLT), floating(val) {}
ExpressionConst::ExpressionConst(bool val) : Expression(Type::CONST), mConstType(BOOL), boolean(val) {}
#include "compiler/expression.h"
#include "NewPlacement.hpp"
using namespace obj;
using namespace BCgen;
Expression::Expression() {}
Expression::Expression(Type type) :
mType(type) {}
ExpressionChild* Expression::ExprChild(tp::String id) { return new ExpressionChild(this, id); }
ExpressionCall* Expression::ExprCall(tp::InitialierList<Expression*> args) { return new ExpressionCall(this, args); }
ExpressionLocal* obj::BCgen::ExprLocal(tp::String id) { return new ExpressionLocal(id); }
ExpressionSelf* obj::BCgen::ExprSelf() { return new ExpressionSelf(); }
ExpressionNew* obj::BCgen::ExprNew(tp::String type) { return new ExpressionNew(type); }
ExpressionAriphm* obj::BCgen::ExprAriphm(Expression* left, Expression* right, OpCode type) { return new ExpressionAriphm(left, right, type); }
ExpressionFunc* obj::BCgen::ExprFunc(tp::String id) { return new ExpressionFunc(id); }
ExpressionBoolean* obj::BCgen::ExprBool(Expression* left, Expression* right, obj::OpCode type) { return new ExpressionBoolean(left, right, ExpressionBoolean::BoolType(type)); }
ExpressionBoolean* obj::BCgen::ExprBoolNot(Expression* invert) { return new ExpressionBoolean(invert); }
ExpressionBoolean::ExpressionBoolean(Expression* left, Expression* right, BoolType type) :
Expression(Type::BOOLEAN),
mLeft(left),
mRight(right),
mBoolType(type) {}
ExpressionBoolean::ExpressionBoolean(Expression* invert) :
Expression(Type::BOOLEAN),
mLeft(invert),
mBoolType(BoolType::NOT) {}
ExpressionCall::ExpressionCall(Expression* mParent, tp::InitialierList<Expression*> args) :
Expression(Type::CALL),
mParent(mParent) {
mArgs = args;
}
ExpressionNew::ExpressionNew(tp::String type) :
Expression(Type::NEW),
mNewType(type) {}
ExpressionLocal::ExpressionLocal(tp::String id) :
Expression(Type::LOCAL),
mLocalId(id) {}
ExpressionSelf::ExpressionSelf() :
Expression(Type::SELF) {}
ExpressionChild::ExpressionChild(Expression* mParent, tp::String id) :
Expression(Type::CHILD),
mParent(mParent),
mLocalId(id) {}
ExpressionAriphm::ExpressionAriphm(Expression* left, Expression* right, OpCode type) :
Expression(Type::ARIPHM),
mLeft(left),
mRight(right),
mOpType(type) {}
ExpressionFunc::ExpressionFunc(tp::String id) :
Expression(Type::FUNC),
mFuncId(id) {}
ExpressionConst::ExpressionConst(tp::String val) :
Expression(Type::CONST),
mConstType(STR),
str(val) {}
ExpressionConst::ExpressionConst(const char* val) :
Expression(Type::CONST),
mConstType(STR),
str(val) {}
ExpressionConst::ExpressionConst(tp::int4 val) :
Expression(Type::CONST),
mConstType(INT),
integer(val) {}
ExpressionConst::ExpressionConst(tp::flt4 val) :
Expression(Type::CONST),
mConstType(FLT),
floating(val) {}
ExpressionConst::ExpressionConst(tp::alni val) :
Expression(Type::CONST),
mConstType(INT),
integer(val) {}
ExpressionConst::ExpressionConst(tp::alnf val) :
Expression(Type::CONST),
mConstType(FLT),
floating(val) {}
ExpressionConst::ExpressionConst(bool val) :
Expression(Type::CONST),
mConstType(BOOL),
boolean(val) {}

1153
Objects/private/compiler/function.cpp
View file

File diff suppressed because it is too large Load diff

72
Objects/private/compiler/instruction.cpp
View file

@ -1,30 +1,44 @@
#include "NewPlacement.hpp"
#include "compiler/instruction.h"
using namespace obj;
using namespace tp;
using namespace BCgen;
Instruction::Instruction(OpCode op) : mOp(op), mArgType(ArgType::NO_ARG), mInstType(InstType::EXEC) {}
Instruction::Instruction() : mInstType(InstType::NONE) {}
Instruction::Instruction(ConstObject* constData)
: mConstData(constData), mInstType(InstType::PURE_CONST) {}
Instruction::Instruction(OpCode op, ConstObject* constData)
: mOp(op), mConstData(constData), mArgType(ArgType::CONST), mInstType(InstType::EXEC) {
}
Instruction::Instruction(OpCode op, ConstObject* constData, ConstObject* constData2)
: mOp(op), mConstData(constData), mConstData2(constData2), mArgType(ArgType::CONST), mInstType(InstType::EXEC) {
}
Instruction::Instruction(OpCode op, tp::alni param, tp::alni nBytes)
: mOp(op), mParam(param), mArgType(ArgType::PARAM), mParamBytes(nBytes), mInstType(InstType::EXEC) {
}
Instruction::Instruction(Instruction* inst, InstType jump_type): mInstTarget(inst) {
mInstType = jump_type;
#include "compiler/instruction.h"
#include "NewPlacement.hpp"
using namespace obj;
using namespace tp;
using namespace BCgen;
Instruction::Instruction(OpCode op) :
mOp(op),
mArgType(ArgType::NO_ARG),
mInstType(InstType::EXEC) {}
Instruction::Instruction() :
mInstType(InstType::NONE) {}
Instruction::Instruction(ConstObject* constData) :
mConstData(constData),
mInstType(InstType::PURE_CONST) {}
Instruction::Instruction(OpCode op, ConstObject* constData) :
mOp(op),
mConstData(constData),
mArgType(ArgType::CONST),
mInstType(InstType::EXEC) {}
Instruction::Instruction(OpCode op, ConstObject* constData, ConstObject* constData2) :
mOp(op),
mConstData(constData),
mConstData2(constData2),
mArgType(ArgType::CONST),
mInstType(InstType::EXEC) {}
Instruction::Instruction(OpCode op, tp::alni param, tp::alni nBytes) :
mOp(op),
mParam(param),
mArgType(ArgType::PARAM),
mParamBytes(nBytes),
mInstType(InstType::EXEC) {}
Instruction::Instruction(Instruction* inst, InstType jump_type) :
mInstTarget(inst) {
mInstType = jump_type;
}

218
Objects/private/compiler/statement.cpp
View file

@ -1,116 +1,102 @@
#include "NewPlacement.hpp"
#include "compiler/statement.h"
using namespace obj;
using namespace BCgen;
StatementFuncDef::StatementFuncDef(tp::String function_id, tp::InitialierList<tp::String> args, tp::InitialierList<Statement*> statements) {
mType = Type::DEF_FUNC;
mArgs = args;
mStatements = statements;
mFunctionId = function_id;
}
StatementLocalDef::StatementLocalDef(tp::String id, Expression* value) : mLocalId(id), mNewExpr(value) {
mType = Type::DEF_LOCAL;
}
StatementLocalDef::StatementLocalDef(tp::String id, ExpressionConst* value) : mLocalId(id), mConstExpr(value), mIsConstExpr(true) {
mType = Type::DEF_LOCAL;
}
StatementCopy::StatementCopy(Expression* left, Expression* right) : mLeft(left), mRight(right) {
mType = Type::COPY;
}
StatementReturn::StatementReturn() {
mType = Type::RET;
}
StatementReturn::StatementReturn(Expression* ret) : mRet(ret) {
mType = Type::RET;
}
StatementPrint::StatementPrint(Expression* target) : mTarget(target) {
mType = Type::PRINT;
}
StatementScope::StatementScope(tp::InitialierList<Statement*> statements, bool aPushToScopeStack) {
mType = Type::SCOPE;
mStatements = statements;
mPushToScopeStack = aPushToScopeStack;
}
StatementIf::StatementIf(Expression* condition, StatementScope* on_true, StatementScope* on_false) {
mType = Type::IF;
mOnFalse = on_false;
mOnTrue = on_true;
mCondition = condition;
}
StatementWhile::StatementWhile(Expression* condition, StatementScope* scope) {
mType = Type::WHILE;
mScope = scope;
mCondition = condition;
}
StatementIgnore::StatementIgnore(Expression* expr) {
mType = Type::IGNORE;
mExpr = expr;
}
StatementClassDef::StatementClassDef(tp::String class_id, StatementScope* scope) {
mClassId = class_id;
mScope = scope;
mType = Type::CLASS_DEF;
}
// helpers
StatementFuncDef* obj::BCgen::StmDefFunc(tp::String id, tp::InitialierList<tp::String> args, tp::InitialierList<Statement*> stms) {
return new StatementFuncDef(id, args, stms);
}
StatementLocalDef* obj::BCgen::StmDefLocal(tp::String id, Expression* value) {
if (value->mType == Expression::Type::CONST) {
return new StatementLocalDef(id, (ExpressionConst*)value);
}
return new StatementLocalDef(id, value);
}
StatementCopy* obj::BCgen::StmCopy(Expression* left, Expression* right) {
return new StatementCopy(left, right);
}
StatementPrint* obj::BCgen::StmPrint(Expression* target) {
return new StatementPrint(target);
}
StatementReturn* obj::BCgen::StmReturn() {
return new StatementReturn();
}
StatementReturn* obj::BCgen::StmReturn(Expression* obj) {
return new StatementReturn(obj);
}
StatementIf* obj::BCgen::StmIf(Expression* condition, StatementScope* on_true, StatementScope* on_false) {
return new StatementIf(condition, on_true, on_false);
}
StatementScope* obj::BCgen::StmScope(tp::InitialierList<Statement*> statements, bool aPushToScopeStack = false) {
return new StatementScope(statements, aPushToScopeStack);
}
StatementWhile* obj::BCgen::StmWhile(Expression* condition, StatementScope* scope) {
return new StatementWhile(condition, scope);
}
StatementIgnore* obj::BCgen::StmIgnore(Expression* expr) {
return new StatementIgnore(expr);
}
StatementClassDef* obj::BCgen::StmClassDef(tp::String id, StatementScope* scope) {
return new StatementClassDef(id, scope);
}
#include "compiler/statement.h"
#include "NewPlacement.hpp"
using namespace obj;
using namespace BCgen;
StatementFuncDef::StatementFuncDef(tp::String function_id, tp::InitialierList<tp::String> args, tp::InitialierList<Statement*> statements) {
mType = Type::DEF_FUNC;
mArgs = args;
mStatements = statements;
mFunctionId = function_id;
}
StatementLocalDef::StatementLocalDef(tp::String id, Expression* value) :
mLocalId(id),
mNewExpr(value) {
mType = Type::DEF_LOCAL;
}
StatementLocalDef::StatementLocalDef(tp::String id, ExpressionConst* value) :
mLocalId(id),
mConstExpr(value),
mIsConstExpr(true) {
mType = Type::DEF_LOCAL;
}
StatementCopy::StatementCopy(Expression* left, Expression* right) :
mLeft(left),
mRight(right) {
mType = Type::COPY;
}
StatementReturn::StatementReturn() { mType = Type::RET; }
StatementReturn::StatementReturn(Expression* ret) :
mRet(ret) {
mType = Type::RET;
}
StatementPrint::StatementPrint(Expression* target) :
mTarget(target) {
mType = Type::PRINT;
}
StatementScope::StatementScope(tp::InitialierList<Statement*> statements, bool aPushToScopeStack) {
mType = Type::SCOPE;
mStatements = statements;
mPushToScopeStack = aPushToScopeStack;
}
StatementIf::StatementIf(Expression* condition, StatementScope* on_true, StatementScope* on_false) {
mType = Type::IF;
mOnFalse = on_false;
mOnTrue = on_true;
mCondition = condition;
}
StatementWhile::StatementWhile(Expression* condition, StatementScope* scope) {
mType = Type::WHILE;
mScope = scope;
mCondition = condition;
}
StatementIgnore::StatementIgnore(Expression* expr) {
mType = Type::IGNORE;
mExpr = expr;
}
StatementClassDef::StatementClassDef(tp::String class_id, StatementScope* scope) {
mClassId = class_id;
mScope = scope;
mType = Type::CLASS_DEF;
}
// helpers
StatementFuncDef* obj::BCgen::StmDefFunc(tp::String id, tp::InitialierList<tp::String> args, tp::InitialierList<Statement*> stms) { return new StatementFuncDef(id, args, stms); }
StatementLocalDef* obj::BCgen::StmDefLocal(tp::String id, Expression* value) {
if (value->mType == Expression::Type::CONST) {
return new StatementLocalDef(id, (ExpressionConst*) value);
}
return new StatementLocalDef(id, value);
}
StatementCopy* obj::BCgen::StmCopy(Expression* left, Expression* right) { return new StatementCopy(left, right); }
StatementPrint* obj::BCgen::StmPrint(Expression* target) { return new StatementPrint(target); }
StatementReturn* obj::BCgen::StmReturn() { return new StatementReturn(); }
StatementReturn* obj::BCgen::StmReturn(Expression* obj) { return new StatementReturn(obj); }
StatementIf* obj::BCgen::StmIf(Expression* condition, StatementScope* on_true, StatementScope* on_false) { return new StatementIf(condition, on_true, on_false); }
StatementScope* obj::BCgen::StmScope(tp::InitialierList<Statement*> statements, bool aPushToScopeStack = false) { return new StatementScope(statements, aPushToScopeStack); }
StatementWhile* obj::BCgen::StmWhile(Expression* condition, StatementScope* scope) { return new StatementWhile(condition, scope); }
StatementIgnore* obj::BCgen::StmIgnore(Expression* expr) { return new StatementIgnore(expr); }
StatementClassDef* obj::BCgen::StmClassDef(tp::String id, StatementScope* scope) { return new StatementClassDef(id, scope); }

181
Objects/private/core/module.cpp
View file

@ -1,92 +1,91 @@
#include "NewPlacement.hpp"
#include "Tokenizer.hpp"
#include "compiler/function.h"
#include "primitives/boolobject.h"
#include "primitives/classobject.h"
#include "primitives/colorobject.h"
#include "primitives/dictobject.h"
#include "primitives/enumobject.h"
#include "primitives/floatobject.h"
#include "primitives/interpreterobject.h"
#include "primitives/intobject.h"
#include "primitives/linkobject.h"
#include "primitives/listobject.h"
#include "primitives/methodobject.h"
#include "primitives/nullobject.h"
#include "primitives/stringobject.h"
#include "primitives/typeobject.h"
using namespace obj;
using namespace tp;
static void defineTypes() {
NDO->define(&DictObject::TypeData);
NDO->define(&IntObject::TypeData);
NDO->define(&LinkObject::TypeData);
NDO->define(&ListObject::TypeData);
NDO->define(&NullObject::TypeData);
NDO->define(&StringObject::TypeData);
NDO->define(&BoolObject::TypeData);
NDO->define(&FloatObject::TypeData);
NDO->define(&EnumObject::TypeData);
NDO->define(&ClassObject::TypeData);
NDO->define(&ColorObject::TypeData);
NDO->define(&InterpreterObject::TypeData);
NDO->define(&TypeObject::TypeData);
}
static void defineGroups() {
NDO->type_groups.addType(&DictObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&IntObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&LinkObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&ListObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&NullObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&StringObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&BoolObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&FloatObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&EnumObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&ClassObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&ColorObject::TypeData, {"Primitives"});
NDO->type_groups.addType(&InterpreterObject::TypeData, { "scripting" });
}
static bool init(const tp::ModuleManifest*) {
if (!NDO) NDO = new objects_api();
obj::BCgen::init();
MethodObject::Initialize();
defineTypes();
defineGroups();
return true;
}
static void deinit(const tp::ModuleManifest*) {
NullObject::uninit();
MethodObject::UnInitialize();
obj::BCgen::deinit();
assertNoLeaks();
delete NDO;
NDO = nullptr;
}
static tp::ModuleManifest* sModuleDependencies[] = {
// &tp::gModuleCompressor,
&tp::gModuleMath,
&tp::gModuleStrings,
&tp::gModuleTokenizer,
&tp::gModuleConnection,
NULL
};
#include "NewPlacement.hpp"
#include "Tokenizer.hpp"
#include "compiler/function.h"
#include "primitives/boolobject.h"
#include "primitives/classobject.h"
#include "primitives/colorobject.h"
#include "primitives/dictobject.h"
#include "primitives/enumobject.h"
#include "primitives/floatobject.h"
#include "primitives/interpreterobject.h"
#include "primitives/intobject.h"
#include "primitives/linkobject.h"
#include "primitives/listobject.h"
#include "primitives/methodobject.h"
#include "primitives/nullobject.h"
#include "primitives/stringobject.h"
#include "primitives/typeobject.h"
using namespace obj;
using namespace tp;
static void defineTypes() {
NDO->define(&DictObject::TypeData);
NDO->define(&IntObject::TypeData);
NDO->define(&LinkObject::TypeData);
NDO->define(&ListObject::TypeData);
NDO->define(&NullObject::TypeData);
NDO->define(&StringObject::TypeData);
NDO->define(&BoolObject::TypeData);
NDO->define(&FloatObject::TypeData);
NDO->define(&EnumObject::TypeData);
NDO->define(&ClassObject::TypeData);
NDO->define(&ColorObject::TypeData);
NDO->define(&InterpreterObject::TypeData);
NDO->define(&TypeObject::TypeData);
}
static void defineGroups() {
NDO->type_groups.addType(&DictObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&IntObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&LinkObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&ListObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&NullObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&StringObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&BoolObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&FloatObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&EnumObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&ClassObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&ColorObject::TypeData, { "Primitives" });
NDO->type_groups.addType(&InterpreterObject::TypeData, { "scripting" });
}
static bool init(const tp::ModuleManifest*) {
if (!NDO) NDO = new objects_api();
obj::BCgen::init();
MethodObject::Initialize();
defineTypes();
defineGroups();
return true;
}
static void deinit(const tp::ModuleManifest*) {
NullObject::uninit();
MethodObject::UnInitialize();
obj::BCgen::deinit();
assertNoLeaks();
delete NDO;
NDO = nullptr;
}
static tp::ModuleManifest* sModuleDependencies[] = {
// &tp::gModuleCompressor,
&tp::gModuleMath,
&tp::gModuleStrings,
&tp::gModuleTokenizer,
&tp::gModuleConnection,
NULL
};
tp::ModuleManifest obj::gModuleObjects = tp::ModuleManifest("Objects", init, deinit, sModuleDependencies);

455
Objects/private/core/object.cpp
View file

@ -1,230 +1,227 @@
#include "NewPlacement.hpp"
#include "core/object.h"
#include "primitives/nullobject.h"
#include "primitives/classobject.h"
#include "primitives/methodobject.h"
#include "interpreter/interpreter.h"
#include "compiler/function.h"
namespace obj {
Object* ObjectMemAllocate(const ObjectType* type);
void ObjectMemDeallocate(Object* in);
objects_api* NDO = NULL;
void hierarchy_copy(Object* self, const Object* in, const ObjectType* type);
void hierarchy_construct(Object* self, const ObjectType* type);
objects_api::objects_api() {
tp::memSetVal(sl_callbacks, SAVE_LOAD_MAX_CALLBACK_SLOTS * sizeof(save_load_callbacks*), 0);
interp = new Interpreter();
}
objects_api::~objects_api() {
delete interp;
}
void objects_api::define(ObjectType* type) {
MODULE_SANITY_CHECK(gModuleObjects);
DEBUG_ASSERT(NDO && "using uninitialize objects api");
DEBUG_ASSERT(!types.presents(type->name) && "Type Redefinition");
types.put(type->name, type);
type->type_methods.init();
}
Object* objects_api::create(const tp::String& name) {
MODULE_SANITY_CHECK(gModuleObjects);
const ObjectType* type = types.get(name);
Object* obj_instance = ObjectMemAllocate(type);
if (!obj_instance) {
return NULL;
}
hierarchy_construct(obj_instance, obj_instance->type);
setrefc(obj_instance, 0);
NDO_CASTV(ClassObject, obj_instance, classobj);
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);
if (constructor_method) {
interp->execAll(constructor_method, classobj);
}
}
}
return obj_instance;
}
Object* objects_api::copy(Object* self, const Object* in) {
if (self->type != in->type) {
return NULL;
}
hierarchy_copy(self, in, self->type);
return self;
}
bool objects_api::compare(Object* first, Object* second) {
if (first->type == second->type) {
if (first->type->comparison) {
return first->type->comparison(first, second);
}
// raw data comparison
return tp::memCompare(first, second, first->type->size) == 0;
}
return false;
}
Object* objects_api::instatiate(Object* in) {
obj::Object* obj = NDO->create(in->type->name);
NDO->copy(obj, in);
return obj;
}
void objects_api::set(Object* self, tp::alni val) {
if (self->type->convesions && self->type->convesions->from_int) {
self->type->convesions->from_int(self, val);
return;
}
}
void objects_api::set(Object* self, tp::alnf val) {
if (self->type->convesions && self->type->convesions->from_float) {
self->type->convesions->from_float(self, val);
return;
}
}
void objects_api::set(Object* self, tp::String val) {
if (self->type->convesions && self->type->convesions->from_string) {
self->type->convesions->from_string(self, val);
return;
}
}
tp::alni objects_api::toInt(Object* self) {
DEBUG_ASSERT(self->type->convesions && self->type->convesions->to_int);
return self->type->convesions->to_int(self);
}
tp::alnf objects_api::toFloat(Object* self) {
DEBUG_ASSERT(self->type->convesions && self->type->convesions->to_float);
return self->type->convesions->to_float(self);
}
bool objects_api::toBool(Object* self) {
if (self->type->convesions && self->type->convesions->to_int) {
return (bool) self->type->convesions->to_int(self);
}
return true;
}
tp::String objects_api::toString(Object* self) {
DEBUG_ASSERT(self->type->convesions && self->type->convesions->to_string);
return self->type->convesions->to_string(self);
}
void objects_api::destroy(Object* in) {
if (!in) {
return;
}
#ifdef OBJECT_REF_COUNT
ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
if (mh->refc > 1) {
mh->refc--;
return;
}
#endif
NDO_CASTV(ClassObject, in, classobj);
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);
if (constructor_method) {
interp->execAll(constructor_method, classobj);
}
}
}
for (const ObjectType* iter = in->type; iter; iter = iter->base) {
if (iter->destructor) {
iter->destructor(in);
}
}
ObjectMemDeallocate(in);
}
#ifdef OBJECT_REF_COUNT
tp::halni objects_api::getrefc(Object* in) {
ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
return (tp::halni)mh->refc;
}
void objects_api::refinc(Object* in) {
ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
mh->refc++;
}
void objects_api::setrefc(Object* in, tp::halni refc) {
ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
mh->refc = refc;
}
#endif
void hierarchy_copy(Object* self, const Object* in, const ObjectType* type) {
if (type->base) {
hierarchy_copy(self, in, type->base);
}
if (type->copy) {
type->copy(self, in);
}
}
void hierarchy_construct(Object* self, const ObjectType* type) {
if (type->base) {
hierarchy_construct(self, type->base);
}
if (type->constructor) {
type->constructor(self);
}
}
Object* 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 NULL;
}
#include "NewPlacement.hpp"
#include "core/object.h"
#include "primitives/classobject.h"
#include "primitives/methodobject.h"
#include "primitives/nullobject.h"
#include "compiler/function.h"
#include "interpreter/interpreter.h"
namespace obj {
Object* ObjectMemAllocate(const ObjectType* type);
void ObjectMemDeallocate(Object* in);
objects_api* NDO = NULL;
void hierarchy_copy(Object* self, const Object* in, const ObjectType* type);
void hierarchy_construct(Object* self, const ObjectType* type);
objects_api::objects_api() {
tp::memSetVal(sl_callbacks, SAVE_LOAD_MAX_CALLBACK_SLOTS * sizeof(save_load_callbacks*), 0);
interp = new Interpreter();
}
objects_api::~objects_api() { delete interp; }
void objects_api::define(ObjectType* type) {
MODULE_SANITY_CHECK(gModuleObjects);
DEBUG_ASSERT(NDO && "using uninitialize objects api");
DEBUG_ASSERT(!types.presents(type->name) && "Type Redefinition");
types.put(type->name, type);
type->type_methods.init();
}
Object* objects_api::create(const tp::String& name) {
MODULE_SANITY_CHECK(gModuleObjects);
const ObjectType* type = types.get(name);
Object* obj_instance = ObjectMemAllocate(type);
if (!obj_instance) {
return NULL;
}
hierarchy_construct(obj_instance, obj_instance->type);
setrefc(obj_instance, 0);
NDO_CASTV(ClassObject, obj_instance, classobj);
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);
if (constructor_method) {
interp->execAll(constructor_method, classobj);
}
}
}
return obj_instance;
}
Object* objects_api::copy(Object* self, const Object* in) {
if (self->type != in->type) {
return NULL;
}
hierarchy_copy(self, in, self->type);
return self;
}
bool objects_api::compare(Object* first, Object* second) {
if (first->type == second->type) {
if (first->type->comparison) {
return first->type->comparison(first, second);
}
// raw data comparison
return tp::memCompare(first, second, first->type->size) == 0;
}
return false;
}
Object* objects_api::instatiate(Object* in) {
obj::Object* obj = NDO->create(in->type->name);
NDO->copy(obj, in);
return obj;
}
void objects_api::set(Object* self, tp::alni val) {
if (self->type->convesions && self->type->convesions->from_int) {
self->type->convesions->from_int(self, val);
return;
}
}
void objects_api::set(Object* self, tp::alnf val) {
if (self->type->convesions && self->type->convesions->from_float) {
self->type->convesions->from_float(self, val);
return;
}
}
void objects_api::set(Object* self, tp::String val) {
if (self->type->convesions && self->type->convesions->from_string) {
self->type->convesions->from_string(self, val);
return;
}
}
tp::alni objects_api::toInt(Object* self) {
DEBUG_ASSERT(self->type->convesions && self->type->convesions->to_int);
return self->type->convesions->to_int(self);
}
tp::alnf objects_api::toFloat(Object* self) {
DEBUG_ASSERT(self->type->convesions && self->type->convesions->to_float);
return self->type->convesions->to_float(self);
}
bool objects_api::toBool(Object* self) {
if (self->type->convesions && self->type->convesions->to_int) {
return (bool) self->type->convesions->to_int(self);
}
return true;
}
tp::String objects_api::toString(Object* self) {
DEBUG_ASSERT(self->type->convesions && self->type->convesions->to_string);
return self->type->convesions->to_string(self);
}
void objects_api::destroy(Object* in) {
if (!in) {
return;
}
#ifdef OBJECT_REF_COUNT
ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
if (mh->refc > 1) {
mh->refc--;
return;
}
#endif
NDO_CASTV(ClassObject, in, classobj);
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);
if (constructor_method) {
interp->execAll(constructor_method, classobj);
}
}
}
for (const ObjectType* iter = in->type; iter; iter = iter->base) {
if (iter->destructor) {
iter->destructor(in);
}
}
ObjectMemDeallocate(in);
}
#ifdef OBJECT_REF_COUNT
tp::halni objects_api::getrefc(Object* in) {
ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
return (tp::halni) mh->refc;
}
void objects_api::refinc(Object* in) {
ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
mh->refc++;
}
void objects_api::setrefc(Object* in, tp::halni refc) {
ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in);
mh->refc = refc;
}
#endif
void hierarchy_copy(Object* self, const Object* in, const ObjectType* type) {
if (type->base) {
hierarchy_copy(self, in, type->base);
}
if (type->copy) {
type->copy(self, in);
}
}
void hierarchy_construct(Object* self, const ObjectType* type) {
if (type->base) {
hierarchy_construct(self, type->base);
}
if (type->constructor) {
type->constructor(self);
}
}
Object* 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 NULL;
}
};

877
Objects/private/core/objectsave.cpp
View file

@ -1,444 +1,435 @@
#include "NewPlacement.hpp"
#include "core/object.h"
#include "primitives/nullobject.h"
#include "HeapAllocatorGlobal.hpp"
#include <malloc.h>
namespace obj {
ObjectMemHead* bottom = nullptr;
struct ObjectsFileHeader {
char name[10] = {0};
char version[10] = {0};
ObjectsFileHeader(bool default_val = true) {
if (default_val) {
tp::memCopy(&name, "objects", tp::String::Logic::calcLength("objects") + 1);
tp::memCopy(&version, "0", tp::String::Logic::calcLength("0") + 1);
}
}
};
Object* ObjectMemAllocate(const ObjectType* type) {
ObjectMemHead* memh = (ObjectMemHead*) tp::HeapAllocGlobal::allocate(type->size + sizeof(ObjectMemHead));
if (!memh) {
return NULL;
}
memh->down = NULL;
memh->flags = 0;
#ifdef OBJECT_REF_COUNT
memh->refc = (tp::alni) 1;
#endif
if (bottom) {
bottom->down = memh;
}
memh->up = bottom;
bottom = memh;
NDO_FROM_MEMH(memh)->type = type;
return NDO_FROM_MEMH(memh);
}
void ObjectMemDeallocate(Object* in) {
ObjectMemHead* memh = ((ObjectMemHead*) in) - 1;
if (memh->up) {
memh->up->down = memh->down;
}
if (memh->down) {
memh->down->up = memh->up;
} else {
bottom = memh->up;
}
tp::HeapAllocGlobal::deallocate(memh);
}
void logTypeData(const ObjectType* type) {
printf("type - %s\n", type->name);
if (type->base) {
printf("Based on ");
logTypeData(type->base);
}
}
void assertNoLeaks() {
if (bottom) {
printf("ERROR : not all objects are destroyed\n");
tp::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);
idx++;
}
}
}
struct ObjectFileHead {
Object* load_head_adress = 0;
tp::halni refc = 0;
};
tp::int1* loaded_file = nullptr;
void objects_api::clear_object_flags() {
// clear all object flags
for (ObjectMemHead* iter = bottom; iter; iter = iter->up) {
iter->flags = -1;
}
}
tp::alni& getObjectFlags(Object* in) {
return NDO_MEMH_FROM_NDO(in)->flags;
}
tp::alni objsize_ram_util(Object* self, const ObjectType* type) {
tp::alni out = 0;
if (type->allocated_size) {
out += type->allocated_size(self);
} else {
out += type->size - sizeof(ObjectType*);
}
if (type->base) {
out += objsize_ram_util(self, type->base);
} else {
out += sizeof(ObjectType*);
}
return out;
}
tp::alni objects_api::objsize_ram(Object* self) {
return objsize_ram_util(self, self->type);
}
tp::alni objects_api::objsize_ram_recursive_util(Object* self, const ObjectType* type, bool different_object) {
tp::alni out = 0;
if (different_object) {
if (getObjectFlags(self) == 1) {
return 0;
}
getObjectFlags(self) = 1;
}
if (type->allocated_size_recursive) {
out += type->allocated_size_recursive(self);
} else {
if (type->allocated_size) {
out += type->allocated_size(self);
} else {
out += type->size - sizeof(ObjectType*);
}
}
if (type->base) {
out += objsize_ram_recursive_util(self, type->base, false);
} else {
out += sizeof(ObjectType*);
}
return out;
}
tp::alni objects_api::objsize_ram_recursive(Object* self) {
clear_object_flags();
return objsize_ram_recursive_util(self, self->type);
}
tp::alni objsize_file_util(Object* self, const ObjectType* type) {
tp::alni out = 0;
if (type->save_size) {
out += type->save_size(self);
}
if (type->base) {
out += objsize_file_util(self, type->base);
}
return out;
}
tp::alni objects_api::objsize_file(Object* self) {
return objsize_file_util(self, self->type);
}
tp::alni objsize_file_recursive_util(Object* self, const ObjectType* type) {
tp::alni out = 0;
getObjectFlags(self) = 1;
if (type->save_size) {
out += type->save_size(self);
}
if (type->childs_retrival) {
tp::Buffer<Object*> childs = type->childs_retrival(self);
for (auto child : childs) {
if (getObjectFlags(child.data()) != 1) {
out += objsize_file_recursive_util(child.data(), child.data()->type);
}
}
}
if (type->base) {
out += objsize_file_recursive_util(self, type->base);
}
return out;
}
tp::alni objects_api::objsize_file_recursive(Object* self) {
clear_object_flags();
return objsize_file_recursive_util(self, self->type);
}
void object_recursive_save(ArchiverOut& ndf, Object* self, const ObjectType* type) {
if (type->base) {
object_recursive_save(ndf, self, type->base);
}
// automatically offsets for parent type to write
if (type->save) {
type->save(self, ndf);
}
}
tp::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;
}
// save write adress for parent save function call
tp::alni tmp_adress = ndf.getAddress();
// save requested object to first available adress
tp::alni save_adress = ndf.getFreeAddress();
// save file_adress in memhead
NDO_MEMH_FROM_NDO(in)->flags = save_adress;
// update write adress
ndf.setAddress(save_adress);
// save file object header
ObjectFileHead ofh = { 0, getrefc(in) };
ndf << ofh;
ndf << tp::String(in->type->name);
// allocate for object file header
ndf.setFreeAddress(ndf.getFreeAddress() + sizeof(ObjectFileHead) + tp::SaveSizeCounter::calc(tp::String(in->type->name)));
// calc max size needed for saving all hierarchy of types
tp::alni file_alloc_size = objsize_file_util(in, in->type);
// offes first available adress
ndf.setFreeAddress(ndf.getFreeAddress() + file_alloc_size);
object_recursive_save(ndf, in, in->type);
// restore adress for parent save function
ndf.setAddress(tmp_adress);
// return addres of saved object in file space
return save_adress;
}
void object_recursive_load(ArchiverIn& ndf, Object* out, const ObjectType* type) {
if (type->base) {
object_recursive_load(ndf, out, type->base);
}
// automatically offsets for parent type to read
if (type->load) {
type->load(ndf, out);
}
}
Object* objects_api::load(ArchiverIn& ndf, tp::alni file_adress) {
// check if already saved
if (((ObjectFileHead*) (loaded_file + file_adress))->load_head_adress) {
return ((ObjectFileHead*) (loaded_file + file_adress))->load_head_adress;
}
// save read address
tp::alni parent_file_adress = ndf.getAddress();
// set read address
ndf.setAddress(file_adress);
ObjectFileHead ofh;
ndf >> ofh;
tp::String type_name;
ndf >> type_name;
const ObjectType* object_type = NDO->types.get(type_name);
Object* out = ObjectMemAllocate(object_type);
if (!out) {
return NULL;
}
setrefc(out, 0);
// check for null object
if (out->type == &NullObject::TypeData) {
ObjectMemDeallocate(out);
out = NdoNull_globalInstance;
}
// save heap adress in "loaded_file"
((ObjectFileHead*) (loaded_file + file_adress))->load_head_adress = out;
// loads recursively
object_recursive_load(ndf, out, object_type);
// restore read address for parent call to continue
ndf.setAddress(parent_file_adress);
// return heap memory adress
return out;
}
bool objects_api::save(Object* in, tp::String path, bool compressed) {
ArchiverOut ndf(path.read());
if (!ndf.isOpened()) {
return false;
}
clear_object_flags();
// save version info
ObjectsFileHeader header;
ndf << header;
ndf.setFreeAddress(ndf.getAddress());
// pre allocate
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i]) {
DEBUG_ASSERT(sl_callbacks[i]->size);
ndf.setFreeAddress(ndf.getFreeAddress() + sl_callbacks[i]->size(sl_callbacks[i]->self, ndf));
}
}
// pre-save
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i] && sl_callbacks[i]->pre_save) {
sl_callbacks[i]->pre_save(sl_callbacks[i]->self, ndf);
}
}
save(ndf, in);
// post-save
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i] && sl_callbacks[i]->post_save) {
sl_callbacks[i]->post_save(sl_callbacks[i]->self, ndf);
}
}
// TODO : add compression
/*
if (compressed) {
auto temp = path + ".bz2";
tp::compressF2F(path.read(), temp.cstr());
File::remove(path.read());
File::rename(temp.cstr(), path.read());
}
*/
return true;
}
Object* objects_api::load(tp::String path) {
/*
auto temp_file_name = path + ".unz";
bool unz_res = tp::decompressF2F(path.cstr(), temp_file_name.cstr());
if (!unz_res) {
return NULL;
}
File ndf(temp_file_name.cstr(), tp::osfile_openflags::LOAD);
*/
ArchiverIn ndf(path.read());
if (!ndf.isOpened()) {
return NULL;
}
// check for compatibility
ObjectsFileHeader current_header;
ObjectsFileHeader loaded_header(false);
ndf >> loaded_header;
if (!tp::memEqual(&current_header, &loaded_header, sizeof(ObjectsFileHeader))) {
return NULL;
}
ndf.setAddress(0);
const auto fileSize = ndf.getSize();
loaded_file = (tp::int1*) malloc(fileSize);
tp::memSetVal(loaded_file, fileSize, 0);
ndf.readBytes(loaded_file, fileSize);
ndf.setAddress(sizeof(ObjectsFileHeader));
// preload
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i] && sl_callbacks[i]->pre_load) {
sl_callbacks[i]->pre_load(sl_callbacks[i]->self, ndf);
}
}
Object* out = load(ndf, ndf.getAddress());
// post
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i] && sl_callbacks[i]->post_save) {
sl_callbacks[i]->post_load(sl_callbacks[i]->self, ndf);
}
}
free(loaded_file);
/*
ndf.close();
if (unz_res == NULL) {
File::remove(temp_file_name.cstr());
}
*/
return out;
}
void objects_api::add_sl_callbacks(save_load_callbacks* in) {
sl_callbacks[sl_callbacks_load_idx] = in;
sl_callbacks_load_idx++;
}
#include "NewPlacement.hpp"
#include "core/object.h"
#include "primitives/nullobject.h"
#include "HeapAllocatorGlobal.hpp"
#include <malloc.h>
namespace obj {
ObjectMemHead* bottom = nullptr;
struct ObjectsFileHeader {
char name[10] = { 0 };
char version[10] = { 0 };
ObjectsFileHeader(bool default_val = true) {
if (default_val) {
tp::memCopy(&name, "objects", tp::String::Logic::calcLength("objects") + 1);
tp::memCopy(&version, "0", tp::String::Logic::calcLength("0") + 1);
}
}
};
Object* ObjectMemAllocate(const ObjectType* type) {
ObjectMemHead* memh = (ObjectMemHead*) tp::HeapAllocGlobal::allocate(type->size + sizeof(ObjectMemHead));
if (!memh) {
return NULL;
}
memh->down = NULL;
memh->flags = 0;
#ifdef OBJECT_REF_COUNT
memh->refc = (tp::alni) 1;
#endif
if (bottom) {
bottom->down = memh;
}
memh->up = bottom;
bottom = memh;
NDO_FROM_MEMH(memh)->type = type;
return NDO_FROM_MEMH(memh);
}
void ObjectMemDeallocate(Object* in) {
ObjectMemHead* memh = ((ObjectMemHead*) in) - 1;
if (memh->up) {
memh->up->down = memh->down;
}
if (memh->down) {
memh->down->up = memh->up;
} else {
bottom = memh->up;
}
tp::HeapAllocGlobal::deallocate(memh);
}
void logTypeData(const ObjectType* type) {
printf("type - %s\n", type->name);
if (type->base) {
printf("Based on ");
logTypeData(type->base);
}
}
void assertNoLeaks() {
if (bottom) {
printf("ERROR : not all objects are destroyed\n");
tp::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);
idx++;
}
}
}
struct ObjectFileHead {
Object* load_head_adress = 0;
tp::halni refc = 0;
};
tp::int1* loaded_file = nullptr;
void objects_api::clear_object_flags() {
// clear all object flags
for (ObjectMemHead* iter = bottom; iter; iter = iter->up) {
iter->flags = -1;
}
}
tp::alni& getObjectFlags(Object* in) { return NDO_MEMH_FROM_NDO(in)->flags; }
tp::alni objsize_ram_util(Object* self, const ObjectType* type) {
tp::alni out = 0;
if (type->allocated_size) {
out += type->allocated_size(self);
} else {
out += type->size - sizeof(ObjectType*);
}
if (type->base) {
out += objsize_ram_util(self, type->base);
} else {
out += sizeof(ObjectType*);
}
return out;
}
tp::alni objects_api::objsize_ram(Object* self) { return objsize_ram_util(self, self->type); }
tp::alni objects_api::objsize_ram_recursive_util(Object* self, const ObjectType* type, bool different_object) {
tp::alni out = 0;
if (different_object) {
if (getObjectFlags(self) == 1) {
return 0;
}
getObjectFlags(self) = 1;
}
if (type->allocated_size_recursive) {
out += type->allocated_size_recursive(self);
} else {
if (type->allocated_size) {
out += type->allocated_size(self);
} else {
out += type->size - sizeof(ObjectType*);
}
}
if (type->base) {
out += objsize_ram_recursive_util(self, type->base, false);
} else {
out += sizeof(ObjectType*);
}
return out;
}
tp::alni objects_api::objsize_ram_recursive(Object* self) {
clear_object_flags();
return objsize_ram_recursive_util(self, self->type);
}
tp::alni objsize_file_util(Object* self, const ObjectType* type) {
tp::alni out = 0;
if (type->save_size) {
out += type->save_size(self);
}
if (type->base) {
out += objsize_file_util(self, type->base);
}
return out;
}
tp::alni objects_api::objsize_file(Object* self) { return objsize_file_util(self, self->type); }
tp::alni objsize_file_recursive_util(Object* self, const ObjectType* type) {
tp::alni out = 0;
getObjectFlags(self) = 1;
if (type->save_size) {
out += type->save_size(self);
}
if (type->childs_retrival) {
tp::Buffer<Object*> childs = type->childs_retrival(self);
for (auto child : childs) {
if (getObjectFlags(child.data()) != 1) {
out += objsize_file_recursive_util(child.data(), child.data()->type);
}
}
}
if (type->base) {
out += objsize_file_recursive_util(self, type->base);
}
return out;
}
tp::alni objects_api::objsize_file_recursive(Object* self) {
clear_object_flags();
return objsize_file_recursive_util(self, self->type);
}
void object_recursive_save(ArchiverOut& ndf, Object* self, const ObjectType* type) {
if (type->base) {
object_recursive_save(ndf, self, type->base);
}
// automatically offsets for parent type to write
if (type->save) {
type->save(self, ndf);
}
}
tp::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;
}
// save write adress for parent save function call
tp::alni tmp_adress = ndf.getAddress();
// save requested object to first available adress
tp::alni save_adress = ndf.getFreeAddress();
// save file_adress in memhead
NDO_MEMH_FROM_NDO(in)->flags = save_adress;
// update write adress
ndf.setAddress(save_adress);
// save file object header
ObjectFileHead ofh = { 0, getrefc(in) };
ndf << ofh;
ndf << tp::String(in->type->name);
// allocate for object file header
ndf.setFreeAddress(ndf.getFreeAddress() + sizeof(ObjectFileHead) + tp::SaveSizeCounter::calc(tp::String(in->type->name)));
// calc max size needed for saving all hierarchy of types
tp::alni file_alloc_size = objsize_file_util(in, in->type);
// offes first available adress
ndf.setFreeAddress(ndf.getFreeAddress() + file_alloc_size);
object_recursive_save(ndf, in, in->type);
// restore adress for parent save function
ndf.setAddress(tmp_adress);
// return addres of saved object in file space
return save_adress;
}
void object_recursive_load(ArchiverIn& ndf, Object* out, const ObjectType* type) {
if (type->base) {
object_recursive_load(ndf, out, type->base);
}
// automatically offsets for parent type to read
if (type->load) {
type->load(ndf, out);
}
}
Object* objects_api::load(ArchiverIn& ndf, tp::alni file_adress) {
// check if already saved
if (((ObjectFileHead*) (loaded_file + file_adress))->load_head_adress) {
return ((ObjectFileHead*) (loaded_file + file_adress))->load_head_adress;
}
// save read address
tp::alni parent_file_adress = ndf.getAddress();
// set read address
ndf.setAddress(file_adress);
ObjectFileHead ofh;
ndf >> ofh;
tp::String type_name;
ndf >> type_name;
const ObjectType* object_type = NDO->types.get(type_name);
Object* out = ObjectMemAllocate(object_type);
if (!out) {
return NULL;
}
setrefc(out, 0);
// check for null object
if (out->type == &NullObject::TypeData) {
ObjectMemDeallocate(out);
out = NdoNull_globalInstance;
}
// save heap adress in "loaded_file"
((ObjectFileHead*) (loaded_file + file_adress))->load_head_adress = out;
// loads recursively
object_recursive_load(ndf, out, object_type);
// restore read address for parent call to continue
ndf.setAddress(parent_file_adress);
// return heap memory adress
return out;
}
bool objects_api::save(Object* in, tp::String path, bool compressed) {
ArchiverOut ndf(path.read());
if (!ndf.isOpened()) {
return false;
}
clear_object_flags();
// save version info
ObjectsFileHeader header;
ndf << header;
ndf.setFreeAddress(ndf.getAddress());
// pre allocate
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i]) {
DEBUG_ASSERT(sl_callbacks[i]->size);
ndf.setFreeAddress(ndf.getFreeAddress() + sl_callbacks[i]->size(sl_callbacks[i]->self, ndf));
}
}
// pre-save
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i] && sl_callbacks[i]->pre_save) {
sl_callbacks[i]->pre_save(sl_callbacks[i]->self, ndf);
}
}
save(ndf, in);
// post-save
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i] && sl_callbacks[i]->post_save) {
sl_callbacks[i]->post_save(sl_callbacks[i]->self, ndf);
}
}
// TODO : add compression
/*
if (compressed) {
auto temp = path + ".bz2";
tp::compressF2F(path.read(), temp.cstr());
File::remove(path.read());
File::rename(temp.cstr(), path.read());
}
*/
return true;
}
Object* objects_api::load(tp::String path) {
/*
auto temp_file_name = path + ".unz";
bool unz_res = tp::decompressF2F(path.cstr(), temp_file_name.cstr());
if (!unz_res) {
return NULL;
}
File ndf(temp_file_name.cstr(), tp::osfile_openflags::LOAD);
*/
ArchiverIn ndf(path.read());
if (!ndf.isOpened()) {
return NULL;
}
// check for compatibility
ObjectsFileHeader current_header;
ObjectsFileHeader loaded_header(false);
ndf >> loaded_header;
if (!tp::memEqual(&current_header, &loaded_header, sizeof(ObjectsFileHeader))) {
return NULL;
}
ndf.setAddress(0);
const auto fileSize = ndf.getSize();
loaded_file = (tp::int1*) malloc(fileSize);
tp::memSetVal(loaded_file, fileSize, 0);
ndf.readBytes(loaded_file, fileSize);
ndf.setAddress(sizeof(ObjectsFileHeader));
// preload
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i] && sl_callbacks[i]->pre_load) {
sl_callbacks[i]->pre_load(sl_callbacks[i]->self, ndf);
}
}
Object* out = load(ndf, ndf.getAddress());
// post
for (tp::alni i = 0; i < SAVE_LOAD_MAX_CALLBACK_SLOTS; i++) {
if (sl_callbacks[i] && sl_callbacks[i]->post_save) {
sl_callbacks[i]->post_load(sl_callbacks[i]->self, ndf);
}
}
free(loaded_file);
/*
ndf.close();
if (unz_res == NULL) {
File::remove(temp_file_name.cstr());
}
*/
return out;
}
void objects_api::add_sl_callbacks(save_load_callbacks* in) {
sl_callbacks[sl_callbacks_load_idx] = in;
sl_callbacks_load_idx++;
}
};

523
Objects/private/core/scriptsection.cpp
View file

@ -1,268 +1,255 @@
#include "NewPlacement.hpp"
#include "HeapAllocatorGlobal.hpp"
#include "core/scriptsection.h"
using namespace obj;
ScriptSection* gScriptSection = NULL;
struct script_data_head {
tp::alni refc = 0;
tp::alni store_adress = 0;
};
void set_script_head_store_adress(Script* in, tp::alni address) {
((script_data_head*)in - 1)->store_adress = address;
}
tp::alni get_script_head_store_adress(Script* in) {
return ((script_data_head*)in - 1)->store_adress;
}
Script* ScriptSection::createScript() {
auto sdhead = (script_data_head*)tp::HeapAllocGlobal::allocate(sizeof(script_data_head) + sizeof(Script));
auto out = (Script*)(sdhead + 1);
if (!sdhead) {
return NULL;
}
sdhead->refc = 1;
sdhead->store_adress = -1;
mScripts.pushBack(out);
new (out) Script();
out->mReadable = obj::StringObject::create("");
obj::NDO->refinc(out->mReadable);
return out;
}
void ScriptSection::delete_script(Script* script) {
script->~Script();
obj::NDO->destroy(script->mReadable);
tp::HeapAllocGlobal::deallocate((((script_data_head*)script) - 1));
}
void ScriptSection::reference_script(Script* script) {
(((script_data_head*)script) - 1)->refc++;
}
void ScriptSection::abandonScript(Script* script) {
if ((((script_data_head*)script) - 1)->refc > 1) {
(((script_data_head*)script) - 1)->refc--;
}
else {
// ISSUE : on delete list structure is outdated
// FIXME : use pool alloc with ref count
// forwarding to global destruction
//delete_script(script);
}
}
void ScriptSection::changeScript(Script** current_script, Script** new_script) {
abandonScript(*current_script);
reference_script(*new_script);
*current_script = *new_script;
}
tp::alni ScriptSection::get_script_file_adress(Script* in) {
return get_script_head_store_adress(in);
}
tp::alni ScriptSection::save_script_table_to_file_size(ScriptSection* self, ArchiverOut& file) {
tp::alni size = 0;
size += 5; // header
size += sizeof(tp::alni); // scripts length
for (auto iter : self->mScripts) {
set_script_head_store_adress(iter.data(), file.getAddress() + size);
size += sizeof(tp::alni); // scripts string obj ref
size += sizeof(tp::alni); // constants length
for (auto const_obj : iter->mBytecode.mConstants) {
size += sizeof(tp::alni); // constant object addres
}
// instructions
size += tp::SaveSizeCounter::calc(iter->mBytecode.mInstructions);
}
size += sizeof(tp::alni); // objects mem offset
size += 5; // header
return size;
}
void ScriptSection::save_script_table_to_file(ScriptSection* self, ArchiverOut& file) {
// header
file.writeBytes("/scr/", 5);
// scripts length
tp::alni scripts_count = self->mScripts.length();
file << scripts_count;
for (auto iter : self->mScripts) {
// scripts string obj ref
auto obj_addres = obj::NDO->save(file, iter->mReadable);
file << obj_addres;
// constants length
tp::alni consts_count = iter->mBytecode.mConstants.size();
file << consts_count;
for (auto const_obj : iter->mBytecode.mConstants) {
// constant object addres
auto obj_addres = obj::NDO->save(file, const_obj.data());
file << obj_addres;
}
// mInstructions
file << iter->mBytecode.mInstructions;
}
// header
file.writeBytes("/scr/", 5);
tp::alni objects_mem_offset = file.getFreeAddress();
file << objects_mem_offset;
}
void load_constants(ScriptSection* self, ArchiverIn& file, tp::alni start_addr) {
auto addres = file.getAddress();
file.setAddress(start_addr);
file.setAddress( start_addr + 5); // header
tp::alni scripts_count;
file >> scripts_count;
for (tp::alni i = 0; i < scripts_count; i++) {
auto script = self->get_scritp_from_file_adress(file.getAddress());
// script text
tp::alni str_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));
file.setAddress(file.getAddress() + sizeof(tp::alni)); // constants length
for (auto const_obj : script->mBytecode.mConstants) {
tp::alni consts_addr;
file >> consts_addr;
const_obj.data() = obj::NDO->load(file, consts_addr);
}
// instructions
file.setAddress(file.getAddress() + tp::SaveSizeCounter::calc(script->mBytecode.mInstructions));
}
file.setAddress(addres);
}
void ScriptSection::load_script_table_from_file(ScriptSection* self, ArchiverIn& file) {
for (auto iter : self->mScripts) {
set_script_head_store_adress(iter.data(), -1);
}
auto section_start_addr = file.getAddress();
// header
file.setAddress(file.getAddress() + 5);
// scripts length
tp::alni scripts_count;
file >> scripts_count;
for (tp::alni i = 0; i < scripts_count; i++) {
auto new_script = self->createScript();
set_script_head_store_adress(new_script, file.getAddress());
// scripts text
file.setAddress(file.getAddress() + sizeof(tp::alni));
// constants length
tp::alni consts_count;
file >> consts_count;
new_script->mBytecode.mConstants.reserve(consts_count);
for (tp::alni j = 0; j < consts_count; j++) {
// constant object addres
tp::alni consts_addr;
file >> consts_addr;
// skiping
//new_script->mBytecode.mConstants[j] = obj::NDO->load(file, consts_addr);
}
// mInstructions
file >> new_script->mBytecode.mInstructions;
}
load_constants(self, file, section_start_addr);
// header
file.setAddress(file.getAddress() + 5);
tp::alni objects_mem_offset;
file >> objects_mem_offset;
file.setAddress(objects_mem_offset);
}
Script* ScriptSection::get_scritp_from_file_adress(tp::alni file_adress) {
for (auto iter : mScripts) {
if (get_script_head_store_adress(iter.data()) == file_adress) {
return iter.data();
}
}
return NULL;
}
ScriptSection::~ScriptSection() {
for (auto iter : mScripts) {
delete_script(iter.data());
}
}
obj::save_load_callbacks ScriptSection::slcb_script_section = {
.self = gScriptSection,
.pre_save = (obj::pre_save_callback*)ScriptSection::save_script_table_to_file,
.size = (obj::slcb_size_callback*)ScriptSection::save_script_table_to_file_size,
.pre_load = (obj::pre_load_callback*)ScriptSection::load_script_table_from_file,
.post_save = NULL,
.post_load = NULL,
};
void ScriptSection::initialize() {
ASSERT(!gScriptSection);
gScriptSection = new ScriptSection();
ASSERT(obj::NDO && "Forgot to initialize objects?");
slcb_script_section.self = gScriptSection;
obj::NDO->add_sl_callbacks(&slcb_script_section);
}
void ScriptSection::uninitialize() {
ASSERT(gScriptSection);
delete gScriptSection;
gScriptSection = nullptr;
}
ScriptSection* ScriptSection::globalHandle() {
return gScriptSection;
}
#include "HeapAllocatorGlobal.hpp"
#include "NewPlacement.hpp"
#include "core/scriptsection.h"
using namespace obj;
ScriptSection* gScriptSection = NULL;
struct script_data_head {
tp::alni refc = 0;
tp::alni store_adress = 0;
};
void set_script_head_store_adress(Script* in, tp::alni address) { ((script_data_head*) in - 1)->store_adress = address; }
tp::alni get_script_head_store_adress(Script* in) { return ((script_data_head*) in - 1)->store_adress; }
Script* ScriptSection::createScript() {
auto sdhead = (script_data_head*) tp::HeapAllocGlobal::allocate(sizeof(script_data_head) + sizeof(Script));
auto out = (Script*) (sdhead + 1);
if (!sdhead) {
return NULL;
}
sdhead->refc = 1;
sdhead->store_adress = -1;
mScripts.pushBack(out);
new (out) Script();
out->mReadable = obj::StringObject::create("");
obj::NDO->refinc(out->mReadable);
return out;
}
void ScriptSection::delete_script(Script* script) {
script->~Script();
obj::NDO->destroy(script->mReadable);
tp::HeapAllocGlobal::deallocate((((script_data_head*) script) - 1));
}
void ScriptSection::reference_script(Script* script) { (((script_data_head*) script) - 1)->refc++; }
void ScriptSection::abandonScript(Script* script) {
if ((((script_data_head*) script) - 1)->refc > 1) {
(((script_data_head*) script) - 1)->refc--;
} else {
// ISSUE : on delete list structure is outdated
// FIXME : use pool alloc with ref count
// forwarding to global destruction
// delete_script(script);
}
}
void ScriptSection::changeScript(Script** current_script, Script** new_script) {
abandonScript(*current_script);
reference_script(*new_script);
*current_script = *new_script;
}
tp::alni ScriptSection::get_script_file_adress(Script* in) { return get_script_head_store_adress(in); }
tp::alni ScriptSection::save_script_table_to_file_size(ScriptSection* self, ArchiverOut& file) {
tp::alni size = 0;
size += 5; // header
size += sizeof(tp::alni); // scripts length
for (auto iter : self->mScripts) {
set_script_head_store_adress(iter.data(), file.getAddress() + size);
size += sizeof(tp::alni); // scripts string obj ref
size += sizeof(tp::alni); // constants length
for (auto const_obj : iter->mBytecode.mConstants) {
size += sizeof(tp::alni); // constant object addres
}
// instructions
size += tp::SaveSizeCounter::calc(iter->mBytecode.mInstructions);
}
size += sizeof(tp::alni); // objects mem offset
size += 5; // header
return size;
}
void ScriptSection::save_script_table_to_file(ScriptSection* self, ArchiverOut& file) {
// header
file.writeBytes("/scr/", 5);
// scripts length
tp::alni scripts_count = self->mScripts.length();
file << scripts_count;
for (auto iter : self->mScripts) {
// scripts string obj ref
auto obj_addres = obj::NDO->save(file, iter->mReadable);
file << obj_addres;
// constants length
tp::alni consts_count = iter->mBytecode.mConstants.size();
file << consts_count;
for (auto const_obj : iter->mBytecode.mConstants) {
// constant object addres
auto obj_addres = obj::NDO->save(file, const_obj.data());
file << obj_addres;
}
// mInstructions
file << iter->mBytecode.mInstructions;
}
// header
file.writeBytes("/scr/", 5);
tp::alni objects_mem_offset = file.getFreeAddress();
file << objects_mem_offset;
}
void load_constants(ScriptSection* self, ArchiverIn& file, tp::alni start_addr) {
auto addres = file.getAddress();
file.setAddress(start_addr);
file.setAddress(start_addr + 5); // header
tp::alni scripts_count;
file >> scripts_count;
for (tp::alni i = 0; i < scripts_count; i++) {
auto script = self->get_scritp_from_file_adress(file.getAddress());
// script text
tp::alni str_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));
file.setAddress(file.getAddress() + sizeof(tp::alni)); // constants length
for (auto const_obj : script->mBytecode.mConstants) {
tp::alni consts_addr;
file >> consts_addr;
const_obj.data() = obj::NDO->load(file, consts_addr);
}
// instructions
file.setAddress(file.getAddress() + tp::SaveSizeCounter::calc(script->mBytecode.mInstructions));
}
file.setAddress(addres);
}
void ScriptSection::load_script_table_from_file(ScriptSection* self, ArchiverIn& file) {
for (auto iter : self->mScripts) {
set_script_head_store_adress(iter.data(), -1);
}
auto section_start_addr = file.getAddress();
// header
file.setAddress(file.getAddress() + 5);
// scripts length
tp::alni scripts_count;
file >> scripts_count;
for (tp::alni i = 0; i < scripts_count; i++) {
auto new_script = self->createScript();
set_script_head_store_adress(new_script, file.getAddress());
// scripts text
file.setAddress(file.getAddress() + sizeof(tp::alni));
// constants length
tp::alni consts_count;
file >> consts_count;
new_script->mBytecode.mConstants.reserve(consts_count);
for (tp::alni j = 0; j < consts_count; j++) {
// constant object addres
tp::alni consts_addr;
file >> consts_addr;
// skiping
// new_script->mBytecode.mConstants[j] = obj::NDO->load(file, consts_addr);
}
// mInstructions
file >> new_script->mBytecode.mInstructions;
}
load_constants(self, file, section_start_addr);
// header
file.setAddress(file.getAddress() + 5);
tp::alni objects_mem_offset;
file >> objects_mem_offset;
file.setAddress(objects_mem_offset);
}
Script* ScriptSection::get_scritp_from_file_adress(tp::alni file_adress) {
for (auto iter : mScripts) {
if (get_script_head_store_adress(iter.data()) == file_adress) {
return iter.data();
}
}
return NULL;
}
ScriptSection::~ScriptSection() {
for (auto iter : mScripts) {
delete_script(iter.data());
}
}
obj::save_load_callbacks ScriptSection::slcb_script_section = {
.self = gScriptSection,
.pre_save = (obj::pre_save_callback*) ScriptSection::save_script_table_to_file,
.size = (obj::slcb_size_callback*) ScriptSection::save_script_table_to_file_size,
.pre_load = (obj::pre_load_callback*) ScriptSection::load_script_table_from_file,
.post_save = NULL,
.post_load = NULL,
};
void ScriptSection::initialize() {
ASSERT(!gScriptSection);
gScriptSection = new ScriptSection();
ASSERT(obj::NDO && "Forgot to initialize objects?");
slcb_script_section.self = gScriptSection;
obj::NDO->add_sl_callbacks(&slcb_script_section);
}
void ScriptSection::uninitialize() {
ASSERT(gScriptSection);
delete gScriptSection;
gScriptSection = nullptr;
}
ScriptSection* ScriptSection::globalHandle() { return gScriptSection; }

162
Objects/private/core/typegroups.cpp
View file

@ -1,81 +1,83 @@
#include "NewPlacement.hpp"
#include "core/typegroups.h"
#include "core/object.h"
using namespace obj;
obj::TypeGroups::TypeGroups() : is_group(true) {
new (&childs) Dict();
}
obj::TypeGroups::TypeGroups(bool is_group) : is_group(is_group) {
if (is_group) {
new (&childs) Dict();
} else {
type = NULL;
}
}
bool obj::TypeGroups::isGroup() { return is_group; }
obj::TypeGroups::Dict* obj::TypeGroups::getChilds() {
DEBUG_ASSERT(is_group);
return &childs;
}
void obj::TypeGroups::setType(ObjectType* type) {
DEBUG_ASSERT(!is_group);
this->type = type;
}
void obj::TypeGroups::addType(ObjectType* type, tp::InitialierList<const char*> path, tp::alni cur_dir_idx) {
DEBUG_ASSERT(is_group);
tp::alni dir_len = (tp::alni) path.size();
if (dir_len == cur_dir_idx) {
TypeGroups* type_ref = new TypeGroups(false);
type_ref->setType(type);
childs.put(type->name, type_ref);
return;
}
TypeGroups* group = NULL;
tp::alni index = 0;
for (auto dir : path) {
if (index != cur_dir_idx) {
index++;
continue;
}
auto child_idx = childs.presents(dir);
if (child_idx) {
group = childs.getSlotVal(child_idx);
} else {
group = new TypeGroups(true);
childs.put(dir, group);
}
group->addType(type, path, cur_dir_idx + 1);
break;
}
}
const obj::ObjectType* obj::TypeGroups::getType() {
DEBUG_ASSERT(!is_group);
return type;
}
obj::TypeGroups::~TypeGroups() {
if (is_group) {
for (auto& child : childs) {
delete child->val;
}
childs.~Map();
}
#include "NewPlacement.hpp"
#include "core/typegroups.h"
#include "core/object.h"
using namespace obj;
obj::TypeGroups::TypeGroups() :
is_group(true) {
new (&childs) Dict();
}
obj::TypeGroups::TypeGroups(bool is_group) :
is_group(is_group) {
if (is_group) {
new (&childs) Dict();
} else {
type = NULL;
}
}
bool obj::TypeGroups::isGroup() { return is_group; }
obj::TypeGroups::Dict* obj::TypeGroups::getChilds() {
DEBUG_ASSERT(is_group);
return &childs;
}
void obj::TypeGroups::setType(ObjectType* type) {
DEBUG_ASSERT(!is_group);
this->type = type;
}
void obj::TypeGroups::addType(ObjectType* type, tp::InitialierList<const char*> path, tp::alni cur_dir_idx) {
DEBUG_ASSERT(is_group);
tp::alni dir_len = (tp::alni) path.size();
if (dir_len == cur_dir_idx) {
TypeGroups* type_ref = new TypeGroups(false);
type_ref->setType(type);
childs.put(type->name, type_ref);
return;
}
TypeGroups* group = NULL;
tp::alni index = 0;
for (auto dir : path) {
if (index != cur_dir_idx) {
index++;
continue;
}
auto child_idx = childs.presents(dir);
if (child_idx) {
group = childs.getSlotVal(child_idx);
} else {
group = new TypeGroups(true);
childs.put(dir, group);
}
group->addType(type, path, cur_dir_idx + 1);
break;
}
}
const obj::ObjectType* obj::TypeGroups::getType() {
DEBUG_ASSERT(!is_group);
return type;
}
obj::TypeGroups::~TypeGroups() {
if (is_group) {
for (auto& child : childs) {
delete child->val;
}
childs.~Map();
}
}

270
Objects/private/core/typemethods.cpp
View file

@ -1,138 +1,134 @@
#include "NewPlacement.hpp"
#include "core/typemethods.h"
#include "primitives/nullobject.h"
#include "primitives/typeobject.h"
#include "primitives/floatobject.h"
#include "interpreter/interpreter.h"
using namespace obj;
TypeMethod obj::gDefaultTypeMethods[] = {
{
.nameid = "type",
.descr = "retrieves typeobject",
.exec = [](const TypeMethod* tm) {
tm->ret.obj = TypeObject::create(tm->self->type);
},
.ret = { "typeobject", NULL },
},
{
.nameid = "to_str",
.descr = "converts to string",
.exec = [](const TypeMethod* tm) {
if (tm->self->type->convesions && tm->self->type->convesions->to_string) {
tm->ret.obj = StringObject::create(NDO->toString(tm->self));
}
},
.ret = { "string object", NULL },
},
{
.nameid = "to_float",
.descr = "converts to float",
.exec = [](const TypeMethod* tm) {
if (tm->self->type->convesions && tm->self->type->convesions->to_float) {
tm->ret.obj = FloatObject::create(NDO->toFloat(tm->self));
}
},
.ret = { "string object", NULL },
},
};
tp::int2 TypeMethods::presents(tp::String id) const {
for (tp::int2 idx = 0; idx < mNMethods; idx++) {
if (id == methods[idx]->nameid) {
return idx;
}
}
tp::int2 idx = 0;
for (auto& tm : gDefaultTypeMethods) {
if (id == tm.nameid) {
return { tp::int2(idx + MAX_TYPE_METHODS) };
}
idx++;
}
return -1;
}
TypeMethods::LookupKey TypeMethods::presents(const ObjectType* type, tp::String id) {
tp::int2 depth = 0;
tp::int2 idx = 0;
for (auto iter_type = type; iter_type; iter_type = iter_type->base) {
idx = iter_type->type_methods.presents(id);
if (idx != -1) {
break;
}
depth++;
}
return { idx, depth};
}
const TypeMethod* TypeMethods::getMethod(tp::int2 key) const {
if (key < MAX_TYPE_METHODS) {
return methods[key];
}
return &gDefaultTypeMethods[key - MAX_TYPE_METHODS];
}
const TypeMethod* TypeMethods::getMethod(const ObjectType* type, LookupKey key) {
auto type_iter = type;
for (auto idx = 0; idx < key.type_depth; idx++) {
type_iter = type_iter->base;
}
return type_iter->type_methods.getMethod(key.key);
}
void TypeMethods::init() {
while (methods[mNMethods]) {
mNMethods++;
}
for (tp::int1 i = 0; i < mNMethods; i++) {
methods[i]->init();
}
// initialize and use finate state automata to lookup methods
}
tp::halni TypeMethods::nMethods() const {
return mNMethods;
}
void TypeMethod::operator()(Interpreter* interp) const{
for (auto i = 1; i <= mNargs; i++) {
args[mNargs - i].obj = interp->mOperandsStack.getOperand();
//NDO->refinc(args[i].obj);
ASSERT(args[mNargs - i].obj && "expected an argument");
}
ASSERT(!interp->mOperandsStack.getOperand() && "args remained");
interp->mOperandsStack.getOperand();
self = interp->mLastParent;
exec(this);
if (ret.obj) {
interp->mOperandsStack.push(ret.obj);
interp->mScopeStack.addTempReturn(ret.obj);
}
else {
interp->mOperandsStack.push(NDO_NULL_REF);
}
}
void TypeMethod::init() {
while (args[mNargs].descr) {
mNargs++;
}
#include "NewPlacement.hpp"
#include "core/typemethods.h"
#include "primitives/floatobject.h"
#include "primitives/nullobject.h"
#include "primitives/typeobject.h"
#include "interpreter/interpreter.h"
using namespace obj;
TypeMethod obj::gDefaultTypeMethods[] = {
{
.nameid = "type",
.descr = "retrieves typeobject",
.exec = [](const TypeMethod* tm) { tm->ret.obj = TypeObject::create(tm->self->type); },
.ret = { "typeobject", NULL },
},
{
.nameid = "to_str",
.descr = "converts to string",
.exec =
[](const TypeMethod* tm) {
if (tm->self->type->convesions && tm->self->type->convesions->to_string) {
tm->ret.obj = StringObject::create(NDO->toString(tm->self));
}
},
.ret = { "string object", NULL },
},
{
.nameid = "to_float",
.descr = "converts to float",
.exec =
[](const TypeMethod* tm) {
if (tm->self->type->convesions && tm->self->type->convesions->to_float) {
tm->ret.obj = FloatObject::create(NDO->toFloat(tm->self));
}
},
.ret = { "string object", NULL },
},
};
tp::int2 TypeMethods::presents(tp::String id) const {
for (tp::int2 idx = 0; idx < mNMethods; idx++) {
if (id == methods[idx]->nameid) {
return idx;
}
}
tp::int2 idx = 0;
for (auto& tm : gDefaultTypeMethods) {
if (id == tm.nameid) {
return { tp::int2(idx + MAX_TYPE_METHODS) };
}
idx++;
}
return -1;
}
TypeMethods::LookupKey TypeMethods::presents(const ObjectType* type, tp::String id) {
tp::int2 depth = 0;
tp::int2 idx = 0;
for (auto iter_type = type; iter_type; iter_type = iter_type->base) {
idx = iter_type->type_methods.presents(id);
if (idx != -1) {
break;
}
depth++;
}
return { idx, depth };
}
const TypeMethod* TypeMethods::getMethod(tp::int2 key) const {
if (key < MAX_TYPE_METHODS) {
return methods[key];
}
return &gDefaultTypeMethods[key - MAX_TYPE_METHODS];
}
const TypeMethod* TypeMethods::getMethod(const ObjectType* type, LookupKey key) {
auto type_iter = type;
for (auto idx = 0; idx < key.type_depth; idx++) {
type_iter = type_iter->base;
}
return type_iter->type_methods.getMethod(key.key);
}
void TypeMethods::init() {
while (methods[mNMethods]) {
mNMethods++;
}
for (tp::int1 i = 0; i < mNMethods; i++) {
methods[i]->init();
}
// initialize and use finate state automata to lookup methods
}
tp::halni TypeMethods::nMethods() const { return mNMethods; }
void TypeMethod::operator()(Interpreter* interp) const {
for (auto i = 1; i <= mNargs; i++) {
args[mNargs - i].obj = interp->mOperandsStack.getOperand();
// NDO->refinc(args[i].obj);
ASSERT(args[mNargs - i].obj && "expected an argument");
}
ASSERT(!interp->mOperandsStack.getOperand() && "args remained");
interp->mOperandsStack.getOperand();
self = interp->mLastParent;
exec(this);
if (ret.obj) {
interp->mOperandsStack.push(ret.obj);
interp->mScopeStack.addTempReturn(ret.obj);
} else {
interp->mOperandsStack.push(NDO_NULL_REF);
}
}
void TypeMethod::init() {
while (args[mNargs].descr) {
mNargs++;
}
}

76
Objects/private/interpreter/callstack.cpp
View file

@ -1,40 +1,36 @@
#include "NewPlacement.hpp"
#include "interpreter/callstack.h"
#include "interpreter/bytecode.h"
#include "primitives/methodobject.h"
using namespace obj;
void CallStack::enter(const CallStack::CallFrame& frame) {
if (mStack.size()) {
auto& last_frame = mStack.last();
last_frame.mIp = last_frame.mMethod->mScript->mBytecode.mInstructionIdx;
}
frame.mMethod->mScript->mBytecode.mArgumentsLoaded = 0;
frame.mMethod->mScript->mBytecode.mInstructionIdx = 0;
obj::NDO->refinc(frame.mMethod);
mStack.append(frame);
}
void CallStack::leave() {
auto frame = mStack.last();
obj::NDO->destroy(frame.mMethod);
mStack.pop();
if (mStack.size()) {
auto& last_frame = mStack.last();
last_frame.mMethod->mScript->mBytecode.mInstructionIdx = last_frame.mIp;
}
}
ByteCode* CallStack::getBytecode() {
return &mStack.last().mMethod->mScript->mBytecode;
}
tp::halni CallStack::len() const {
return mStack.size();
}
#include "NewPlacement.hpp"
#include "interpreter/callstack.h"
#include "interpreter/bytecode.h"
#include "primitives/methodobject.h"
using namespace obj;
void CallStack::enter(const CallStack::CallFrame& frame) {
if (mStack.size()) {
auto& last_frame = mStack.last();
last_frame.mIp = last_frame.mMethod->mScript->mBytecode.mInstructionIdx;
}
frame.mMethod->mScript->mBytecode.mArgumentsLoaded = 0;
frame.mMethod->mScript->mBytecode.mInstructionIdx = 0;
obj::NDO->refinc(frame.mMethod);
mStack.append(frame);
}
void CallStack::leave() {
auto frame = mStack.last();
obj::NDO->destroy(frame.mMethod);
mStack.pop();
if (mStack.size()) {
auto& last_frame = mStack.last();
last_frame.mMethod->mScript->mBytecode.mInstructionIdx = last_frame.mIp;
}
}
ByteCode* CallStack::getBytecode() { return &mStack.last().mMethod->mScript->mBytecode; }
tp::halni CallStack::len() const { return mStack.size(); }

1180
Objects/private/interpreter/interpreter.cpp
View file

File diff suppressed because it is too large Load diff

755
Objects/private/interpreter/opcodes.cpp
View file

@ -1,384 +1,371 @@
#include "Utils.hpp"
#include "interpreter/opcodes.h"
namespace obj {
OpcodeInfos gOpcodeInfos;
};
using namespace obj;
#define CONST_IDX_BYTES 2
#define OP(opcode, name, desc, ops, params) \
add(opcode, { #name, #desc, ops, params } );
OpcodeInfos::OperandsInfo::OperandsInfo() {}
OpcodeInfos::OperandsInfo::OperandsInfo(tp::InitialierList<Operand> list) {
DEBUG_ASSERT(MAX_OPERANDS >= list.size());
for (auto item : list) {
buff[len] = item;
len++;
}
}
OpcodeInfos::ParamsInfo::ParamsInfo() {}
OpcodeInfos::ParamsInfo::ParamsInfo(tp::InitialierList<Param> list) {
DEBUG_ASSERT(MAX_PARAMS >= list.size());
for (auto item : list) {
buff[len] = item;
len++;
}
}
tp::uint1 OpcodeInfos::OpInfo::opsize() {
tp::uint1 out = 1;
for (auto i = 0; i < params.len; i++) {
out += params.buff[i].bytes;
}
return out;
}
OpcodeInfos::OpcodeInfos() {
add(OpCode::NONE, { "NONE", "Does Nothing" });
add(OpCode::HALT, { "HALT", "Halts for 3 sec" });
add(OpCode::TERMINATE, { "TERMINATE", "Terminates the process" });
add(OpCode::DEF_LOCAL, {
.name = "DEF LOCAL",
.desc = "Adds object to the locals",
.operands = {
{ "str", "local id" },
{ "any", "object to be local" }
}
}
);
add(OpCode::LOAD_CONST, {
.name = "LOAD CONST",
.desc = "Loads const object from the const pool",
.params = {
{ "const obj idx", CONST_IDX_BYTES },
}
}
);
add(OpCode::LOAD_LOCAL, {
.name = "LOAD LOCAL",
.desc = "Loads local object from the locals",
.params = {
{ "idx of const StringObject - represents name id", CONST_IDX_BYTES },
}
}
);
add(OpCode::IGNORE, {
.name = "IGNORE",
.desc = "Ignores returned object by destroying it",
}
);
add(OpCode::SCOPE_IN, {
.name = "SCOPE IN",
.desc = "Enters new scope",
}
);
add(OpCode::SCOPE_OUT, {
.name = "SCOPE OUT",
.desc = "Leaves current scope",
}
);
add(OpCode::CALL, {
.name = "CALL",
.desc = "Leaves current scope",
.operands = {
{ "method", "method object" },
}
}
);
add(OpCode::RETURN_OBJ, {
.name = "RETURN OBJ",
.desc = "Returns Operand",
.operands = {
{ "any", "object to be returned" },
}
}
);
add(OpCode::RETURN, {
.name = "RETURN",
.desc = "Returns Null Object",
}
);
add(OpCode::CHILD, {
.name = "CHILD",
.desc = "Retrieves child from class",
.operands = {
{ "str", "child id" },
{ "class", "parent class" },
},
.params = {
{ "is method ?", 1 }
}
}
);
add(OpCode::PUSH_ARGS, {
.name = "PUSH ARGS",
.desc = "Pushes Separator on the OperandsStack",
.params = {
{ "length to chech number of args", 1 }
}
}
);
add(OpCode::SAVE_ARGS, {
.name = "SAVE ARGS",
.desc = "Pushes operands to locals",
.params = {
{ "number of arguments in function defenition", 1 }
}
}
);
add(OpCode::OBJ_CREATE_LOCAL, {
.name = "CREATE LOCAL OBJ",
.desc = "creates object of given type and adds it to the locals",
.operands = {
{ "str", "types" },
{ "str", "name id" },
}
}
);
add(OpCode::OBJ_CREATE, {
.name = "CREATE OBJ",
.desc = "creates object of given type",
.operands = {
{ "str", "types" },
}
}
);
add(OpCode::OBJ_COPY, {
.name = "COPY",
.desc = "Copies objects",
.operands = {
{ "any", "self" },
{ "any", "target" },
}
}
);
add(OpCode::OBJ_SAVE, {
.name = "SAVE",
.desc = "Saves object to a file",
.operands = {
{ "str", "path" },
{ "any", "self" },
}
}
);
add(OpCode::OBJ_LOAD, {
.name = "LOAD",
.desc = "loads object from a file",
.operands = {
{ "str", "path" },
{ "any", "self" },
}
}
);
add(OpCode::OBJ_ADD, {
.name = "ADD",
.desc = "Adds objects of the same type that supports ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::OBJ_SUB, {
.name = "SUB",
.desc = "Subtruts objects of the same type that supports ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::OBJ_MUL, {
.name = "MUL",
.desc = "Multiplies objects of the same type that supports ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::OBJ_DIV, {
.name = "DIV",
.desc = "Divides objects of the same type that supports ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::AND, {
.name = "AND",
.desc = "Logical AND of objects of the same type that supports boolean ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::OR, {
.name = "OR",
.desc = "Logical OR of objects of the same type that supports boolean ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::EQUAL, {
.name = "EQUAL",
.desc = "Compares objects",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::NOT_EQUAL, {
.name = "NOT EQUAL",
.desc = "Compares objects and inverts the resault",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::MORE, {
.name = "MORE",
.desc = " > ",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::LESS, {
.name = "LESS",
.desc = " < ",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::EQUAL_OR_MORE, {
.name = "GRATER OR EQUAL",
.desc = " >= ",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::EQUAL_OR_LESS, {
.name = "LESS OR EQUAL",
.desc = " <= ",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::NOT, {
.name = "NOT",
.desc = "Inverts the object bolean representation",
.operands = {
{ "any", "self" },
}
}
);
add(OpCode::JUMP, {
.name = "JUMP",
.desc = "Offsets the instruction pointer",
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_R, {
.name = "JUMP R",
.desc = "Offsets the instruction pointer in reversed direction",
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_IF, {
.name = "JUMP IF",
.desc = "Offsets the instruction pointer if condition is met",
.operands = {
{ "any", "condition object" },
},
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_IF_R, {
.name = "JUMP IF R",
.desc = "Offsets the instruction pointer in reversed direction if condition is met",
.operands = {
{ "any", "condition object" },
},
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_IF_NOT, {
.name = "JUMP IF R",
.desc = "Offsets the instruction pointer if condition is NOT met",
.operands = {
{ "any", "condition object" },
},
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_IF_NOT_R, {
.name = "JUMP IF R",
.desc = "Offsets the instruction pointer in reversed direction if condition is NOT met",
.operands = {
{ "any", "condition object" },
},
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::PRINT, {
.name = "PRINT",
.desc = "Prints the object string representation",
.operands = {
{ "any", "self" },
}
}
);
add(OpCode::CLASS_CONSTRUCT, {
.name = "CLASS CONSTRUCT",
.desc = "Creates class from the function execution state",
}
);
add(OpCode::SELF, {
.name = "SELF",
.desc = "retrieves parent class of the current method",
}
);
}
OpcodeInfos::OpInfo OpcodeInfos::fetch(OpCode code) {
DEBUG_ASSERT((tp::alni)code >= 0 && (tp::alni)code < (tp::alni)OpCode::END_OPCODES);
return buff[(tp::alni)code];
}
void OpcodeInfos::add(OpCode code, const OpInfo& info) {
buff[(tp::alni)code] = info;
}
#include "Utils.hpp"
#include "interpreter/opcodes.h"
namespace obj {
OpcodeInfos gOpcodeInfos;
};
using namespace obj;
#define CONST_IDX_BYTES 2
#define OP(opcode, name, desc, ops, params) add(opcode, { #name, #desc, ops, params });
OpcodeInfos::OperandsInfo::OperandsInfo() {}
OpcodeInfos::OperandsInfo::OperandsInfo(tp::InitialierList<Operand> list) {
DEBUG_ASSERT(MAX_OPERANDS >= list.size());
for (auto item : list) {
buff[len] = item;
len++;
}
}
OpcodeInfos::ParamsInfo::ParamsInfo() {}
OpcodeInfos::ParamsInfo::ParamsInfo(tp::InitialierList<Param> list) {
DEBUG_ASSERT(MAX_PARAMS >= list.size());
for (auto item : list) {
buff[len] = item;
len++;
}
}
tp::uint1 OpcodeInfos::OpInfo::opsize() {
tp::uint1 out = 1;
for (auto i = 0; i < params.len; i++) {
out += params.buff[i].bytes;
}
return out;
}
OpcodeInfos::OpcodeInfos() {
add(OpCode::NONE, { "NONE", "Does Nothing" });
add(OpCode::HALT, { "HALT", "Halts for 3 sec" });
add(OpCode::TERMINATE, { "TERMINATE", "Terminates the process" });
add(OpCode::DEF_LOCAL, { .name = "DEF LOCAL", .desc = "Adds object to the locals", .operands = { { "str", "local id" }, { "any", "object to be local" } } });
add(OpCode::LOAD_CONST, {
.name = "LOAD CONST",
.desc = "Loads const object from the const pool",
.params = {
{ "const obj idx", CONST_IDX_BYTES },
}
}
);
add(OpCode::LOAD_LOCAL, {
.name = "LOAD LOCAL",
.desc = "Loads local object from the locals",
.params = {
{ "idx of const StringObject - represents name id", CONST_IDX_BYTES },
}
}
);
add(
OpCode::IGNORE,
{
.name = "IGNORE",
.desc = "Ignores returned object by destroying it",
}
);
add(
OpCode::SCOPE_IN,
{
.name = "SCOPE IN",
.desc = "Enters new scope",
}
);
add(
OpCode::SCOPE_OUT,
{
.name = "SCOPE OUT",
.desc = "Leaves current scope",
}
);
add(OpCode::CALL, {
.name = "CALL",
.desc = "Leaves current scope",
.operands = {
{ "method", "method object" },
}
}
);
add(OpCode::RETURN_OBJ, {
.name = "RETURN OBJ",
.desc = "Returns Operand",
.operands = {
{ "any", "object to be returned" },
}
}
);
add(
OpCode::RETURN,
{
.name = "RETURN",
.desc = "Returns Null Object",
}
);
add(OpCode::CHILD, {
.name = "CHILD",
.desc = "Retrieves child from class",
.operands = {
{ "str", "child id" },
{ "class", "parent class" },
},
.params = {
{ "is method ?", 1 }
}
}
);
add(OpCode::PUSH_ARGS, { .name = "PUSH ARGS", .desc = "Pushes Separator on the OperandsStack", .params = { { "length to chech number of args", 1 } } });
add(OpCode::SAVE_ARGS, { .name = "SAVE ARGS", .desc = "Pushes operands to locals", .params = { { "number of arguments in function defenition", 1 } } });
add(OpCode::OBJ_CREATE_LOCAL, {
.name = "CREATE LOCAL OBJ",
.desc = "creates object of given type and adds it to the locals",
.operands = {
{ "str", "types" },
{ "str", "name id" },
}
}
);
add(OpCode::OBJ_CREATE, {
.name = "CREATE OBJ",
.desc = "creates object of given type",
.operands = {
{ "str", "types" },
}
}
);
add(OpCode::OBJ_COPY, {
.name = "COPY",
.desc = "Copies objects",
.operands = {
{ "any", "self" },
{ "any", "target" },
}
}
);
add(OpCode::OBJ_SAVE, {
.name = "SAVE",
.desc = "Saves object to a file",
.operands = {
{ "str", "path" },
{ "any", "self" },
}
}
);
add(OpCode::OBJ_LOAD, {
.name = "LOAD",
.desc = "loads object from a file",
.operands = {
{ "str", "path" },
{ "any", "self" },
}
}
);
add(OpCode::OBJ_ADD, {
.name = "ADD",
.desc = "Adds objects of the same type that supports ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::OBJ_SUB, {
.name = "SUB",
.desc = "Subtruts objects of the same type that supports ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::OBJ_MUL, {
.name = "MUL",
.desc = "Multiplies objects of the same type that supports ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::OBJ_DIV, {
.name = "DIV",
.desc = "Divides objects of the same type that supports ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::AND, {
.name = "AND",
.desc = "Logical AND of objects of the same type that supports boolean ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::OR, {
.name = "OR",
.desc = "Logical OR of objects of the same type that supports boolean ariphmetics",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::EQUAL, {
.name = "EQUAL",
.desc = "Compares objects",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::NOT_EQUAL, {
.name = "NOT EQUAL",
.desc = "Compares objects and inverts the resault",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::MORE, {
.name = "MORE",
.desc = " > ",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::LESS, {
.name = "LESS",
.desc = " < ",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::EQUAL_OR_MORE, {
.name = "GRATER OR EQUAL",
.desc = " >= ",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::EQUAL_OR_LESS, {
.name = "LESS OR EQUAL",
.desc = " <= ",
.operands = {
{ "any", "left" },
{ "any", "right" },
}
}
);
add(OpCode::NOT, {
.name = "NOT",
.desc = "Inverts the object bolean representation",
.operands = {
{ "any", "self" },
}
}
);
add(OpCode::JUMP, {
.name = "JUMP",
.desc = "Offsets the instruction pointer",
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_R, {
.name = "JUMP R",
.desc = "Offsets the instruction pointer in reversed direction",
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_IF, {
.name = "JUMP IF",
.desc = "Offsets the instruction pointer if condition is met",
.operands = {
{ "any", "condition object" },
},
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_IF_R, {
.name = "JUMP IF R",
.desc = "Offsets the instruction pointer in reversed direction if condition is met",
.operands = {
{ "any", "condition object" },
},
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_IF_NOT, {
.name = "JUMP IF R",
.desc = "Offsets the instruction pointer if condition is NOT met",
.operands = {
{ "any", "condition object" },
},
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::JUMP_IF_NOT_R, {
.name = "JUMP IF R",
.desc = "Offsets the instruction pointer in reversed direction if condition is NOT met",
.operands = {
{ "any", "condition object" },
},
.params = {
{ "ip offset unsigned", 2 },
}
}
);
add(OpCode::PRINT, {
.name = "PRINT",
.desc = "Prints the object string representation",
.operands = {
{ "any", "self" },
}
}
);
add(
OpCode::CLASS_CONSTRUCT,
{
.name = "CLASS CONSTRUCT",
.desc = "Creates class from the function execution state",
}
);
add(
OpCode::SELF,
{
.name = "SELF",
.desc = "retrieves parent class of the current method",
}
);
}
OpcodeInfos::OpInfo OpcodeInfos::fetch(OpCode code) {
DEBUG_ASSERT((tp::alni) code >= 0 && (tp::alni) code < (tp::alni) OpCode::END_OPCODES);
return buff[(tp::alni) code];
}
void OpcodeInfos::add(OpCode code, const OpInfo& info) { buff[(tp::alni) code] = info; }

62
Objects/private/interpreter/operandsstack.cpp
View file

@ -1,32 +1,30 @@
#include "NewPlacement.hpp"
#include "interpreter/operandsstack.h"
using namespace obj;
OperandStack::OperandStack() {
mBuff = new Operand[MAX_STACK_SIZE];
mIdx = 0;
}
void OperandStack::push(Operand operand) {
ASSERT(MAX_STACK_SIZE - 1 > mIdx && "stack overflow");
mBuff[mIdx] = operand;
mIdx++;
}
void OperandStack::pop() {
ASSERT(mIdx != NULL && "stack overflow");
mIdx--;
}
Operand OperandStack::getOperand() {
auto ret = mBuff[mIdx - 1];
mIdx--;
return ret;
}
OperandStack::~OperandStack() {
delete[] mBuff;
}
#include "NewPlacement.hpp"
#include "interpreter/operandsstack.h"
using namespace obj;
OperandStack::OperandStack() {
mBuff = new Operand[MAX_STACK_SIZE];
mIdx = 0;
}
void OperandStack::push(Operand operand) {
ASSERT(MAX_STACK_SIZE - 1 > mIdx && "stack overflow");
mBuff[mIdx] = operand;
mIdx++;
}
void OperandStack::pop() {
ASSERT(mIdx != NULL && "stack overflow");
mIdx--;
}
Operand OperandStack::getOperand() {
auto ret = mBuff[mIdx - 1];
mIdx--;
return ret;
}
OperandStack::~OperandStack() { delete[] mBuff; }

175
Objects/private/interpreter/scopestack.cpp
View file

@ -1,90 +1,85 @@
#include "NewPlacement.hpp"
#include "interpreter/scopestack.h"
using namespace obj;
Scope::~Scope() {
for (auto local : mLocals) {
obj::NDO->destroy(local->val);
}
for (auto tmp : mTemps) {
obj::NDO->destroy(tmp.data());
}
}
obj::Object* ScopeStack::getLocalUtil(Scope& scope, tp::String* id) {
auto idx = scope.mLocals.presents(*id);
if (idx) {
return scope.mLocals.getSlotVal(idx);
}
else {
mIterIdx--;
Scope& parent_scope = mBuff[mIterIdx];
ASSERT(parent_scope.mChildReachable && "Undefined Local Reference");
return getLocalUtil(parent_scope, id);
}
}
ScopeStack::ScopeStack() {
mBuff = (Scope*) tp::HeapAllocGlobal::allocate(sizeof(Scope) * MAX_STACK_SIZE);
mIdx = 0;
mIterIdx = 0;
}
void ScopeStack::enterScope(bool aChildReachable) {
ASSERT(MAX_STACK_SIZE - 1 > mIdx && "stack overflow");
new (&mBuff[mIdx]) Scope();
mBuff[mIdx].mChildReachable = aChildReachable;
mIdx++;
}
void ScopeStack::leaveScope() {
ASSERT(mIdx != NULL && "stack overflow");
mBuff[mIdx - 1].~Scope();
mIdx--;
}
void ScopeStack::addTemp(obj::Object* tmp) {
obj::NDO->refinc(tmp);
mBuff[mIdx - 1].mTemps.pushBack(tmp);
}
void ScopeStack::popTemp() {
obj::NDO->destroy(mBuff[mIdx - 1].mTemps.last()->data);
mBuff[mIdx - 1].mTemps.popBack();
}
void ScopeStack::addTempReturn(obj::Object* ret) {
if (mIdx >= 2) {
obj::NDO->refinc(ret);
mBuff[mIdx - 2].mTemps.pushBack(ret);
}
}
void ScopeStack::addLocal(obj::Object* local, tp::String id) {
DEBUG_ASSERT(mIdx != 0 && "No scope given");
Scope::ObjDict& locals = mBuff[mIdx - 1].mLocals;
auto idx = locals.presents(id);
if (idx) {
obj::NDO->destroy(locals.getSlotVal(idx));
}
obj::NDO->refinc(local);
locals.put(id, local);
}
obj::Object* ScopeStack::getLocal(tp::String& str) {
mIterIdx = mIdx - 1;
return getLocalUtil(mBuff[mIdx - 1], &str);
}
Scope* ScopeStack::getCurrentScope() {
return &mBuff[mIdx - 1];
}
ScopeStack::~ScopeStack() {
tp::HeapAllocGlobal::deallocate(mBuff);
}
#include "NewPlacement.hpp"
#include "interpreter/scopestack.h"
using namespace obj;
Scope::~Scope() {
for (auto local : mLocals) {
obj::NDO->destroy(local->val);
}
for (auto tmp : mTemps) {
obj::NDO->destroy(tmp.data());
}
}
obj::Object* ScopeStack::getLocalUtil(Scope& scope, tp::String* id) {
auto idx = scope.mLocals.presents(*id);
if (idx) {
return scope.mLocals.getSlotVal(idx);
} else {
mIterIdx--;
Scope& parent_scope = mBuff[mIterIdx];
ASSERT(parent_scope.mChildReachable && "Undefined Local Reference");
return getLocalUtil(parent_scope, id);
}
}
ScopeStack::ScopeStack() {
mBuff = (Scope*) tp::HeapAllocGlobal::allocate(sizeof(Scope) * MAX_STACK_SIZE);
mIdx = 0;
mIterIdx = 0;
}
void ScopeStack::enterScope(bool aChildReachable) {
ASSERT(MAX_STACK_SIZE - 1 > mIdx && "stack overflow");
new (&mBuff[mIdx]) Scope();
mBuff[mIdx].mChildReachable = aChildReachable;
mIdx++;
}
void ScopeStack::leaveScope() {
ASSERT(mIdx != NULL && "stack overflow");
mBuff[mIdx - 1].~Scope();
mIdx--;
}
void ScopeStack::addTemp(obj::Object* tmp) {
obj::NDO->refinc(tmp);
mBuff[mIdx - 1].mTemps.pushBack(tmp);
}
void ScopeStack::popTemp() {
obj::NDO->destroy(mBuff[mIdx - 1].mTemps.last()->data);
mBuff[mIdx - 1].mTemps.popBack();
}
void ScopeStack::addTempReturn(obj::Object* ret) {
if (mIdx >= 2) {
obj::NDO->refinc(ret);
mBuff[mIdx - 2].mTemps.pushBack(ret);
}
}
void ScopeStack::addLocal(obj::Object* local, tp::String id) {
DEBUG_ASSERT(mIdx != 0 && "No scope given");
Scope::ObjDict& locals = mBuff[mIdx - 1].mLocals;
auto idx = locals.presents(id);
if (idx) {
obj::NDO->destroy(locals.getSlotVal(idx));
}
obj::NDO->refinc(local);
locals.put(id, local);
}
obj::Object* ScopeStack::getLocal(tp::String& str) {
mIterIdx = mIdx - 1;
return getLocalUtil(mBuff[mIdx - 1], &str);
}
Scope* ScopeStack::getCurrentScope() { return &mBuff[mIdx - 1]; }
ScopeStack::~ScopeStack() { tp::HeapAllocGlobal::deallocate(mBuff); }

1759
Objects/private/parser/parser.cpp
View file

File diff suppressed because it is too large Load diff

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

1
Objects/tests/Tests.cpp
View file

@ -7,7 +7,6 @@
using namespace tp;
using namespace obj;
void testCore();
void testPrimitives();
void testInterpreter();

5
Objects/tests/core/TestCore.cpp
View file

@ -26,11 +26,8 @@ TEST_DEF_STATIC(BasicAPI) {
TEST(NDO_CAST(IntObject, savedInt));
TEST(integer->val == NDO_CAST(IntObject, savedInt)->val);
NDO->destroy(integer);
NDO->destroy(savedInt);
}
TEST_DEF(Core) {
testBasicAPI();
}
TEST_DEF(Core) { testBasicAPI(); }

9
Objects/tests/interpreter/TestInterpreter.cpp
View file

@ -3,12 +3,12 @@
#include "Testing.hpp"
#include "compiler/function.h"
#include "core/object.h"
#include "primitives/methodobject.h"
#include "interpreter/interpreter.h"
#include "primitives/interpreterobject.h"
#include "primitives/linkobject.h"
#include "compiler/function.h"
#include "interpreter/interpreter.h"
#include "primitives/methodobject.h"
using namespace tp;
using namespace obj;
@ -57,7 +57,6 @@ TEST_DEF_STATIC(Complex) {
interpreter->exec();
NDO->destroy(interpreter);
}
@ -84,5 +83,5 @@ TEST_DEF_STATIC(Simple) {
TEST_DEF(Interpreter) {
testSimple();
//testComplex();
// testComplex();
}

4
Objects/tests/primitives/TestPrimitives.cpp
View file

@ -30,6 +30,4 @@ TEST_DEF_STATIC(Dict) {
NDO->destroy(dictLoaded);
}
TEST_DEF(Primitives) {
testDict();
}
TEST_DEF(Primitives) { testDict(); }