From f8c82b7e29a59c0b5220636342482fe20aba4a56 Mon Sep 17 00:00:00 2001 From: IlyaShurupov Date: Sat, 23 Mar 2024 12:32:57 +0300 Subject: [PATCH] clean up object module --- Objects/applications/GUI.cpp | 13 +- Objects/applications/GUI.h | 4 +- Objects/private/compiler/Constants.cpp | 31 +- Objects/private/compiler/Expressions.cpp | 32 +- Objects/private/compiler/Functions.cpp | 104 ++- Objects/private/compiler/Instructions.cpp | 3 +- Objects/private/compiler/Statements.cpp | 9 +- Objects/private/core/Object.cpp | 430 +++++----- Objects/private/core/ObjectSave.cpp | 740 +++++++++--------- Objects/private/core/ObjectsModule.cpp | 14 +- Objects/private/core/ScriptSection.cpp | 65 +- Objects/private/core/TypeGroups.cpp | 7 +- Objects/private/core/TypeMethods.cpp | 19 +- Objects/private/interpreter/CallStack.cpp | 5 +- Objects/private/interpreter/Interpreter.cpp | 49 +- Objects/private/interpreter/OperandsStack.cpp | 1 + .../private/interpreter/OperationCodes.cpp | 21 +- Objects/private/interpreter/ScopeStack.cpp | 7 +- Objects/private/parser/Bindings.cpp | 5 +- Objects/private/parser/Parser.cpp | 5 +- Objects/private/parser/Private.hpp | 74 +- Objects/private/primitives/BoolObject.cpp | 2 +- Objects/private/primitives/ClassObject.cpp | 4 +- Objects/private/primitives/ColorObject.cpp | 2 +- Objects/private/primitives/DictObject.cpp | 6 +- Objects/private/primitives/EnumObject.cpp | 2 +- Objects/private/primitives/FloatObject.cpp | 2 +- Objects/private/primitives/IntObject.cpp | 2 +- .../private/primitives/InterpreterObject.cpp | 2 +- Objects/private/primitives/LinkObject.cpp | 6 +- Objects/private/primitives/ListObject.cpp | 8 +- Objects/private/primitives/MethodObject.cpp | 3 +- Objects/private/primitives/NullObject.cpp | 2 +- Objects/private/primitives/Stringobject.cpp | 2 +- Objects/private/primitives/TypeObject.cpp | 2 +- Objects/public/compiler/Constants.hpp | 73 +- Objects/public/compiler/Expressions.hpp | 32 +- Objects/public/compiler/Functions.hpp | 51 +- Objects/public/compiler/Instructions.hpp | 69 +- Objects/public/compiler/Statements.hpp | 10 +- Objects/public/core/Object.hpp | 139 ++-- Objects/public/core/ObjectArchiver.hpp | 56 ++ Objects/public/core/ScriptSection.hpp | 12 +- Objects/public/core/TypeGroups.hpp | 11 +- Objects/public/core/TypeMethods.hpp | 21 +- Objects/public/interpreter/ByteCode.hpp | 12 +- Objects/public/interpreter/CallStack.hpp | 17 +- Objects/public/interpreter/Interpreter.hpp | 12 +- Objects/public/interpreter/OperandsStack.hpp | 11 +- Objects/public/interpreter/OperatoinCodes.hpp | 18 +- Objects/public/interpreter/ScopeStack.hpp | 25 +- Objects/public/interpreter/Script.hpp | 6 +- Objects/public/parser/Parser.hpp | 10 +- Objects/public/primitives/BoolObject.hpp | 14 +- Objects/public/primitives/ClassObject.hpp | 8 +- Objects/public/primitives/ColorObject.hpp | 12 +- Objects/public/primitives/DictObject.hpp | 20 +- Objects/public/primitives/EnumObject.hpp | 24 +- Objects/public/primitives/FloatObject.hpp | 16 +- Objects/public/primitives/IntObject.hpp | 16 +- .../public/primitives/InterpreterObject.hpp | 6 +- Objects/public/primitives/LinkObject.hpp | 13 +- Objects/public/primitives/ListObject.hpp | 18 +- Objects/public/primitives/MethodObject.hpp | 6 +- Objects/public/primitives/NullObject.hpp | 12 +- Objects/public/primitives/StringObject.hpp | 12 +- Objects/public/primitives/TypeObject.hpp | 5 +- Objects/tests/main.cpp | 2 +- 68 files changed, 1223 insertions(+), 1229 deletions(-) create mode 100644 Objects/public/core/ObjectArchiver.hpp diff --git a/Objects/applications/GUI.cpp b/Objects/applications/GUI.cpp index 2909a46..674175e 100644 --- a/Objects/applications/GUI.cpp +++ b/Objects/applications/GUI.cpp @@ -8,6 +8,9 @@ #include "imgui.h" #include "imgui_internal.h" +using namespace tp; +using namespace obj; + namespace ImGui { bool SubMenuBegin(const char* desc, int level); @@ -104,7 +107,7 @@ void obj::ObjectsGUI::setClipboard(obj::Object* obj) { mClipboard = obj; if (mClipboard) { - obj::NDO->refinc(obj); + obj::NDO->increaseReferenceCount(obj); } } @@ -145,7 +148,7 @@ obj::ObjectsGUI::ObjectsGUI() { assert(obj::NDO && "Objects library is not initi void obj::ObjectsGUI::cd(obj::Object* child, const std::string& name) { mActive = child; mViewStack.pushBack({ mActive, name }); - obj::NDO->refinc(child); + obj::NDO->increaseReferenceCount(child); } void obj::ObjectsGUI::cdup() { @@ -587,7 +590,7 @@ void obj::ObjectsGUI::dictViewEdit(obj::DictObject* dict, const std::string& key if (bool(idx)) { // Notify("Object with such name Already Exists"); } else { - obj::NDO->refinc(obj); + obj::NDO->increaseReferenceCount(obj); dict->remove(key); auto id = std::string(mNameEdit); dict->put(id, obj); @@ -915,7 +918,7 @@ void obj::ObjectsGUI::explorer() { } if (ImGui::Selectable("Instantiate ")) { - setClipboard(obj::NDO->instatiate(curretn_object)); + setClipboard(obj::NDO->instantiate(curretn_object)); // Notify("Object copied to clipboard"); } @@ -1005,7 +1008,7 @@ void obj::ObjectsGUI::properties(const obj::ObjectType* type, bool top_of_tree_v assert(mActive); if (mActive->type != type) return; - ImGui::Text(" RefCount : %i", obj::NDO->getrefc(mActive)); + ImGui::Text(" RefCount : %i", obj::NDO->getReferenceCount(mActive)); ImGui::Text(" Type : %s", type->name); diff --git a/Objects/applications/GUI.h b/Objects/applications/GUI.h index 1e64f55..13f1602 100644 --- a/Objects/applications/GUI.h +++ b/Objects/applications/GUI.h @@ -8,7 +8,7 @@ #include -namespace obj { +namespace tp::obj { class ObjectsGUI { @@ -24,7 +24,7 @@ namespace obj { operator bool() { return obj; } }; - tp::List mViewStack; + List mViewStack; obj::Object* mRoot = NULL; obj::Object* mActive = NULL; obj::Object* mClipboard = NULL; diff --git a/Objects/private/compiler/Constants.cpp b/Objects/private/compiler/Constants.cpp index 0569902..acff574 100644 --- a/Objects/private/compiler/Constants.cpp +++ b/Objects/private/compiler/Constants.cpp @@ -2,12 +2,11 @@ #include "primitives/MethodObject.hpp" #include "primitives/PrimitiveObjects.hpp" -using namespace obj; using namespace tp; -using namespace BCgen; +using namespace obj; -ConstObject::ConstObject() {} -ConstObject::ConstObject(obj::Object* mObj) : +ConstObject::ConstObject() = default; +ConstObject::ConstObject(Object* mObj) : mObj(mObj) {} ConstObjectsPool::~ConstObjectsPool() { @@ -42,15 +41,15 @@ ConstObjectsPool::~ConstObjectsPool() { } } -ConstObject* ConstObjectsPool::registerObject(obj::Object* obj) { - ConstObject* out = new ConstObject(obj); +ConstObject* ConstObjectsPool::registerObject(Object* obj) { + auto out = new ConstObject(obj); mTotalObjects++; return out; } -ConstObject* ConstObjectsPool::get(tp::alni val) { +ConstObject* ConstObjectsPool::get(alni val) { auto idx = mIntegers.presents(val); - ConstObject* const_obj = nullptr; + ConstObject* const_obj; if (idx) { const_obj = mIntegers.getSlotVal(idx); } else { @@ -62,7 +61,7 @@ ConstObject* ConstObjectsPool::get(tp::alni val) { ConstObject* ConstObjectsPool::get(const std::string& val) { auto idx = mStrings.presents(val); - ConstObject* const_obj = nullptr; + ConstObject* const_obj; if (idx) { const_obj = mStrings.getSlotVal(idx); } else { @@ -72,9 +71,9 @@ ConstObject* ConstObjectsPool::get(const std::string& val) { return const_obj; } -ConstObject* ConstObjectsPool::get(tp::alnf val) { +ConstObject* ConstObjectsPool::get(alnf val) { auto idx = mFloats.presents(val); - ConstObject* const_obj = nullptr; + ConstObject* const_obj; if (idx) { const_obj = mFloats.getSlotVal(idx); } else { @@ -100,17 +99,17 @@ ConstObject* ConstObjectsPool::get(bool val) { } } -ConstObject* ConstObjectsPool::addMethod(const std::string& method_id, obj::Object* method) { - ASSERT(NDO_CAST(MethodObject, method) && "Object is not a method object"); - ASSERT(!mMethods.presents(method_id) && "Method Redefinition"); +ConstObject* ConstObjectsPool::addMethod(const std::string& method_id, 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& out) { +void ConstObjectsPool::save(Buffer& out) { out.reserve(mTotalObjects); - tp::alni data_idx = 0; + alni data_idx = 0; for (auto obj : mMethods) { out[data_idx] = obj->val->mObj; obj->val->mConstIdx = data_idx; diff --git a/Objects/private/compiler/Expressions.cpp b/Objects/private/compiler/Expressions.cpp index 9beacf2..3a5c5ee 100644 --- a/Objects/private/compiler/Expressions.cpp +++ b/Objects/private/compiler/Expressions.cpp @@ -1,7 +1,9 @@ #include "compiler/Expressions.hpp" +#include + +using namespace tp; using namespace obj; -using namespace BCgen; Expression::Expression(Type type) : mType(type) {} @@ -46,25 +48,25 @@ ExpressionList::~ExpressionList() { } } -ExpressionNew::ExpressionNew(const std::string& type) : +ExpressionNew::ExpressionNew(std::string type) : Expression(Type::NEW), - mNewType(type) {} + mNewType(std::move(type)) {} ExpressionNew::~ExpressionNew() = default; -ExpressionLocal::ExpressionLocal(const std::string& id) : +ExpressionLocal::ExpressionLocal(std::string id) : Expression(Type::LOCAL), - mLocalId(id) {} + mLocalId(std::move(id)) {} ExpressionLocal::~ExpressionLocal() = default; ExpressionSelf::ExpressionSelf() : Expression(Type::SELF) {} -ExpressionChild::ExpressionChild(Expression* mParent, const std::string& id) : +ExpressionChild::ExpressionChild(Expression* mParent, std::string id) : Expression(Type::CHILD), mParent(mParent), - mLocalId(id) {} + mLocalId(std::move(id)) {} ExpressionChild::~ExpressionChild() { delete mParent; } @@ -79,38 +81,38 @@ ExpressionArithmetics::~ExpressionArithmetics() { delete mRight; } -ExpressionFunc::ExpressionFunc(const std::string& id) : +ExpressionFunc::ExpressionFunc(std::string id) : Expression(Type::FUNC), - mFuncId(id) {} + mFuncId(std::move(id)) {} ExpressionFunc::~ExpressionFunc() = default; -ExpressionConst::ExpressionConst(const std::string& val) : +ExpressionConst::ExpressionConst(std::string val) : Expression(Type::CONST_EXPR), mConstType(STR), - str(val) {} + str(std::move(val)) {} ExpressionConst::ExpressionConst(const char* val) : Expression(Type::CONST_EXPR), mConstType(STR), str(val) {} -ExpressionConst::ExpressionConst(tp::int4 val) : +ExpressionConst::ExpressionConst(int4 val) : Expression(Type::CONST_EXPR), mConstType(INT), integer(val) {} -ExpressionConst::ExpressionConst(tp::flt4 val) : +ExpressionConst::ExpressionConst(flt4 val) : Expression(Type::CONST_EXPR), mConstType(FLT), floating(val) {} -ExpressionConst::ExpressionConst(tp::alni val) : +ExpressionConst::ExpressionConst(alni val) : Expression(Type::CONST_EXPR), mConstType(INT), integer(val) {} -ExpressionConst::ExpressionConst(tp::alnf val) : +ExpressionConst::ExpressionConst(alnf val) : Expression(Type::CONST_EXPR), mConstType(FLT), floating(val) {} diff --git a/Objects/private/compiler/Functions.cpp b/Objects/private/compiler/Functions.cpp index 9ceb42a..8d699de 100644 --- a/Objects/private/compiler/Functions.cpp +++ b/Objects/private/compiler/Functions.cpp @@ -6,12 +6,10 @@ #include "parser/Parser.hpp" -using namespace obj; using namespace tp; using namespace obj; -using namespace BCgen; -void obj::BCgen::Genereate(ByteCode& out, StatementScope* body) { +void obj::Generate(ByteCode& out, StatementScope* body) { auto root = FunctionDefinition(); root.inst(Instruction(OpCode::SCOPE_IN)); @@ -26,18 +24,18 @@ void obj::BCgen::Genereate(ByteCode& out, StatementScope* body) { } ConstObject* FunctionDefinition::defineLocal(const std::string& id) { - auto idx = mLocals.presents(id); + // auto idx = mLocals.presents(id); // RelAssert(!idx && "Local Redefinition"); auto const_str_id = mConstants.get(id); mLocals.put(id, const_str_id); return const_str_id; } -FunctionDefinition::FunctionDefinition(const std::string& function_id, tp::Buffer args, FunctionDefinition* prnt) { +FunctionDefinition::FunctionDefinition(const std::string& function_id, const Buffer& args, FunctionDefinition*) { mFunctionId = function_id; - inst(Instruction(OpCode::SAVE_ARGS, args.size(), 1)); + inst(Instruction(OpCode::SAVE_ARGS, (alni) args.size(), 1)); for (auto id : args) { - ASSERT(!mLocals.presents(id.data()) && "Argument Redefinition"); + ASSERT(!mLocals.presents(id.data()) && "Argument Redefinition") auto const_data = mConstants.get(id.data()); mArgsOrder.pushBack(const_data); mLocals.put(id.data(), const_data); @@ -124,7 +122,7 @@ void FunctionDefinition::EvalStatement(Statement* stm) { // define method as local auto idx = mLocals.presents(func.mFunctionId); - ASSERT(!idx && "Local Redefinition with function name"); + ASSERT(!idx && "Local Redefinition with function name") mLocals.put(func.mFunctionId, mConstants.get(func.mFunctionId)); // create and register const func object @@ -152,7 +150,7 @@ void FunctionDefinition::EvalStatement(Statement* stm) { // define method as local auto idx = mLocals.presents(func.mFunctionId); - ASSERT(!idx && "Local Redefinition with function name"); + ASSERT(!idx && "Local Redefinition with function name") mLocals.put(func.mFunctionId, mConstants.get(func.mFunctionId)); // create and register const func object @@ -164,7 +162,7 @@ void FunctionDefinition::EvalStatement(Statement* stm) { // check for return statements ASSERT( child_stm.data()->mType != Statement::Type::RET && "return statements are not allowed in class definition" - ); + ) func.EvalStatement(child_stm.data()); } // create one last instruction - constructing class from function execution state @@ -280,10 +278,10 @@ void FunctionDefinition::EvalExpr(Expression* expr) { } case Expression::Type::ARITHMETICS: { - auto ariphm = (ExpressionArithmetics*) expr; - EvalExpr(ariphm->mRight); - EvalExpr(ariphm->mLeft); - inst(Instruction(ariphm->mOpType)); + auto arithmeticExpression = (ExpressionArithmetics*) expr; + EvalExpr(arithmeticExpression->mRight); + EvalExpr(arithmeticExpression->mLeft); + inst(Instruction(arithmeticExpression->mOpType)); break; } case Expression::Type::NEW: @@ -302,29 +300,29 @@ void FunctionDefinition::EvalExpr(Expression* expr) { } case Expression::Type::CONST_EXPR: { - auto constobj = (ExpressionConst*) expr; - switch (constobj->mConstType) { + auto constObject = (ExpressionConst*) expr; + switch (constObject->mConstType) { case ExpressionConst::STR: { - inst(Instruction(OpCode::LOAD_CONST, mConstants.get(constobj->str))); + inst(Instruction(OpCode::LOAD_CONST, mConstants.get(constObject->str))); break; } case ExpressionConst::INT: { - inst(Instruction(OpCode::LOAD_CONST, mConstants.get(constobj->integer))); + inst(Instruction(OpCode::LOAD_CONST, mConstants.get(constObject->integer))); break; } case ExpressionConst::FLT: { - inst(Instruction(OpCode::LOAD_CONST, mConstants.get(constobj->floating))); + inst(Instruction(OpCode::LOAD_CONST, mConstants.get(constObject->floating))); break; } case ExpressionConst::BOOL: { - inst(Instruction(OpCode::LOAD_CONST, mConstants.get(constobj->boolean))); + inst(Instruction(OpCode::LOAD_CONST, mConstants.get(constObject->boolean))); break; } - }; + } break; } case Expression::Type::CHILD: @@ -343,7 +341,7 @@ void FunctionDefinition::EvalExpr(Expression* expr) { case Expression::Type::CALL: { auto call = (ExpressionCall*) expr; - inst(Instruction(OpCode::PUSH_ARGS, call->mArgs->mItems.size(), 1)); + inst(Instruction(OpCode::PUSH_ARGS, (alni) call->mArgs->mItems.size(), 1)); for (auto arg : call->mArgs->mItems) { EvalExpr(arg.data()); } @@ -356,13 +354,13 @@ void FunctionDefinition::EvalExpr(Expression* expr) { } } -tp::alni instSize(const Instruction& inst) { +alni instSize(const Instruction& inst) { switch (inst.mInstType) { case Instruction::InstType::JUMP: case Instruction::InstType::JUMP_IF_NOT: case Instruction::InstType::JUMP_IF: { - // 2 bytes for offset 1 byte for instrtuction + // 2 bytes for offset 1 byte for instruction return 3; } case Instruction::InstType::PURE_CONST: @@ -371,7 +369,7 @@ tp::alni instSize(const Instruction& inst) { } case Instruction::InstType::EXEC: { - tp::alni out = 1; + alni out = 1; switch (inst.mArgType) { case Instruction::ArgType::PARAM: { @@ -392,7 +390,7 @@ tp::alni instSize(const Instruction& inst) { } default: { - ASSERT(0); + ASSERT(0) } } } @@ -402,30 +400,30 @@ tp::alni instSize(const Instruction& inst) { } default: { - ASSERT(0); + ASSERT(0) } } - ASSERT(0); + ASSERT(0) return 0; } -void writeConst(ByteCode& out, tp::alni& idx, tp::uint2 data) { - for (auto byte : tp::Range(sizeof(tp::uint2))) { - out.mInstructions[idx] = OpCode((tp::int1)(data >> byte * 8)); +void writeConst(ByteCode& out, alni& idx, uint2 data) { + for (auto byte : Range(sizeof(uint2))) { + out.mInstructions[idx] = OpCode((int1)(data >> byte * 8)); idx++; } } -void writeParam(ByteCode& out, tp::alni& idx, tp::int1* data, tp::alni size) { - for (auto byte : tp::Range(size)) { +void writeParam(ByteCode& out, alni& idx, const int1* data, alni size) { + for (auto byte : Range(size)) { out.mInstructions[idx] = OpCode(data[byte]); idx++; } } -tp::alni calcOffset(tp::List::Node* jump_inst, Instruction* to) { - tp::alni offset = 0; +alni calcOffset(List::Node* jump_inst, Instruction* to) { + alni offset = 0; bool reversed = jump_inst->data.mInstIdx > to->mInstIdx; auto iter_node = reversed ? jump_inst : jump_inst->next; while (&iter_node->data != to) { @@ -445,13 +443,13 @@ void FunctionDefinition::generateByteCode(ByteCode& out) { mConstants.save(out.mConstants); - tp::alni inst_len = 0; + alni inst_len = 0; for (auto inst_iter : mInstructions) { inst_len += instSize(inst_iter.data()); } out.mInstructions.reserve(inst_len); - tp::alni idx = 0; + alni idx = 0; for (auto inst_iter : mInstructions) { auto inst = inst_iter.data(); @@ -460,7 +458,7 @@ void FunctionDefinition::generateByteCode(ByteCode& out) { case Instruction::InstType::JUMP_IF_NOT: case Instruction::InstType::JUMP: { - tp::alni offset = calcOffset(inst_iter.node(), inst.mInstTarget); + alni offset = calcOffset(inst_iter.node(), inst.mInstTarget); if (offset == 0) { out.mInstructions[idx] = OpCode::NONE; @@ -490,14 +488,14 @@ void FunctionDefinition::generateByteCode(ByteCode& out) { idx++; - tp::alni offset_mod = abs(offset); - tp::uint2 offset_param = (tp::uint2) offset_mod; - writeParam(out, idx, (tp::int1*) &offset_param, 2); + alni offset_mod = abs(offset); + auto offset_param = (uint2) offset_mod; + writeParam(out, idx, (int1*) &offset_param, 2); break; } case Instruction::InstType::PURE_CONST: { - writeConst(out, idx, (tp::uint2) inst.mConstData->mConstIdx); + writeConst(out, idx, (uint2) inst.mConstData->mConstIdx); break; } case Instruction::InstType::EXEC: @@ -507,14 +505,14 @@ void FunctionDefinition::generateByteCode(ByteCode& out) { switch (inst.mArgType) { case Instruction::ArgType::PARAM: { - writeParam(out, idx, (tp::int1*) &inst.mParam, inst.mParamBytes); + writeParam(out, idx, (int1*) &inst.mParam, inst.mParamBytes); break; } case Instruction::ArgType::CONST_ARG: { - writeConst(out, idx, (tp::uint2) inst.mConstData->mConstIdx); + writeConst(out, idx, (uint2) inst.mConstData->mConstIdx); if (inst.mConstData2) { - writeConst(out, idx, (tp::uint2) inst.mConstData2->mConstIdx); + writeConst(out, idx, (uint2) inst.mConstData2->mConstIdx); } break; } @@ -524,14 +522,14 @@ void FunctionDefinition::generateByteCode(ByteCode& out) { } default: { - ASSERT(0); + ASSERT(0) } } break; } default: { - ASSERT(0); + ASSERT(0) } case Instruction::InstType::NONE: { @@ -540,18 +538,18 @@ void FunctionDefinition::generateByteCode(ByteCode& out) { } } -tp::List::Node* FunctionDefinition::inst(Instruction inst) { +List::Node* FunctionDefinition::inst(Instruction inst) { mInstructions.pushBack(inst); auto out = &mInstructions.last()->data; - out->mInstIdx = mInstructions.length() - 1; + out->mInstIdx = (alni) mInstructions.length() - 1; return mInstructions.last(); } -void obj::BCgen::init() {} +void obj::initialize() {} -void obj::BCgen::deinit() {} +void obj::finalize() {} -bool obj::BCgen::Compile(obj::MethodObject* method) { +bool obj::Compile(obj::MethodObject* method) { Parser parser; @@ -563,7 +561,7 @@ bool obj::BCgen::Compile(obj::MethodObject* method) { return false; } - BCgen::Genereate(method->mScript->mBytecode, res.scope); + Generate(method->mScript->mBytecode, res.scope); delete res.scope; diff --git a/Objects/private/compiler/Instructions.cpp b/Objects/private/compiler/Instructions.cpp index a055683..63f0355 100644 --- a/Objects/private/compiler/Instructions.cpp +++ b/Objects/private/compiler/Instructions.cpp @@ -1,9 +1,8 @@ #include "compiler/Instructions.hpp" -using namespace obj; using namespace tp; -using namespace BCgen; +using namespace obj; Instruction::Instruction(OpCode op) : mOp(op), diff --git a/Objects/private/compiler/Statements.cpp b/Objects/private/compiler/Statements.cpp index 0f437f7..8df4fd3 100644 --- a/Objects/private/compiler/Statements.cpp +++ b/Objects/private/compiler/Statements.cpp @@ -1,7 +1,8 @@ #include "compiler/Statements.hpp" +#include +using namespace tp; using namespace obj; -using namespace BCgen; StatementFuncDef::StatementFuncDef(const std::string& function_id) : Statement(Type::DEF_FUNC) { @@ -10,8 +11,8 @@ StatementFuncDef::StatementFuncDef(const std::string& function_id) : StatementFuncDef::~StatementFuncDef() { delete mStatements; } -StatementLocalDef::StatementLocalDef(const std::string& id, Expression* value) : - mLocalId(id), +StatementLocalDef::StatementLocalDef(std::string id, Expression* value) : + mLocalId(std::move(id)), Statement(Type::DEF_LOCAL) { if (value->mType == Expression::Type::CONST_EXPR) { @@ -53,7 +54,7 @@ StatementPrint::StatementPrint(Expression* target) : StatementPrint::~StatementPrint() { delete mTarget; } -StatementScope::StatementScope(tp::InitialierList statements, bool aPushToScopeStack) : +StatementScope::StatementScope(InitialierList statements, bool aPushToScopeStack) : Statement(Type::SCOPE) { mStatements = statements; mPushToScopeStack = aPushToScopeStack; diff --git a/Objects/private/core/Object.cpp b/Objects/private/core/Object.cpp index e5653ba..9895f36 100644 --- a/Objects/private/core/Object.cpp +++ b/Objects/private/core/Object.cpp @@ -1,241 +1,239 @@ - #include "core/Object.hpp" #include "primitives/ClassObject.hpp" #include "primitives/MethodObject.hpp" -#include "primitives/NullObject.hpp" -#include "compiler/Functions.hpp" #include "interpreter/Interpreter.hpp" -namespace obj { +using namespace tp; +using namespace obj; - void save_string(ArchiverOut& file, const std::string& string) { - file << string.size(); - file.writeBytes(string.c_str(), string.size()); - } +void obj::save_string(ArchiverOut& file, const std::string& string) { + file << string.size(); + file.writeBytes(string.c_str(), string.size()); +} - tp::ualni save_string_size(const std::string& string) { - return string.size() + sizeof(string.size()); - } +ualni obj::save_string_size(const std::string& string) { + return string.size() + sizeof(string.size()); +} - void load_string(ArchiverIn& file, std::string& out) { - typeof(out.size()) size; - file >> size; - auto buff = new char[size + 1]; - file.readBytes(buff, size); - buff[size] = 0; - out = buff; - delete[] buff; - } +void obj::load_string(ArchiverIn& file, std::string& out) { + typeof(out.size()) size; + file >> size; + auto buff = new char[size + 1]; + file.readBytes(buff, size); + buff[size] = 0; + out = buff; + delete[] buff; +} - Object* ObjectMemAllocate(const ObjectType* type); - void ObjectMemDeallocate(Object* in); +Object* ObjectMemAllocate(const ObjectType* type); +void ObjectMemDeallocate(Object* in); - objects_api* NDO = nullptr; +objects_api* obj::NDO = nullptr; - void hierarchy_copy(Object* self, const Object* in, const ObjectType* type); - void hierarchy_construct(Object* self, const ObjectType* type); +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() { + memSetVal(sl_callbacks, SAVE_LOAD_MAX_CALLBACK_SLOTS * sizeof(save_load_callbacks*), 0); + interp = new Interpreter(); +} - objects_api::~objects_api() { delete interp; } +objects_api::~objects_api() { delete interp; } - void objects_api::define(ObjectType* type) { - MODULE_SANITY_CHECK(gModuleObjects); +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); + DEBUG_ASSERT(NDO && "using uninitialized objects api") + DEBUG_ASSERT(!types.presents(type->name) && "Type Redefinition") + types.put(type->name, type); - type->type_methods.init(); - } + type->type_methods.init(); +} - Object* objects_api::create(const std::string& name) { - MODULE_SANITY_CHECK(gModuleObjects); +Object* objects_api::create(const std::string& name) { + MODULE_SANITY_CHECK(gModuleObjects) - const ObjectType* type = types.get(name); + const ObjectType* type = types.get(name); - Object* obj_instance = ObjectMemAllocate(type); + Object* obj_instance = ObjectMemAllocate(type); - if (!obj_instance) { - return nullptr; - } - - 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 nullptr; - } - - 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, const std::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; - } - - std::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; - } - - ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in); - if (mh->refc > 1) { - mh->refc--; - return; - } - - 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); - } - - 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; - } - - - 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; - } + if (!obj_instance) { return nullptr; } -}; + + hierarchy_construct(obj_instance, obj_instance->type); + + setReferenceCount(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 nullptr; + } + + 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 memCompare(first, second, first->type->size) == 0; + } + + return false; +} + +Object* objects_api::instantiate(Object* in) { + obj::Object* obj = NDO->create(in->type->name); + NDO->copy(obj, in); + return obj; +} + +void objects_api::set(Object* self, 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, 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, const std::string& val) { + if (self->type->convesions && self->type->convesions->from_string) { + self->type->convesions->from_string(self, val); + return; + } +} + +alni objects_api::toInt(Object* self) { + DEBUG_ASSERT(self->type->convesions && self->type->convesions->to_int) + return self->type->convesions->to_int(self); +} + +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; +} + +std::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) const { + + if (!in) { + return; + } + + ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in); + if (mh->refc > 1) { + mh->refc--; + return; + } + + 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); +} + +halni objects_api::getReferenceCount(Object* in) { + ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in); + return (halni) mh->refc; +} + +void objects_api::increaseReferenceCount(Object* in) { + ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in); + mh->refc++; +} + +void objects_api::setReferenceCount(Object* in, halni count) { + ObjectMemHead* mh = NDO_MEMH_FROM_NDO(in); + mh->refc = count; +} + + +void hierarchy_copy(Object* self, const Object* in, const ObjectType* type) { + if (type->base) { + hierarchy_copy(self, in, type->base); + } + + 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* obj::ndo_cast(const Object* in, const ObjectType* to_type) { + const ObjectType* typeIter = in->type; + while (typeIter) { + if (typeIter == to_type) { + return (Object*) in; + } + typeIter = typeIter->base; + } + return nullptr; +} diff --git a/Objects/private/core/ObjectSave.cpp b/Objects/private/core/ObjectSave.cpp index dafc71a..64857ec 100644 --- a/Objects/private/core/ObjectSave.cpp +++ b/Objects/private/core/ObjectSave.cpp @@ -6,434 +6,434 @@ #include -namespace obj { +using namespace tp; +using namespace obj; - ObjectMemHead* bottom = nullptr; - tp::ualni count = 0; +ObjectMemHead* bottom = nullptr; +ualni count = 0; - struct ObjectsFileHeader { - char name[10] = { 0 }; - char version[10] = { 0 }; +struct ObjectsFileHeader { + char name[10] = { 0 }; + char version[10] = { 0 }; - ObjectsFileHeader(bool default_val = true) { - if (default_val) { - tp::memCopy(&name, "objects", 8); - tp::memCopy(&version, "0", 2); - } - } - }; - - Object* ObjectMemAllocate(const ObjectType* type) { - ObjectMemHead* memh = (ObjectMemHead*) malloc(type->size + sizeof(ObjectMemHead)); - if (!memh) { - return nullptr; - } - - memh->down = nullptr; - memh->flags = 0; - - memh->refc = (tp::alni) 1; - - if (bottom) { - bottom->down = memh; - } - - memh->up = bottom; - bottom = memh; - - count++; - - 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; - } - - free(memh); - - count--; - } - - void logTypeData(const ObjectType* type) { - printf("type - %s\n", type->name); - if (type->base) { - printf("Based on "); - logTypeData(type->base); + ObjectsFileHeader(bool default_val = true) { + if (default_val) { + memCopy(&name, "objects", 8); + memCopy(&version, "0", 2); } } +}; - tp::ualni getObjCount() { return count; } - - 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++; - } - } +Object* ObjectMemAllocate(const ObjectType* type) { + ObjectMemHead* memh = (ObjectMemHead*) malloc(type->size + sizeof(ObjectMemHead)); + if (!memh) { + return nullptr; } - struct ObjectFileHead { - Object* load_head_adress = 0; - tp::halni refc = 0; - }; + memh->down = nullptr; + memh->flags = 0; - tp::int1* loaded_file = nullptr; + memh->refc = (alni) 1; - void objects_api::clear_object_flags() { - // clear all object flags - for (ObjectMemHead* iter = bottom; iter; iter = iter->up) { - iter->flags = -1; - } + if (bottom) { + bottom->down = memh; } - tp::alni& getObjectFlags(Object* in) { return NDO_MEMH_FROM_NDO(in)->flags; } + memh->up = bottom; + bottom = memh; - tp::alni objsize_ram_util(Object* self, const ObjectType* type) { - tp::alni out = 0; + count++; + 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; + } + + free(memh); + + count--; +} + +void obj::logTypeData(const ObjectType* type) { + printf("type - %s\n", type->name); + if (type->base) { + printf("Based on "); + logTypeData(type->base); + } +} + +ualni obj::getObjCount() { return count; } + +void obj::assertNoLeaks() { + if (bottom) { + printf("ERROR : not all objects are destroyed\n"); + ualni idx = 0; + for (ObjectMemHead* memh = bottom; memh; memh = memh->up) { + printf(" ===== Object - %i. Ref count - %i ===== \n", idx, memh->refc); + logTypeData(NDO_FROM_MEMH(memh)->type); + idx++; + } + } +} + +struct ObjectFileHead { + Object* load_head_adress = 0; + halni refc = 0; +}; + +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; + } +} + +alni& getObjectFlags(Object* in) { return NDO_MEMH_FROM_NDO(in)->flags; } + +alni objsize_ram_util(Object* self, const ObjectType* type) { + 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; +} + +alni objects_api::objsize_ram(Object* self) { return objsize_ram_util(self, self->type); } + +alni objects_api::objsize_ram_recursive_util(Object* self, const ObjectType* type, bool different_object) { + 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_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); } + if (type->base) { + out += objsize_ram_recursive_util(self, type->base, false); + } else { + out += sizeof(ObjectType*); + } - tp::alni objects_api::objsize_ram_recursive_util(Object* self, const ObjectType* type, bool different_object) { - tp::alni out = 0; + return out; +} - if (different_object) { - if (getObjectFlags(self) == 1) { - return 0; - } +alni objects_api::objsize_ram_recursive(Object* self) { + clear_object_flags(); + return objsize_ram_recursive_util(self, self->type); +} - getObjectFlags(self) = 1; - } +alni objsize_file_util(Object* self, const ObjectType* type) { + alni out = 0; - 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->save_size) { + out += type->save_size(self); + } + + if (type->base) { + out += objsize_file_util(self, type->base); + } + return out; +} + +alni objects_api::objsize_file(Object* self) { return objsize_file_util(self, self->type); } + +alni objsize_file_recursive_util(Object* self, const ObjectType* type) { + alni out = 0; + + getObjectFlags(self) = 1; + + if (type->save_size) { + out += type->save_size(self); + } + + if (type->childs_retrival) { + Buffer 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_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); + if (type->base) { + out += objsize_file_recursive_util(self, type->base); } - tp::alni objsize_file_util(Object* self, const ObjectType* type) { - tp::alni out = 0; + return out; +} - if (type->save_size) { - out += type->save_size(self); - } +alni objects_api::objsize_file_recursive(Object* self) { + clear_object_flags(); + return objsize_file_recursive_util(self, self->type); +} - if (type->base) { - out += objsize_file_util(self, type->base); - } - return out; +void object_recursive_save(ArchiverOut& ndf, Object* self, const ObjectType* type) { + if (type->base) { + object_recursive_save(ndf, self, type->base); } - tp::alni objects_api::objsize_file(Object* self) { return objsize_file_util(self, self->type); } + // automatically offsets for parent type to write + if (type->save) { + type->save(self, ndf); + } +} - 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 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; +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; } - tp::alni objects_api::objsize_file_recursive(Object* self) { - clear_object_flags(); - return objsize_file_recursive_util(self, self->type); + // save write adress for parent save function call + alni tmp_adress = ndf.getAddress(); + + // save requested object to first available adress + 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, getReferenceCount(in) }; + ndf << ofh; + + save_string(ndf, in->type->name); + + // allocate for object file header + ndf.setFreeAddress(ndf.getFreeAddress() + sizeof(ObjectFileHead) + save_string_size(in->type->name)); + + // calc max size needed for saving all hierarchy of types + 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); } - 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 read + if (type->load) { + type->load(ndf, out); + } +} - // automatically offsets for parent type to write - if (type->save) { - type->save(self, ndf); +Object* objects_api::load(ArchiverIn& ndf, 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 + alni parent_file_adress = ndf.getAddress(); + + // set read address + ndf.setAddress(file_adress); + + ObjectFileHead ofh; + ndf >> ofh; + + std::string type_name; + load_string(ndf, type_name); + + const ObjectType* object_type = NDO->types.get(type_name); + Object* out = ObjectMemAllocate(object_type); + + if (!out) { + return nullptr; + } + + setReferenceCount(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, const std::string& path, bool compressed) { + ArchiverOut ndf(path.c_str()); + + if (!ndf.isOpened()) { + return false; + } + + clear_object_flags(); + + // save version info + ObjectsFileHeader header; + ndf << header; + + ndf.setFreeAddress(ndf.getAddress()); + + // pre allocate + for (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)); } } - 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; - - save_string(ndf, in->type->name); - - // allocate for object file header - ndf.setFreeAddress(ndf.getFreeAddress() + sizeof(ObjectFileHead) + save_string_size(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); + // pre-save + for (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); } } - 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(ndf, in); + + // post-save + for (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); } - - // save read address - tp::alni parent_file_adress = ndf.getAddress(); - - // set read address - ndf.setAddress(file_adress); - - ObjectFileHead ofh; - ndf >> ofh; - - std::string type_name; - load_string(ndf, type_name); - - const ObjectType* object_type = NDO->types.get(type_name); - Object* out = ObjectMemAllocate(object_type); - - if (!out) { - return nullptr; - } - - 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, const std::string& path, bool compressed) { - ArchiverOut ndf(path.c_str()); + // TODO : add compression + /* + if (compressed) { + auto temp = path + ".bz2"; + compressF2F(path.read(), temp.cstr()); - if (!ndf.isOpened()) { - return false; - } + File::remove(path.read()); + File::rename(temp.cstr(), path.read()); + } + */ - clear_object_flags(); + return true; +} - // save version info - ObjectsFileHeader header; - ndf << header; +Object* objects_api::load(const std::string& path) { + /* + auto temp_file_name = path + ".unz"; + bool unz_res = decompressF2F(path.cstr(), temp_file_name.cstr()); - 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; + if (!unz_res) { + return nullptr; } - Object* objects_api::load(const std::string& path) { - /* - auto temp_file_name = path + ".unz"; - bool unz_res = tp::decompressF2F(path.cstr(), temp_file_name.cstr()); + File ndf(temp_file_name.cstr(), osfile_openflags::LOAD); + */ - if (!unz_res) { - return nullptr; - } + ArchiverIn ndf(path.c_str()); - File ndf(temp_file_name.cstr(), tp::osfile_openflags::LOAD); - */ - - ArchiverIn ndf(path.c_str()); - - if (!ndf.isOpened()) { - return nullptr; - } - - // check for compatibility - ObjectsFileHeader current_header; - ObjectsFileHeader loaded_header(false); - - ndf >> loaded_header; - - if (!tp::memEqual(¤t_header, &loaded_header, sizeof(ObjectsFileHeader))) { - return nullptr; - } - - 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 == nullptr) { - File::remove(temp_file_name.cstr()); - } - */ - - return out; + if (!ndf.isOpened()) { + return nullptr; } - void objects_api::add_sl_callbacks(save_load_callbacks* in) { - sl_callbacks[sl_callbacks_load_idx] = in; - sl_callbacks_load_idx++; + // check for compatibility + ObjectsFileHeader current_header; + ObjectsFileHeader loaded_header(false); + + ndf >> loaded_header; + + if (!memEqual(¤t_header, &loaded_header, sizeof(ObjectsFileHeader))) { + return nullptr; } -}; + + ndf.setAddress(0); + + const auto fileSize = ndf.getSize(); + loaded_file = (int1*) malloc(fileSize); + memSetVal(loaded_file, fileSize, 0); + ndf.readBytes(loaded_file, fileSize); + + ndf.setAddress(sizeof(ObjectsFileHeader)); + + // preload + for (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 (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 == nullptr) { + 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++; +} diff --git a/Objects/private/core/ObjectsModule.cpp b/Objects/private/core/ObjectsModule.cpp index c7dc5df..95e1cec 100644 --- a/Objects/private/core/ObjectsModule.cpp +++ b/Objects/private/core/ObjectsModule.cpp @@ -16,8 +16,8 @@ #include "primitives/StringObject.hpp" #include "primitives/TypeObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; static void defineTypes() { NDO->define(&DictObject::TypeData); @@ -50,9 +50,9 @@ static void defineGroups() { NDO->type_groups.addType(&InterpreterObject::TypeData, { "scripting" }); } -static bool init(const tp::ModuleManifest*) { +static bool init(const ModuleManifest*) { if (!NDO) NDO = new objects_api(); - obj::BCgen::init(); + obj::initialize(); MethodObject::Initialize(); @@ -62,12 +62,12 @@ static bool init(const tp::ModuleManifest*) { return true; } -static void deinit(const tp::ModuleManifest*) { +static void deinit(const ModuleManifest*) { NullObject::uninit(); MethodObject::UnInitialize(); - obj::BCgen::deinit(); + obj::finalize(); assertNoLeaks(); @@ -75,8 +75,8 @@ static void deinit(const tp::ModuleManifest*) { NDO = nullptr; } -static tp::ModuleManifest* sModuleDependencies[] = { +static ModuleManifest* sModuleDependencies[] = { nullptr }; -tp::ModuleManifest obj::gModuleObjects = tp::ModuleManifest("Objects", init, deinit, sModuleDependencies); +ModuleManifest obj::gModuleObjects = ModuleManifest("Objects", init, deinit, sModuleDependencies); diff --git a/Objects/private/core/ScriptSection.cpp b/Objects/private/core/ScriptSection.cpp index b1ef355..1d3d9a8 100644 --- a/Objects/private/core/ScriptSection.cpp +++ b/Objects/private/core/ScriptSection.cpp @@ -1,18 +1,19 @@ #include "core/ScriptSection.hpp" +using namespace tp; using namespace obj; ScriptSection* gScriptSection = nullptr; struct script_data_head { - tp::alni refc = 0; - tp::alni store_adress = 0; + alni refc = 0; + alni store_adress = 0; }; -void set_script_head_store_adress(Script* in, tp::alni address) { ((script_data_head*) in - 1)->store_adress = address; } +void set_script_head_store_adress(Script* in, 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; } +alni get_script_head_store_adress(Script* in) { return ((script_data_head*) in - 1)->store_adress; } Script* ScriptSection::createScript() { auto sdhead = (script_data_head*) malloc(sizeof(script_data_head) + sizeof(Script)); @@ -29,7 +30,7 @@ Script* ScriptSection::createScript() { new (out) Script(); out->mReadable = obj::StringObject::create(""); - obj::NDO->refinc(out->mReadable); + obj::NDO->increaseReferenceCount(out->mReadable); return out; } @@ -60,29 +61,29 @@ void ScriptSection::changeScript(Script** current_script, Script** new_script) { *current_script = *new_script; } -tp::alni ScriptSection::get_script_file_adress(Script* in) { return get_script_head_store_adress(in); } +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; +alni ScriptSection::save_script_table_to_file_size(ScriptSection* self, ArchiverOut& file) { + alni size = 0; size += 5; // header - size += sizeof(tp::alni); // scripts length + size += sizeof(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 + size += sizeof(alni); // scripts string obj ref + size += sizeof(alni); // constants length for (auto const_obj : iter->mBytecode.mConstants) { - size += sizeof(tp::alni); // constant object addres + size += sizeof(alni); // constant object addres } // instructions - size += tp::SaveSizeCounter::calc(iter->mBytecode.mInstructions); + size += SaveSizeCounter::calc(iter->mBytecode.mInstructions); } - size += sizeof(tp::alni); // objects mem offset + size += sizeof(alni); // objects mem offset size += 5; // header return size; } @@ -92,7 +93,7 @@ void ScriptSection::save_script_table_to_file(ScriptSection* self, ArchiverOut& file.writeBytes("/scr/", 5); // scripts length - tp::alni scripts_count = self->mScripts.length(); + alni scripts_count = self->mScripts.length(); file << scripts_count; for (auto iter : self->mScripts) { @@ -102,7 +103,7 @@ void ScriptSection::save_script_table_to_file(ScriptSection* self, ArchiverOut& file << obj_addres; // constants length - tp::alni consts_count = iter->mBytecode.mConstants.size(); + alni consts_count = iter->mBytecode.mConstants.size(); file << consts_count; for (auto const_obj : iter->mBytecode.mConstants) { @@ -118,40 +119,40 @@ void ScriptSection::save_script_table_to_file(ScriptSection* self, ArchiverOut& // header file.writeBytes("/scr/", 5); - tp::alni objects_mem_offset = file.getFreeAddress(); + alni objects_mem_offset = file.getFreeAddress(); file << objects_mem_offset; } -void load_constants(ScriptSection* self, ArchiverIn& file, tp::alni start_addr) { +void load_constants(ScriptSection* self, ArchiverIn& file, alni start_addr) { auto addres = file.getAddress(); file.setAddress(start_addr); file.setAddress(start_addr + 5); // header - tp::alni scripts_count; + alni scripts_count; file >> scripts_count; - for (tp::alni i = 0; i < scripts_count; i++) { + for (alni i = 0; i < scripts_count; i++) { auto script = self->get_scritp_from_file_adress(file.getAddress()); // script text - tp::alni str_addr; + 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 + file.setAddress(file.getAddress() + sizeof(alni)); // constants length for (auto const_obj : script->mBytecode.mConstants) { - tp::alni consts_addr; + 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(file.getAddress() + SaveSizeCounter::calc(script->mBytecode.mInstructions)); } file.setAddress(addres); @@ -168,26 +169,26 @@ void ScriptSection::load_script_table_from_file(ScriptSection* self, ArchiverIn& file.setAddress(file.getAddress() + 5); // scripts length - tp::alni scripts_count; + alni scripts_count; file >> scripts_count; - for (tp::alni i = 0; i < scripts_count; i++) { + for (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)); + file.setAddress(file.getAddress() + sizeof(alni)); // constants length - tp::alni consts_count; + alni consts_count; file >> consts_count; new_script->mBytecode.mConstants.reserve(consts_count); - for (tp::alni j = 0; j < consts_count; j++) { + for (alni j = 0; j < consts_count; j++) { // constant object addres - tp::alni consts_addr; + alni consts_addr; file >> consts_addr; // skiping @@ -203,13 +204,13 @@ void ScriptSection::load_script_table_from_file(ScriptSection* self, ArchiverIn& // header file.setAddress(file.getAddress() + 5); - tp::alni objects_mem_offset; + alni objects_mem_offset; file >> objects_mem_offset; file.setAddress(objects_mem_offset); } -Script* ScriptSection::get_scritp_from_file_adress(tp::alni file_adress) { +Script* ScriptSection::get_scritp_from_file_adress(alni file_adress) { for (auto iter : mScripts) { if (get_script_head_store_adress(iter.data()) == file_adress) { return iter.data(); diff --git a/Objects/private/core/TypeGroups.cpp b/Objects/private/core/TypeGroups.cpp index 9663f46..57952dc 100644 --- a/Objects/private/core/TypeGroups.cpp +++ b/Objects/private/core/TypeGroups.cpp @@ -3,6 +3,7 @@ #include "core/Object.hpp" +using namespace tp; using namespace obj; obj::TypeGroups::TypeGroups() : @@ -31,10 +32,10 @@ void obj::TypeGroups::setType(ObjectType* type) { this->type = type; } -void obj::TypeGroups::addType(ObjectType* type, tp::InitialierList path, tp::alni cur_dir_idx) { +void obj::TypeGroups::addType(ObjectType* type, InitialierList path, alni cur_dir_idx) { DEBUG_ASSERT(is_group); - tp::alni dir_len = (tp::alni) path.size(); + alni dir_len = (alni) path.size(); if (dir_len == cur_dir_idx) { TypeGroups* type_ref = new TypeGroups(false); @@ -44,7 +45,7 @@ void obj::TypeGroups::addType(ObjectType* type, tp::InitialierList } TypeGroups* group = nullptr; - tp::alni index = 0; + alni index = 0; for (auto dir : path) { if (index != cur_dir_idx) { diff --git a/Objects/private/core/TypeMethods.cpp b/Objects/private/core/TypeMethods.cpp index 7662692..66c38a2 100644 --- a/Objects/private/core/TypeMethods.cpp +++ b/Objects/private/core/TypeMethods.cpp @@ -7,6 +7,7 @@ #include "interpreter/Interpreter.hpp" +using namespace tp; using namespace obj; TypeMethod obj::gDefaultTypeMethods[] = { @@ -40,17 +41,17 @@ TypeMethod obj::gDefaultTypeMethods[] = { }, }; -tp::int2 TypeMethods::presents(const std::string& id) const { - for (tp::int2 idx = 0; idx < mNMethods; idx++) { +int2 TypeMethods::presents(const std::string& id) const { + for (int2 idx = 0; idx < mNMethods; idx++) { if (id == methods[idx]->nameid) { return idx; } } - tp::int2 idx = 0; + int2 idx = 0; for (auto& tm : gDefaultTypeMethods) { if (id == tm.nameid) { - return { tp::int2(idx + MAX_TYPE_METHODS) }; + return { int2(idx + MAX_TYPE_METHODS) }; } idx++; } @@ -60,8 +61,8 @@ tp::int2 TypeMethods::presents(const std::string& id) const { TypeMethods::LookupKey TypeMethods::presents(const ObjectType* type, const std::string& id) { - tp::int2 depth = 0; - tp::int2 idx = 0; + int2 depth = 0; + int2 idx = 0; for (auto iter_type = type; iter_type; iter_type = iter_type->base) { idx = iter_type->type_methods.presents(id); @@ -74,7 +75,7 @@ TypeMethods::LookupKey TypeMethods::presents(const ObjectType* type, const std:: return { idx, depth }; } -const TypeMethod* TypeMethods::getMethod(tp::int2 key) const { +const TypeMethod* TypeMethods::getMethod(int2 key) const { if (key < MAX_TYPE_METHODS) { return methods[key]; } @@ -94,14 +95,14 @@ void TypeMethods::init() { mNMethods++; } - for (tp::int1 i = 0; i < mNMethods; i++) { + for (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; } +halni TypeMethods::nMethods() const { return mNMethods; } void TypeMethod::operator()(Interpreter* interp) const { for (auto i = 1; i <= mNargs; i++) { diff --git a/Objects/private/interpreter/CallStack.cpp b/Objects/private/interpreter/CallStack.cpp index 3a4c567..06dbc9e 100644 --- a/Objects/private/interpreter/CallStack.cpp +++ b/Objects/private/interpreter/CallStack.cpp @@ -4,6 +4,7 @@ #include "interpreter/ByteCode.hpp" #include "primitives/MethodObject.hpp" +using namespace tp; using namespace obj; void CallStack::enter(const CallStack::CallFrame& frame) { @@ -14,7 +15,7 @@ void CallStack::enter(const CallStack::CallFrame& frame) { frame.mMethod->mScript->mBytecode.mArgumentsLoaded = 0; frame.mMethod->mScript->mBytecode.mInstructionIdx = 0; - obj::NDO->refinc(frame.mMethod); + obj::NDO->increaseReferenceCount(frame.mMethod); mStack.append(frame); } @@ -31,4 +32,4 @@ void CallStack::leave() { ByteCode* CallStack::getBytecode() { return &mStack.last().mMethod->mScript->mBytecode; } -tp::halni CallStack::len() const { return mStack.size(); } +halni CallStack::len() const { return mStack.size(); } diff --git a/Objects/private/interpreter/Interpreter.cpp b/Objects/private/interpreter/Interpreter.cpp index 293d763..94e0b0c 100644 --- a/Objects/private/interpreter/Interpreter.cpp +++ b/Objects/private/interpreter/Interpreter.cpp @@ -5,20 +5,21 @@ #include "Timing.hpp" +using namespace tp; using namespace obj; -inline tp::uint1 read_byte(ByteCode* bytecode) { - auto out = (tp::uint1) bytecode->mInstructions[bytecode->mInstructionIdx]; +inline uint1 read_byte(ByteCode* bytecode) { + auto out = (uint1) bytecode->mInstructions[bytecode->mInstructionIdx]; bytecode->mInstructionIdx++; return out; } // exeption for opcodes // reads 2 bytes from instructions in order to load constant onto operands stack -tp::uint2 loadConstDataIdx(ByteCode* bytecode) { - tp::uint2 out = 0; - out |= ((tp::uint2) read_byte(bytecode)); - out |= ((tp::uint2) read_byte(bytecode) << 8); +uint2 loadConstDataIdx(ByteCode* bytecode) { + uint2 out = 0; + out |= ((uint2) read_byte(bytecode)); + out |= ((uint2) read_byte(bytecode) << 8); return out; } @@ -26,9 +27,9 @@ tp::uint2 loadConstDataIdx(ByteCode* bytecode) { // reads 2 bytes from instructions in order to load constant onto operands stack void skip_param(ByteCode* bytecode) { bytecode->mInstructionIdx += 2; } -tp::uint2 param(ByteCode* bytecode) { return loadConstDataIdx(bytecode); } +uint2 param(ByteCode* bytecode) { return loadConstDataIdx(bytecode); } -void Interpreter::exec(obj::MethodObject* method, obj::ClassObject* self, obj::DictObject* globals, tp::InitialierList globals2) { +void Interpreter::exec(obj::MethodObject* method, obj::ClassObject* self, obj::DictObject* globals, InitialierList globals2) { if (!method->mScript->mBytecode.mInstructions.size()) { return; } @@ -52,7 +53,7 @@ void Interpreter::exec(obj::MethodObject* method, obj::ClassObject* self, obj::D bool Interpreter::finished() { return !mCallStack.len(); } void Interpreter::stepBytecode() { - tp::halni call_depth = mCallStack.len(); + halni call_depth = mCallStack.len(); do { stepBytecodeIn(); if (finished()) { @@ -66,7 +67,7 @@ void Interpreter::stepBytecodeOut() { return; } - tp::halni call_depth = mCallStack.len(); + halni call_depth = mCallStack.len(); if (!call_depth) { return; } @@ -87,7 +88,7 @@ void Interpreter::stepBytecodeIn() { auto bytecode = mCallStack.getBytecode(); - if (bytecode->mInstructionIdx >= (tp::ualni) bytecode->mInstructions.size()) { + if (bytecode->mInstructionIdx >= (ualni) bytecode->mInstructions.size()) { // just return if (mScopeStack.mIdx) { mScopeStack.leaveScope(); @@ -114,14 +115,14 @@ void Interpreter::stepBytecodeIn() { case OpCode::HALT: { while (true) { - tp::sleep(3); + sleep(3); } break; } case OpCode::TERMINATE: { - // tp::terminate(0); + // terminate(0); } case OpCode::IGNORE: @@ -242,7 +243,7 @@ void Interpreter::stepBytecodeIn() { auto id = mOperandsStack.getOperand(); auto obj = mOperandsStack.getOperand(); mScopeStack.addLocal(obj, id->val); - NDO->refinc(obj); + NDO->increaseReferenceCount(obj); // mScopeStack.popTemp(); break; } @@ -270,7 +271,7 @@ void Interpreter::stepBytecodeIn() { // class is a function - execute it as a constructor // PUSH_ARGS protocol - tp::uint2 len = 0; + uint2 len = 0; mOperandsStack.push((Object*) len); mOperandsStack.push(nullptr); @@ -318,7 +319,7 @@ void Interpreter::stepBytecodeIn() { // +4) object2 // ... - tp::uint2 len = read_byte(bytecode); + uint2 len = read_byte(bytecode); mOperandsStack.push((Object*) len); mOperandsStack.push(nullptr); break; @@ -326,11 +327,11 @@ void Interpreter::stepBytecodeIn() { case OpCode::SAVE_ARGS: { - tp::uint2 args_len = read_byte(bytecode); + uint2 args_len = read_byte(bytecode); auto argument = mOperandsStack.getOperand(); while (argument) { - NDO->refinc(argument); + NDO->increaseReferenceCount(argument); auto argument_id = bytecode->mConstants[loadConstDataIdx(bytecode)]; NDO_CASTV(StringObject, argument_id, id); @@ -340,7 +341,7 @@ void Interpreter::stepBytecodeIn() { argument = mOperandsStack.getOperand(); } - tp::uint2 saved_len = tp::uint2(tp::ualni(mOperandsStack.getOperand())); + uint2 saved_len = uint2(ualni(mOperandsStack.getOperand())); ASSERT(args_len == saved_len && "invalid number of arguments passefd"); break; @@ -388,7 +389,7 @@ void Interpreter::stepBytecodeIn() { ASSERT(left->type == right->type && "addition of different types is not implemented"); ASSERT(left->type->ariphmetics && left->type->ariphmetics->add && "cannot add object of this type"); - auto res = NDO->instatiate(left); + auto res = NDO->instantiate(left); res->type->ariphmetics->add(res, right); mScopeStack.addTemp(res); @@ -403,7 +404,7 @@ void Interpreter::stepBytecodeIn() { ASSERT(left->type == right->type && "addition of different types is not implemented"); ASSERT(left->type->ariphmetics && left->type->ariphmetics->add && "cannot add object of this type"); - auto res = NDO->instatiate(left); + auto res = NDO->instantiate(left); res->type->ariphmetics->sub(res, right); mScopeStack.addTemp(res); @@ -418,7 +419,7 @@ void Interpreter::stepBytecodeIn() { ASSERT(left->type == right->type && "addition of different types is not implemented"); ASSERT(left->type->ariphmetics && left->type->ariphmetics->add && "cannot add object of this type"); - auto res = NDO->instatiate(left); + auto res = NDO->instantiate(left); res->type->ariphmetics->mul(res, right); mScopeStack.addTemp(res); @@ -433,7 +434,7 @@ void Interpreter::stepBytecodeIn() { ASSERT(left->type == right->type && "addition of different types is not implemented"); ASSERT(left->type->ariphmetics && left->type->ariphmetics->add && "cannot add object of this type"); - auto res = NDO->instatiate(left); + auto res = NDO->instantiate(left); res->type->ariphmetics->div(res, right); mScopeStack.addTemp(res); @@ -593,7 +594,7 @@ void Interpreter::stepBytecodeIn() { } } -void Interpreter::execAll(obj::MethodObject* method, obj::ClassObject* self, obj::DictObject* globals, tp::InitialierList globals2) { +void Interpreter::execAll(obj::MethodObject* method, obj::ClassObject* self, obj::DictObject* globals, InitialierList globals2) { if (!method->mScript->mBytecode.mInstructions.size()) { return; } diff --git a/Objects/private/interpreter/OperandsStack.cpp b/Objects/private/interpreter/OperandsStack.cpp index b83b3c5..4f7206d 100644 --- a/Objects/private/interpreter/OperandsStack.cpp +++ b/Objects/private/interpreter/OperandsStack.cpp @@ -1,6 +1,7 @@ #include "interpreter/OperandsStack.hpp" +using namespace tp; using namespace obj; OperandStack::OperandStack() { diff --git a/Objects/private/interpreter/OperationCodes.cpp b/Objects/private/interpreter/OperationCodes.cpp index ebce645..9aa8104 100644 --- a/Objects/private/interpreter/OperationCodes.cpp +++ b/Objects/private/interpreter/OperationCodes.cpp @@ -3,18 +3,17 @@ #include "interpreter/OperatoinCodes.hpp" -namespace obj { - OpcodeInfos gOpcodeInfos; -}; - +using namespace tp; using namespace obj; +OpcodeInfos tp::obj::gOpcodeInfos; + #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 list) { +OpcodeInfos::OperandsInfo::OperandsInfo(InitialierList list) { DEBUG_ASSERT(MAX_OPERANDS >= list.size()); for (auto item : list) { buff[len] = item; @@ -23,7 +22,7 @@ OpcodeInfos::OperandsInfo::OperandsInfo(tp::InitialierList list) { } OpcodeInfos::ParamsInfo::ParamsInfo() {} -OpcodeInfos::ParamsInfo::ParamsInfo(tp::InitialierList list) { +OpcodeInfos::ParamsInfo::ParamsInfo(InitialierList list) { DEBUG_ASSERT(MAX_PARAMS >= list.size()); for (auto item : list) { buff[len] = item; @@ -31,8 +30,8 @@ OpcodeInfos::ParamsInfo::ParamsInfo(tp::InitialierList list) { } } -tp::uint1 OpcodeInfos::OpInfo::opsize() { - tp::uint1 out = 1; +uint1 OpcodeInfos::OpInfo::opsize() { + uint1 out = 1; for (auto i = 0; i < params.len; i++) { out += params.buff[i].bytes; } @@ -364,8 +363,8 @@ OpcodeInfos::OpcodeInfos() { } 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]; + DEBUG_ASSERT((alni) code >= 0 && (alni) code < (alni) OpCode::END_OPCODES); + return buff[(alni) code]; } -void OpcodeInfos::add(OpCode code, const OpInfo& info) { buff[(tp::alni) code] = info; } \ No newline at end of file +void OpcodeInfos::add(OpCode code, const OpInfo& info) { buff[(alni) code] = info; } \ No newline at end of file diff --git a/Objects/private/interpreter/ScopeStack.cpp b/Objects/private/interpreter/ScopeStack.cpp index 74a926e..bb40c80 100644 --- a/Objects/private/interpreter/ScopeStack.cpp +++ b/Objects/private/interpreter/ScopeStack.cpp @@ -1,6 +1,7 @@ #include "interpreter/ScopeStack.hpp" +using namespace tp; using namespace obj; Scope::~Scope() { @@ -46,7 +47,7 @@ void ScopeStack::leaveScope() { } void ScopeStack::addTemp(obj::Object* tmp) { - obj::NDO->refinc(tmp); + obj::NDO->increaseReferenceCount(tmp); mBuff[mIdx - 1].mTemps.pushBack(tmp); } @@ -57,7 +58,7 @@ void ScopeStack::popTemp() { void ScopeStack::addTempReturn(obj::Object* ret) { if (mIdx >= 2) { - obj::NDO->refinc(ret); + obj::NDO->increaseReferenceCount(ret); mBuff[mIdx - 2].mTemps.pushBack(ret); } } @@ -69,7 +70,7 @@ void ScopeStack::addLocal(obj::Object* local, const std::string& id) { if (idx) { obj::NDO->destroy(locals.getSlotVal(idx)); } - obj::NDO->refinc(local); + obj::NDO->increaseReferenceCount(local); locals.put(id, local); } diff --git a/Objects/private/parser/Bindings.cpp b/Objects/private/parser/Bindings.cpp index 78da434..cfb9433 100644 --- a/Objects/private/parser/Bindings.cpp +++ b/Objects/private/parser/Bindings.cpp @@ -1,7 +1,8 @@ #include "Private.hpp" -using namespace obj::BCgen; +using namespace tp; +using namespace obj; typedef lalr::ParserNode Node; @@ -189,7 +190,7 @@ static UserData tmp(const UserData* start, const Node*, size_t) { #define BIND(name) parser.set_action_handler(#name, &(name)) -void bind(LalrParser& parser) { +void obj::bind(LalrParser& parser) { BIND(scope); BIND(stm_list_append); diff --git a/Objects/private/parser/Parser.cpp b/Objects/private/parser/Parser.cpp index 50dbbb4..e9d9a67 100644 --- a/Objects/private/parser/Parser.cpp +++ b/Objects/private/parser/Parser.cpp @@ -3,6 +3,7 @@ #include "Private.hpp" +using namespace tp; using namespace obj; lalr::ErrorPolicy::~ErrorPolicy() = default; @@ -37,10 +38,10 @@ Parser::Result Parser::parse(const std::string& stream) { parser.parse(streamStd.begin(), streamStd.end()); - BCgen::StatementScope* out = nullptr; + StatementScope* out = nullptr; if (parser.accepted() && parser.full()) { - out = (BCgen::StatementScope*) parser.user_data().statement; + out = (StatementScope*) parser.user_data().statement; } return { out, !(parser.accepted() && parser.full()) }; diff --git a/Objects/private/parser/Private.hpp b/Objects/private/parser/Private.hpp index 966a614..50801a8 100644 --- a/Objects/private/parser/Private.hpp +++ b/Objects/private/parser/Private.hpp @@ -9,42 +9,44 @@ #include "Tree.hpp" -struct UserNode { - obj::BCgen::Expression* expression = nullptr; - obj::BCgen::Statement* statement = nullptr; - tp::Buffer* arguments = nullptr; - - UserNode(obj::BCgen::Statement* stm) : - statement(stm) {} - - UserNode(obj::BCgen::Expression* expr) : - expression(expr) {} - - UserNode(tp::Buffer* argList) : - arguments(argList) {} - - UserNode() = default; - - obj::BCgen::Statement* releaseStm() { - auto out = statement; - statement = nullptr; - return out; - } - - void destroy() { - delete statement; - delete arguments; - delete expression; - } -}; - -typedef UserNode UserData; -typedef char SymbolType; - -typedef std::basic_string::iterator IteratorType; - extern const lalr::ParserStateMachine* oscript_parser_state_machine; -typedef lalr::Parser LalrParser; +namespace tp::obj { + struct UserNode { + obj::Expression* expression = nullptr; + obj::Statement* statement = nullptr; + tp::Buffer* arguments = nullptr; -void bind(LalrParser& parser); + UserNode(obj::Statement* stm) : + statement(stm) {} + + UserNode(obj::Expression* expr) : + expression(expr) {} + + UserNode(tp::Buffer* argList) : + arguments(argList) {} + + UserNode() = default; + + obj::Statement* releaseStm() { + auto out = statement; + statement = nullptr; + return out; + } + + void destroy() { + delete statement; + delete arguments; + delete expression; + } + }; + + typedef UserNode UserData; + typedef char SymbolType; + + typedef std::basic_string::iterator IteratorType; + + typedef lalr::Parser LalrParser; + + void bind(LalrParser& parser); +} \ No newline at end of file diff --git a/Objects/private/primitives/BoolObject.cpp b/Objects/private/primitives/BoolObject.cpp index e627423..a0318c9 100644 --- a/Objects/private/primitives/BoolObject.cpp +++ b/Objects/private/primitives/BoolObject.cpp @@ -2,8 +2,8 @@ #include "primitives/BoolObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void BoolObject::constructor(BoolObject* self) { self->val = false; } diff --git a/Objects/private/primitives/ClassObject.cpp b/Objects/private/primitives/ClassObject.cpp index 100991d..dece72d 100644 --- a/Objects/private/primitives/ClassObject.cpp +++ b/Objects/private/primitives/ClassObject.cpp @@ -3,8 +3,8 @@ #include "primitives/DictObject.hpp" #include "primitives/NullObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void ClassObject::constructor(ClassObject* self) { self->members = NDO_CAST(DictObject, NDO->create("dict")); @@ -38,7 +38,7 @@ 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); + NDO->increaseReferenceCount(self->members); } tp::Buffer childs_retrival(ClassObject* self) { diff --git a/Objects/private/primitives/ColorObject.cpp b/Objects/private/primitives/ColorObject.cpp index e9ece07..f5fab12 100644 --- a/Objects/private/primitives/ColorObject.cpp +++ b/Objects/private/primitives/ColorObject.cpp @@ -1,8 +1,8 @@ #include "primitives/ColorObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void ColorObject::constructor(Object* self) { NDO_CAST(ColorObject, self)->mCol = tp::RGBA(1.f); } diff --git a/Objects/private/primitives/DictObject.cpp b/Objects/private/primitives/DictObject.cpp index 409ae2e..daac2e2 100644 --- a/Objects/private/primitives/DictObject.cpp +++ b/Objects/private/primitives/DictObject.cpp @@ -2,8 +2,8 @@ #include "primitives/DictObject.hpp" #include "primitives/StringObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void DictObject::constructor(Object* self) { NDO_CASTV(DictObject, self, dict); @@ -19,7 +19,7 @@ void DictObject::copy(Object* in, const Object* target) { constructor(self); for (auto item : src->items) { - auto instance = NDO->instatiate(item->val); + auto instance = NDO->instantiate(item->val); self->items.put(item->key, instance); } } @@ -120,7 +120,7 @@ alni DictObject::allocated_size_recursive(DictObject* self) { void DictObject::put(const std::string& str, Object* obj) { DEBUG_ASSERT(obj); - NDO->refinc(obj); + NDO->increaseReferenceCount(obj); items.put(str, obj); } diff --git a/Objects/private/primitives/EnumObject.cpp b/Objects/private/primitives/EnumObject.cpp index 0074b8f..94c70a0 100644 --- a/Objects/private/primitives/EnumObject.cpp +++ b/Objects/private/primitives/EnumObject.cpp @@ -4,8 +4,8 @@ #include #include -using namespace obj; using namespace tp; +using namespace obj; void EnumObject::constructor(EnumObject* self) { self->active = 0; diff --git a/Objects/private/primitives/FloatObject.cpp b/Objects/private/primitives/FloatObject.cpp index 4f9a331..ee5f02e 100644 --- a/Objects/private/primitives/FloatObject.cpp +++ b/Objects/private/primitives/FloatObject.cpp @@ -1,7 +1,7 @@ #include "primitives/FloatObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void FloatObject::constructor(FloatObject* self) { self->val = 0; } diff --git a/Objects/private/primitives/IntObject.cpp b/Objects/private/primitives/IntObject.cpp index d27aa3f..3c61aa5 100644 --- a/Objects/private/primitives/IntObject.cpp +++ b/Objects/private/primitives/IntObject.cpp @@ -1,8 +1,8 @@ #include "primitives/IntObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void IntObject::constructor(Object* self) { NDO_CAST(IntObject, self)->val = 0; } diff --git a/Objects/private/primitives/InterpreterObject.cpp b/Objects/private/primitives/InterpreterObject.cpp index 015e3b4..38ebfdd 100644 --- a/Objects/private/primitives/InterpreterObject.cpp +++ b/Objects/private/primitives/InterpreterObject.cpp @@ -3,8 +3,8 @@ #include "primitives/LinkObject.hpp" #include "primitives/MethodObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void InterpreterObject::constructor(InterpreterObject* self) { new (&self->mInterpreter) Interpreter(); diff --git a/Objects/private/primitives/LinkObject.cpp b/Objects/private/primitives/LinkObject.cpp index 56a1ca1..930d6d1 100644 --- a/Objects/private/primitives/LinkObject.cpp +++ b/Objects/private/primitives/LinkObject.cpp @@ -1,8 +1,8 @@ #include "primitives/LinkObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void LinkObject::constructor(Object* self) { NDO_CAST(LinkObject, self)->link = 0; } @@ -38,7 +38,7 @@ void LinkObject::load(ArchiverIn& file_self, LinkObject* self) { self->link = nullptr; } else { self->link = NDO->load(file_self, saved_object_adress); - NDO->refinc(self->link); + NDO->increaseReferenceCount(self->link); } } @@ -62,7 +62,7 @@ Object* LinkObject::getLink() { return link; } void LinkObject::setLink(Object* obj) { if (link) NDO->destroy(link); - if (obj) NDO->refinc(obj); + if (obj) NDO->increaseReferenceCount(obj); link = obj; } diff --git a/Objects/private/primitives/ListObject.cpp b/Objects/private/primitives/ListObject.cpp index 0d339e8..bad2655 100644 --- a/Objects/private/primitives/ListObject.cpp +++ b/Objects/private/primitives/ListObject.cpp @@ -2,8 +2,8 @@ #include "primitives/IntObject.hpp" #include "primitives/ListObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void ListObject::constructor(Object* in) { NDO_CASTV(ListObject, in, self); @@ -17,7 +17,7 @@ void ListObject::copy(Object* in, const Object* target) { destructor(in); for (auto item : src->items) { - self->pushBack(NDO->instatiate(item.data())); + self->pushBack(NDO->instantiate(item.data())); } } @@ -84,12 +84,12 @@ alni ListObject::allocated_size_recursive(ListObject* self) { } void ListObject::pushBack(Object* obj) { - obj::NDO->refinc(obj); + obj::NDO->increaseReferenceCount(obj); items.pushBack(obj); } void ListObject::pushFront(Object* obj) { - obj::NDO->refinc(obj); + obj::NDO->increaseReferenceCount(obj); items.pushFront(obj); } diff --git a/Objects/private/primitives/MethodObject.cpp b/Objects/private/primitives/MethodObject.cpp index 671a1bb..5df8719 100644 --- a/Objects/private/primitives/MethodObject.cpp +++ b/Objects/private/primitives/MethodObject.cpp @@ -3,6 +3,7 @@ #include "core/ScriptSection.hpp" #include "primitives/MethodObject.hpp" +using namespace tp; using namespace obj; struct ObjectType MethodObject::TypeData = { @@ -52,7 +53,7 @@ void MethodObject::Initialize() { void MethodObject::UnInitialize() { obj::ScriptSection::uninitialize(); } -void MethodObject::compile() { BCgen::Compile(this); } +void MethodObject::compile() { Compile(this); } MethodObject* MethodObject::create(const std::string& script) { auto out = (MethodObject*) NDO->create(MethodObject::TypeData.name); diff --git a/Objects/private/primitives/NullObject.cpp b/Objects/private/primitives/NullObject.cpp index fd099f6..e1a7360 100644 --- a/Objects/private/primitives/NullObject.cpp +++ b/Objects/private/primitives/NullObject.cpp @@ -2,8 +2,8 @@ #include "primitives/NullObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; obj::NullObject* obj::NdoNull_globalInstance = nullptr; bool uninit_flag = false; diff --git a/Objects/private/primitives/Stringobject.cpp b/Objects/private/primitives/Stringobject.cpp index 3cbda2d..7487443 100644 --- a/Objects/private/primitives/Stringobject.cpp +++ b/Objects/private/primitives/Stringobject.cpp @@ -2,8 +2,8 @@ #include "primitives/StringObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; void StringObject::constructor(Object* self) { new (&NDO_CAST(StringObject, self)->val) std::string(); } diff --git a/Objects/private/primitives/TypeObject.cpp b/Objects/private/primitives/TypeObject.cpp index 98fced2..20f4dba 100644 --- a/Objects/private/primitives/TypeObject.cpp +++ b/Objects/private/primitives/TypeObject.cpp @@ -2,8 +2,8 @@ #include "primitives/TypeObject.hpp" #include "primitives/NullObject.hpp" -using namespace obj; using namespace tp; +using namespace obj; TypeObject* TypeObject::create(const ObjectType* type) { NDO_CASTV(TypeObject, NDO->create("typeobject"), out); diff --git a/Objects/public/compiler/Constants.hpp b/Objects/public/compiler/Constants.hpp index 143a393..4f1cda4 100644 --- a/Objects/public/compiler/Constants.hpp +++ b/Objects/public/compiler/Constants.hpp @@ -1,45 +1,42 @@ - #pragma once -#include "interpreter/ByteCode.hpp" #include "core/Object.hpp" +#include "interpreter/ByteCode.hpp" -namespace obj { - namespace BCgen { +namespace tp::obj { - class ConstObject { - public: - obj::Object* mObj = nullptr; - tp::alni mConstIdx = 0; + class ConstObject { + public: + Object* mObj = nullptr; + alni mConstIdx = 0; - ConstObject(); - ConstObject(obj::Object* mObj); - }; - - - class ConstObjectsPool { - public: - tp::Map mMethods; - tp::Map mStrings; - tp::Map mIntegers; - tp::Map mFloats; - ConstObject mBoolTrue; - ConstObject mBoolFalse; - - bool mDelete = true; - tp::alni mTotalObjects = 0; - - ConstObject* get(tp::alni val); - ConstObject* get(const std::string& val); - ConstObject* get(tp::alnf val); - ConstObject* get(bool val); - - ConstObject* addMethod(const std::string& method_id, obj::Object* method); - ConstObject* registerObject(obj::Object* obj); - void save(tp::Buffer& out); - - ConstObjectsPool() = default; - ~ConstObjectsPool(); - }; + ConstObject(); + ConstObject(Object* mObj); }; -}; \ No newline at end of file + + + class ConstObjectsPool { + public: + Map mMethods; + Map mStrings; + Map mIntegers; + Map mFloats; + ConstObject mBoolTrue; + ConstObject mBoolFalse; + + bool mDelete = true; + alni mTotalObjects = 0; + + ConstObject* get(alni val); + ConstObject* get(const std::string& val); + ConstObject* get(alnf val); + ConstObject* get(bool val); + + ConstObject* addMethod(const std::string& method_id, Object* method); + ConstObject* registerObject(Object* obj); + void save(Buffer& out); + + ConstObjectsPool() = default; + ~ConstObjectsPool(); + }; +} \ No newline at end of file diff --git a/Objects/public/compiler/Expressions.hpp b/Objects/public/compiler/Expressions.hpp index bed6c67..903ddc6 100644 --- a/Objects/public/compiler/Expressions.hpp +++ b/Objects/public/compiler/Expressions.hpp @@ -1,12 +1,10 @@ - #pragma once -#include #include "Buffer.hpp" - #include "interpreter/OperatoinCodes.hpp" +#include -namespace obj::BCgen { +namespace tp::obj { struct Expression { enum class Type { @@ -33,26 +31,26 @@ namespace obj::BCgen { }; struct ExpressionList : public Expression { - tp::Buffer mItems; + Buffer mItems; ExpressionList(); ~ExpressionList() override; }; struct ExpressionNew : public Expression { std::string mNewType; - explicit ExpressionNew(const std::string& type); + explicit ExpressionNew(std::string type); ~ExpressionNew() override; }; struct ExpressionLocal : public Expression { std::string mLocalId; - explicit ExpressionLocal(const std::string& id); + explicit ExpressionLocal(std::string id); ~ExpressionLocal() override; }; struct ExpressionFunc : public Expression { std::string mFuncId; - explicit ExpressionFunc(const std::string& id); + explicit ExpressionFunc(std::string id); ~ExpressionFunc() override; }; @@ -60,7 +58,7 @@ namespace obj::BCgen { Expression* mParent = nullptr; std::string mLocalId; bool mMethod = false; - ExpressionChild(Expression* mParent, const std::string& id); + ExpressionChild(Expression* mParent, std::string id); ~ExpressionChild() override; }; @@ -83,7 +81,7 @@ namespace obj::BCgen { Expression* mLeft = nullptr; Expression* mRight = nullptr; - enum class BoolType : tp::uint1 { + enum class BoolType : uint1 { AND = 24U, OR, EQUAL, @@ -103,16 +101,16 @@ namespace obj::BCgen { struct ExpressionConst : public Expression { enum ConstType { STR, INT, BOOL, FLT } mConstType; std::string str; - tp::alni integer = 0; - tp::alnf floating = 0; + alni integer = 0; + alnf floating = 0; bool boolean = false; - explicit ExpressionConst(const std::string& val); + explicit ExpressionConst(std::string val); explicit ExpressionConst(const char* val); - explicit ExpressionConst(tp::alni val); - explicit ExpressionConst(tp::int4 val); - explicit ExpressionConst(tp::flt4 val); - explicit ExpressionConst(tp::alnf val); + explicit ExpressionConst(alni val); + explicit ExpressionConst(int4 val); + explicit ExpressionConst(flt4 val); + explicit ExpressionConst(alnf val); explicit ExpressionConst(bool val); ~ExpressionConst() override; diff --git a/Objects/public/compiler/Functions.hpp b/Objects/public/compiler/Functions.hpp index 56ec7c6..46b54dd 100644 --- a/Objects/public/compiler/Functions.hpp +++ b/Objects/public/compiler/Functions.hpp @@ -1,7 +1,5 @@ - #pragma once -#include #include "List.hpp" #include "Map.hpp" @@ -9,39 +7,38 @@ #include "Statements.hpp" #include "Constants.hpp" -namespace obj { +#include + +namespace tp::obj { struct MethodObject; - namespace BCgen { + struct FunctionDefinition { - struct FunctionDefinition { - - FunctionDefinition* mPrnt = nullptr; + FunctionDefinition* mPrnt = nullptr; - // signature - std::string mFunctionId; - tp::List mArgsOrder; + // signature + std::string mFunctionId; + List mArgsOrder; - ConstObjectsPool mConstants; - tp::Map mLocals; - tp::List mInstructions; + ConstObjectsPool mConstants; + Map mLocals; + List mInstructions; - FunctionDefinition(const std::string& function_id, tp::Buffer args, FunctionDefinition* prnt); - FunctionDefinition() {} + FunctionDefinition(const std::string& function_id, const Buffer& args, FunctionDefinition* prnt); + FunctionDefinition() {} - void generateByteCode(ByteCode& out); + void generateByteCode(ByteCode& out); - tp::List::Node* inst(Instruction inst); - - void EvalExpr(Expression* expr); - void EvalStatement(Statement* expr); + List::Node* inst(Instruction inst); - ConstObject* defineLocal(const std::string& id); - }; + void EvalExpr(Expression* expr); + void EvalStatement(Statement* expr); - void init(); - void deinit(); - void Genereate(ByteCode& out, StatementScope* body); - bool Compile(MethodObject* obj); + ConstObject* defineLocal(const std::string& id); }; -}; \ No newline at end of file + + void initialize(); + void finalize(); + void Generate(ByteCode& out, StatementScope* body); + bool Compile(MethodObject* obj); +} \ No newline at end of file diff --git a/Objects/public/compiler/Instructions.hpp b/Objects/public/compiler/Instructions.hpp index 83346a2..c97d1b7 100644 --- a/Objects/public/compiler/Instructions.hpp +++ b/Objects/public/compiler/Instructions.hpp @@ -2,52 +2,47 @@ #pragma once #include "interpreter/OperatoinCodes.hpp" - #include "core/Object.hpp" - #include "List.hpp" -namespace obj { - namespace BCgen { +namespace tp::obj { + class ConstObject; - class ConstObject; + class Instruction { + public: - class Instruction { - public: + OpCode mOp = OpCode::NONE; - OpCode mOp = OpCode::NONE; + enum class ArgType : ualni { + NO_ARG, + PARAM, + CONST_ARG, + } mArgType = ArgType::NO_ARG; - enum class ArgType : tp::ualni { - NO_ARG, - PARAM, - CONST_ARG, - } mArgType = ArgType::NO_ARG; + enum class InstType : ualni { + NONE, + JUMP, + JUMP_IF, + JUMP_IF_NOT, + EXEC, + PURE_CONST, + } mInstType = InstType::NONE; - enum class InstType : tp::ualni { - NONE, - JUMP, - JUMP_IF, - JUMP_IF_NOT, - EXEC, - PURE_CONST, - } mInstType = InstType::NONE; + alni mParam = 0; + alni mParamBytes = 1; - tp::alni mParam = 0; - tp::alni mParamBytes = 1; + ConstObject* mConstData = nullptr; + ConstObject* mConstData2 = nullptr; - ConstObject* mConstData = nullptr; - ConstObject* mConstData2 = nullptr; + alni mInstIdx = 0; + Instruction* mInstTarget = nullptr; - tp::alni mInstIdx = 0; - Instruction* mInstTarget = nullptr; - - Instruction(); - Instruction(ConstObject* constData); - Instruction(OpCode op); - Instruction(OpCode op, ConstObject* constData); - Instruction(OpCode op, ConstObject* constData, ConstObject* constData2); - Instruction(OpCode op, tp::alni param, tp::alni nBytes); - Instruction(Instruction* inst, InstType jump_type); - }; + Instruction(); + Instruction(ConstObject* constData); + Instruction(OpCode op); + Instruction(OpCode op, ConstObject* constData); + Instruction(OpCode op, ConstObject* constData, ConstObject* constData2); + Instruction(OpCode op, alni param, alni nBytes); + Instruction(Instruction* inst, InstType jump_type); }; -}; \ No newline at end of file +} diff --git a/Objects/public/compiler/Statements.hpp b/Objects/public/compiler/Statements.hpp index 2a4703c..312d23e 100644 --- a/Objects/public/compiler/Statements.hpp +++ b/Objects/public/compiler/Statements.hpp @@ -3,7 +3,7 @@ #include "Expressions.hpp" -namespace obj::BCgen { +namespace tp::obj { struct Statement { enum class Type { @@ -28,15 +28,15 @@ namespace obj::BCgen { }; struct StatementScope : public Statement { - tp::Buffer mStatements; + Buffer mStatements; bool mPushToScopeStack = false; - StatementScope(tp::InitialierList statements, bool aPushToScopeStack); + StatementScope(InitialierList statements, bool aPushToScopeStack); ~StatementScope() override; }; struct StatementFuncDef : public Statement { - tp::Buffer mArgs; + Buffer mArgs; std::string mFunctionId; StatementScope* mStatements = nullptr; @@ -50,7 +50,7 @@ namespace obj::BCgen { ExpressionConst* mConstExpr = nullptr; bool mIsConstExpr = false; - StatementLocalDef(const std::string& id, Expression* value); + StatementLocalDef(std::string id, Expression* value); ~StatementLocalDef() override; }; diff --git a/Objects/public/core/Object.hpp b/Objects/public/core/Object.hpp index accd6d9..e83963b 100644 --- a/Objects/public/core/Object.hpp +++ b/Objects/public/core/Object.hpp @@ -10,12 +10,12 @@ #include "core/TypeGroups.hpp" #include "core/TypeMethods.hpp" -#include "Archiver.hpp" +#include "ObjectArchiver.hpp" #include "SizeCounter.hpp" #include -//#include "interpreter/interpreter.h" +#include "core/ObjectArchiver.hpp" /* Steps to create custom Object: define name of object @@ -37,80 +37,29 @@ implement construct, destruct and copy methods */ #define NDO_MEMH_FROM_NDO(ndo_ptr) (((ObjectMemHead*)ndo_ptr) - 1) #define NDO_FROM_MEMH(ndo_ptr) ((Object*)(ndo_ptr + 1)) -namespace obj { +namespace tp::obj { - - template - class Archiver : public tp::ArchiverTemplate { - tp::LocalConnection mConnection; - tp::ualni mAddress = 0; - tp::ualni mFirstNotWritten = 0; - - public: - Archiver() = default; - explicit Archiver(const char* location) { - mConnection.connect(tp::LocalConnection::Location(location), tp::LocalConnection::Type(tRead)); - }; - - void writeBytes(const tp::int1* val, tp::ualni size) override { - mConnection.setPointer(mAddress); - mConnection.writeBytes(val, size); - incrementAddresses(size); - } - - void readBytes(tp::int1* val, tp::ualni size) override { - mConnection.setPointer(mAddress); - mConnection.readBytes(val, size); - incrementAddresses(size); - } - - tp::ualni getAddress() { return mAddress; } - - void setAddress(tp::ualni addr) { mAddress = addr; } - - tp::ualni getFreeAddress() { return mFirstNotWritten; } - - void setFreeAddress(tp::ualni addr) { mFirstNotWritten = addr; } - - bool isOpened() { return mConnection.getConnectionStatus().isOpened(); } - - tp::ualni getSize() { return mConnection.size(); } - - private: - void incrementAddresses(tp::ualni size) { - // if (mAddress + size > mFirstNotWritten) mFirstNotWritten = mAddress + size; - mAddress += size; - } - }; - - using ArchiverIn = Archiver; - using ArchiverOut = Archiver; - - void save_string(ArchiverOut& file, const std::string& string); - tp::ualni save_string_size(const std::string& string); - void load_string(ArchiverIn& file, std::string& out); - - extern tp::ModuleManifest gModuleObjects; + extern ModuleManifest gModuleObjects; extern struct objects_api* NDO; struct ObjectMemHead { ObjectMemHead* up; ObjectMemHead* down; - tp::alni flags; - tp::alni refc; + alni flags; + alni refc; }; struct Object { const struct ObjectType* type; }; - typedef void (*object_from_int)(Object* self, tp::alni in); - typedef void (*object_from_float)(Object* self, tp::alnf in); + typedef void (*object_from_int)(Object* self, alni in); + typedef void (*object_from_float)(Object* self, alnf in); typedef void (*object_from_string)(Object* self, const std::string& in); typedef std::string(*object_to_string)(Object* self); - typedef tp::alni(*object_to_int)(Object* self); - typedef tp::alnf(*object_to_float)(Object* self); + typedef alni(*object_to_int)(Object* self); + typedef alnf(*object_to_float)(Object* self); struct ObjectTypeConversions { object_from_int from_int; @@ -137,22 +86,22 @@ namespace obj { typedef void (*object_destructor)(Object* self); typedef void (*object_copy)(Object* self, const Object* target); - typedef tp::alni(*object_save_size)(Object* self); + typedef alni(*object_save_size)(Object* self); typedef void (*object_save)(Object*, ArchiverOut&); typedef void (*object_load)(ArchiverIn&, Object*); typedef bool (*object_compare)(Object*, Object*); - typedef tp::Buffer (*object_debug_all_childs_retrival)(Object*); - typedef tp::alni (*object_allocated_size)(Object*); // default value = type->size - sizeof(ObjectType*) - typedef tp::alni (*object_allocated_size_recursive)(Object*); // default value = object_allocated_size + typedef Buffer (*object_debug_all_childs_retrival)(Object*); + typedef alni (*object_allocated_size)(Object*); // default value = type->size - sizeof(ObjectType*) + typedef alni (*object_allocated_size_recursive)(Object*); // default value = object_allocated_size struct ObjectType { const ObjectType* base = nullptr; object_constructor constructor = nullptr; object_destructor destructor = nullptr; object_copy copy = nullptr; - tp::alni size = 0; + alni size = 0; const char* name; const ObjectTypeConversions* convesions = nullptr; const ObjectTypeAriphmetics* ariphmetics = nullptr; @@ -174,7 +123,7 @@ namespace obj { typedef void (pre_load_callback)(void* self, ArchiverIn&); typedef void (post_save_callback)(void* self, ArchiverOut&); typedef void (post_load_callback)(void* self, ArchiverIn&); - typedef tp::alni (slcb_size_callback)(void* self, ArchiverOut&); + typedef alni (slcb_size_callback)(void* self, ArchiverOut&); struct save_load_callbacks { void* self; @@ -188,8 +137,8 @@ namespace obj { struct objects_api { - tp::Map types; - obj::TypeGroups type_groups; + Map types; + TypeGroups type_groups; Interpreter* interp = nullptr; objects_api(); @@ -197,54 +146,54 @@ namespace obj { void define(ObjectType* type); Object* create(const std::string& name); - Object* copy(Object* self, const Object* in); - bool compare(Object* first, Object* second); - Object* instatiate(Object*); - void set(Object* self, tp::alni val); - void set(Object* self, tp::alnf val); - void set(Object* self, const std::string& val); + static Object* copy(Object* self, const Object* in); + static bool compare(Object* first, Object* second); + static Object* instantiate(Object*); + static void set(Object* self, alni val); + static void set(Object* self, alnf val); + static void set(Object* self, const std::string& val); - tp::alni toInt(Object* self); - tp::alnf toFloat(Object* self); - bool toBool(Object* self); - std::string toString(Object* self); + static alni toInt(Object* self); + static alnf toFloat(Object* self); + static bool toBool(Object* self); + static std::string toString(Object* self); void clear_object_flags(); - void destroy(Object* in); + void destroy(Object* in) const; - void refinc(Object* in); - tp::halni getrefc(Object* in); + static void increaseReferenceCount(Object* in); + static halni getReferenceCount(Object* in); private: - void setrefc(Object* in, tp::halni refc); + static void setReferenceCount(Object* in, halni count); public: - save_load_callbacks* sl_callbacks[SAVE_LOAD_MAX_CALLBACK_SLOTS]; - tp::alni sl_callbacks_load_idx = 0; + save_load_callbacks* sl_callbacks[SAVE_LOAD_MAX_CALLBACK_SLOTS]{}; + alni sl_callbacks_load_idx = 0; void add_sl_callbacks(save_load_callbacks*); - tp::alni objsize_file(Object* self); - tp::alni objsize_file_recursive(Object* self); + alni objsize_file(Object* self); + alni objsize_file_recursive(Object* self); - tp::alni objsize_ram(Object* self); - tp::alni objsize_ram_recursive_util(Object* self, const ObjectType* type, bool different_object = true); - tp::alni objsize_ram_recursive(Object* self); + alni objsize_ram(Object* self); + alni objsize_ram_recursive_util(Object* self, const ObjectType* type, bool different_object = true); + alni objsize_ram_recursive(Object* self); bool save(Object*, const std::string& path, bool compressed = true); Object* load(const std::string& path); - tp::alni save(ArchiverOut&, Object*); - Object* load(ArchiverIn&, tp::alni file_adress); + alni save(ArchiverOut&, Object*); + Object* load(ArchiverIn&, alni file_adress); }; void logTypeData(const ObjectType* type); void assertNoLeaks(); - tp::ualni getObjCount(); + ualni getObjCount(); Object* ndo_cast(const Object* in, const ObjectType* to_type); template Type* create() { - return (Type*)obj::NDO->create(Type::TypeData.name); + return (Type*)NDO->create(Type::TypeData.name); } -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/core/ObjectArchiver.hpp b/Objects/public/core/ObjectArchiver.hpp new file mode 100644 index 0000000..65ca203 --- /dev/null +++ b/Objects/public/core/ObjectArchiver.hpp @@ -0,0 +1,56 @@ +#pragma once + +#include "ObjectArchiver.hpp" +#include "LocalConnection.hpp" + +namespace tp::obj { + template + class Archiver : public ArchiverTemplate { + LocalConnection mConnection; + ualni mAddress = 0; + ualni mFirstNotWritten = 0; + + public: + Archiver() = default; + explicit Archiver(const char* location) { + mConnection.connect(LocalConnection::Location(location), LocalConnection::Type(tRead)); + }; + + void writeBytes(const int1* val, ualni size) override { + mConnection.setPointer(mAddress); + mConnection.writeBytes(val, size); + incrementAddresses(size); + } + + void readBytes(int1* val, ualni size) override { + mConnection.setPointer(mAddress); + mConnection.readBytes(val, size); + incrementAddresses(size); + } + + ualni getAddress() { return mAddress; } + + void setAddress(ualni addr) { mAddress = addr; } + + ualni getFreeAddress() { return mFirstNotWritten; } + + void setFreeAddress(ualni addr) { mFirstNotWritten = addr; } + + bool isOpened() { return mConnection.getConnectionStatus().isOpened(); } + + ualni getSize() { return mConnection.size(); } + + private: + void incrementAddresses(ualni size) { + // if (mAddress + size > mFirstNotWritten) mFirstNotWritten = mAddress + size; + mAddress += size; + } + }; + + using ArchiverIn = Archiver; + using ArchiverOut = Archiver; + + void save_string(ArchiverOut& file, const std::string& string); + ualni save_string_size(const std::string& string); + void load_string(ArchiverIn& file, std::string& out); +} \ No newline at end of file diff --git a/Objects/public/core/ScriptSection.hpp b/Objects/public/core/ScriptSection.hpp index d4fcf03..cae0f4c 100644 --- a/Objects/public/core/ScriptSection.hpp +++ b/Objects/public/core/ScriptSection.hpp @@ -2,19 +2,19 @@ #include "primitives/MethodObject.hpp" -namespace obj { +namespace tp::obj { // global singleton API for method object to manage the script struct ScriptSection { - tp::List mScripts; + List mScripts; Script* createScript(); void changeScript(Script** current_script, Script** new_script); void abandonScript(Script* script); - tp::alni get_script_file_adress(Script* in); - Script* get_scritp_from_file_adress(tp::alni file_adress); + alni get_script_file_adress(Script* in); + Script* get_scritp_from_file_adress(alni file_adress); ~ScriptSection(); @@ -31,6 +31,6 @@ namespace obj { static void save_script_table_to_file(ScriptSection* self, ArchiverOut& file); static void load_script_table_from_file(ScriptSection* self, ArchiverIn& file); - static tp::alni save_script_table_to_file_size(ScriptSection* self, ArchiverOut& file); + static alni save_script_table_to_file_size(ScriptSection* self, ArchiverOut& file); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/core/TypeGroups.hpp b/Objects/public/core/TypeGroups.hpp index b230925..bf2ac6f 100644 --- a/Objects/public/core/TypeGroups.hpp +++ b/Objects/public/core/TypeGroups.hpp @@ -4,7 +4,7 @@ #include "Map.hpp" #include -namespace obj { +namespace tp::obj { struct ObjectType; struct objects_api; @@ -13,15 +13,15 @@ namespace obj { public: - typedef tp::Map Dict; + typedef Map Dict; TypeGroups(); - friend struct obj::objects_api; + friend struct objects_api; explicit TypeGroups(bool is_group); - void addType(ObjectType* type, tp::InitialierList path, tp::alni cur_arg = 0); + void addType(ObjectType* type, InitialierList path, alni cur_arg = 0); void setType(ObjectType* type); bool isGroup(); Dict* getChilds(); @@ -36,5 +36,4 @@ namespace obj { const obj::ObjectType* type; }; }; - -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/core/TypeMethods.hpp b/Objects/public/core/TypeMethods.hpp index 59c659f..fff4a18 100644 --- a/Objects/public/core/TypeMethods.hpp +++ b/Objects/public/core/TypeMethods.hpp @@ -4,7 +4,7 @@ #include "Buffer.hpp" #include -namespace obj { +namespace tp::obj { struct Interpreter; struct Object; @@ -23,7 +23,7 @@ namespace obj { mutable Object* self = nullptr; Arg args[MAX_ARGS]; - tp::int1 mNargs = 0; + int1 mNargs = 0; void (*exec)(const TypeMethod* tm) = nullptr; @@ -37,14 +37,14 @@ namespace obj { extern TypeMethod gDefaultTypeMethods[3]; struct TypeMethods { - enum : tp::int2 { MAX_TYPE_METHODS = 128 }; + enum : int2 { MAX_TYPE_METHODS = 128 }; TypeMethod* methods[MAX_TYPE_METHODS]; - tp::halni mNMethods = 0; + halni mNMethods = 0; struct LookupKey { - tp::int2 key = -1; - tp::int2 type_depth = -1; + int2 key = -1; + int2 type_depth = -1; operator bool() { return key != -1; } }; @@ -53,11 +53,10 @@ namespace obj { void init(); - tp::halni nMethods() const; + halni nMethods() const; private: - tp::int2 presents(const std::string&) const; - const TypeMethod* getMethod(tp::int2) const; + int2 presents(const std::string&) const; + const TypeMethod* getMethod(int2) const; }; - -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/interpreter/ByteCode.hpp b/Objects/public/interpreter/ByteCode.hpp index e20dcd5..46aeaf0 100644 --- a/Objects/public/interpreter/ByteCode.hpp +++ b/Objects/public/interpreter/ByteCode.hpp @@ -9,15 +9,15 @@ #include "Buffer.hpp" #include -namespace obj { +namespace tp::obj { typedef Object* ConstData; struct ByteCode { - tp::Buffer mConstants; - tp::Buffer mInstructions; - tp::ualni mInstructionIdx = 0; - tp::ualni mArgumentsLoaded = 0; + Buffer mConstants; + Buffer mInstructions; + ualni mInstructionIdx = 0; + ualni mArgumentsLoaded = 0; ~ByteCode() { for (auto const_obj : mConstants) { @@ -25,4 +25,4 @@ namespace obj { } } }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/interpreter/CallStack.hpp b/Objects/public/interpreter/CallStack.hpp index bad8aeb..88f7281 100644 --- a/Objects/public/interpreter/CallStack.hpp +++ b/Objects/public/interpreter/CallStack.hpp @@ -5,11 +5,8 @@ #include "Map.hpp" -namespace obj { +namespace tp::obj { struct MethodObject; -}; - -namespace obj { struct ByteCode; @@ -17,16 +14,16 @@ namespace obj { struct CallFrame { enum { CALL_DEPTH = 1024 }; - obj::Object* mSelf = nullptr; - obj::MethodObject* mMethod = nullptr; - tp::ualni mIp = 0; + Object* mSelf = nullptr; + MethodObject* mMethod = nullptr; + ualni mIp = 0; }; void enter(const CallFrame& frame); void leave(); ByteCode* getBytecode(); - [[nodiscard]] tp::halni len() const; + [[nodiscard]] halni len() const; - tp::ConstSizeBuffer mStack; + ConstSizeBuffer mStack; }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/interpreter/Interpreter.hpp b/Objects/public/interpreter/Interpreter.hpp index cbdae4c..98fad8c 100644 --- a/Objects/public/interpreter/Interpreter.hpp +++ b/Objects/public/interpreter/Interpreter.hpp @@ -4,19 +4,19 @@ #include "ScopeStack.hpp" #include "CallStack.hpp" -namespace obj { +namespace tp::obj { struct Interpreter { OperandStack mOperandsStack; ScopeStack mScopeStack; CallStack mCallStack; - obj::Object* mLastParent = nullptr; + Object* mLastParent = nullptr; bool mIsTypeMethod = false; const TypeMethod* mTypeMethod = nullptr; - typedef struct { obj::Object* obj; std::string id; } GlobalDef; + typedef struct { Object* obj; std::string id; } GlobalDef; - void exec(obj::MethodObject* method, obj::ClassObject* self = nullptr, obj::DictObject* globals = nullptr, tp::InitialierList globals2 = {}); + void exec(MethodObject* method, ClassObject* self = nullptr, DictObject* globals = nullptr, InitialierList globals2 = {}); void stepBytecode(); void stepBytecodeIn(); @@ -24,6 +24,6 @@ namespace obj { bool finished(); - void execAll(obj::MethodObject* method, obj::ClassObject* self = nullptr, obj::DictObject* globals = nullptr, tp::InitialierList globals2 = {}); + void execAll(MethodObject* method, ClassObject* self = nullptr, DictObject* globals = nullptr, InitialierList globals2 = {}); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/interpreter/OperandsStack.hpp b/Objects/public/interpreter/OperandsStack.hpp index 3722d15..be3ab4d 100644 --- a/Objects/public/interpreter/OperandsStack.hpp +++ b/Objects/public/interpreter/OperandsStack.hpp @@ -3,21 +3,21 @@ #include "ByteCode.hpp" #include "core/Object.hpp" -namespace obj { +namespace tp::obj { // can be other aligned value as well - typedef obj::Object* Operand; + typedef Object* Operand; class OperandStack { - enum : tp::alni { + enum : alni { MAX_STACK_SIZE = 512 }; public: Operand* mBuff; - tp::ualni mIdx; + ualni mIdx; OperandStack(); void push(Operand operand); @@ -35,5 +35,4 @@ namespace obj { ~OperandStack(); }; - -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/interpreter/OperatoinCodes.hpp b/Objects/public/interpreter/OperatoinCodes.hpp index e77092b..054c243 100644 --- a/Objects/public/interpreter/OperatoinCodes.hpp +++ b/Objects/public/interpreter/OperatoinCodes.hpp @@ -12,11 +12,11 @@ // 2) Index of bytecode->ConstData from bytecode->Instruction (ConstData) // 3) Raw Bytes from bytecode->Instruction (Param) -namespace obj { +namespace tp::obj { extern struct OpcodeInfos gOpcodeInfos; - enum class OpCode : tp::uint1 { + enum class OpCode : uint1 { NONE = 0x00, HALT, @@ -118,24 +118,24 @@ namespace obj { enum { MAX_OPERANDS = 5 }; Operand buff[MAX_OPERANDS]; - tp::halni len = 0; + halni len = 0; OperandsInfo(); - OperandsInfo(tp::InitialierList list); + OperandsInfo(InitialierList list); }; struct ParamsInfo { struct Param { const char* desc = nullptr; - tp::halni bytes = 1; + halni bytes = 1; }; enum { MAX_PARAMS = 5 }; Param buff[MAX_PARAMS]; - tp::halni len = 0; + halni len = 0; ParamsInfo(); - ParamsInfo(tp::InitialierList list); + ParamsInfo(InitialierList list); }; struct OpInfo { @@ -144,14 +144,14 @@ namespace obj { OperandsInfo operands; ParamsInfo params; - tp::uint1 opsize(); + uint1 opsize(); }; OpcodeInfos(); OpInfo fetch(OpCode code); private: - OpInfo buff[(tp::alni)OpCode::END_OPCODES]; + OpInfo buff[(alni)OpCode::END_OPCODES]; void add(OpCode code, const OpInfo& info); }; diff --git a/Objects/public/interpreter/ScopeStack.hpp b/Objects/public/interpreter/ScopeStack.hpp index 342e3c2..a02c34c 100644 --- a/Objects/public/interpreter/ScopeStack.hpp +++ b/Objects/public/interpreter/ScopeStack.hpp @@ -3,11 +3,11 @@ #include "core/Object.hpp" #include "Map.hpp" -namespace obj { +namespace tp::obj { struct Scope { - typedef tp::Map ObjDict; - typedef tp::List ObjList; + typedef Map ObjDict; + typedef List ObjList; ObjDict mLocals; ObjList mTemps; @@ -18,29 +18,28 @@ namespace obj { class ScopeStack { - enum : tp::alni { + enum : alni { MAX_STACK_SIZE = 1024 * 4 }; public: Scope* mBuff; - tp::ualni mIdx; - tp::ualni mIterIdx; + ualni mIdx; + ualni mIterIdx; ScopeStack(); void enterScope(bool aChildReachable); void leaveScope(); - void addLocal(obj::Object* local, const std::string& id); - void addTemp(obj::Object* tmp); + void addLocal(Object* local, const std::string& id); + void addTemp(Object* tmp); void popTemp(); - void addTempReturn(obj::Object* ret); - obj::Object* getLocal(const std::string& str); + void addTempReturn(Object* ret); + Object* getLocal(const std::string& str); Scope* getCurrentScope(); ~ScopeStack(); private: - obj::Object* getLocalUtil(Scope& scope, const std::string& id); + Object* getLocalUtil(Scope& scope, const std::string& id); }; - -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/interpreter/Script.hpp b/Objects/public/interpreter/Script.hpp index d7624e5..02a8f2d 100644 --- a/Objects/public/interpreter/Script.hpp +++ b/Objects/public/interpreter/Script.hpp @@ -2,11 +2,11 @@ #include "interpreter/ByteCode.hpp" -namespace obj { +namespace tp::obj { struct Script { - obj::StringObject* mReadable; + StringObject* mReadable; ByteCode mBytecode; void compile(); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/parser/Parser.hpp b/Objects/public/parser/Parser.hpp index 9337c23..d5b0218 100644 --- a/Objects/public/parser/Parser.hpp +++ b/Objects/public/parser/Parser.hpp @@ -3,20 +3,20 @@ #include "compiler/Statements.hpp" #include "compiler/Expressions.hpp" -namespace obj { +namespace tp::obj { class Parser { public: Parser() = default; struct Result { - obj::BCgen::StatementScope* scope = nullptr; + StatementScope* scope = nullptr; bool isError = false; std::string description; - tp::halni line = 0; - tp::halni column = 0; + halni line = 0; + halni column = 0; }; Result parse(const std::string& stream); }; -}; +} diff --git a/Objects/public/primitives/BoolObject.hpp b/Objects/public/primitives/BoolObject.hpp index 117b36c..a805dc8 100644 --- a/Objects/public/primitives/BoolObject.hpp +++ b/Objects/public/primitives/BoolObject.hpp @@ -3,10 +3,10 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { struct BoolObject : Object { - tp::alni val; + alni val; static ObjectType TypeData; static void constructor(BoolObject* self); @@ -14,11 +14,11 @@ namespace obj { static BoolObject* create(bool in); - static void from_int(BoolObject* self, tp::alni in); - static void from_float(BoolObject* self, tp::alnf in); + static void from_int(BoolObject* self, alni in); + static void from_float(BoolObject* self, alnf in); static void from_string(BoolObject* self, const std::string& in); static std::string to_string(BoolObject* self); - static tp::alni to_int(BoolObject* self); - static tp::alnf to_float(BoolObject* self); + static alni to_int(BoolObject* self); + static alnf to_float(BoolObject* self); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/ClassObject.hpp b/Objects/public/primitives/ClassObject.hpp index 17cd917..056db5f 100644 --- a/Objects/public/primitives/ClassObject.hpp +++ b/Objects/public/primitives/ClassObject.hpp @@ -2,7 +2,7 @@ #include "primitives/DictObject.hpp" -namespace obj { +namespace tp::obj { struct ClassObject : Object { @@ -10,7 +10,7 @@ namespace obj { static void copy(ClassObject* self, const ClassObject* in); static void destructor(ClassObject* self); static void constructor(ClassObject* self); - static tp::alni save_size(ClassObject* self); + static alni save_size(ClassObject* self); static void save(ClassObject* self, ArchiverOut& file_self); static void load(ArchiverIn& file_self, ClassObject* self); @@ -31,7 +31,7 @@ namespace obj { Type* getMember(const std::string& id) { auto idx = members->presents(id); if (bool(idx)) { - return ((Type*)obj::ndo_cast(members->getSlotVal(idx), &Type::TypeData)); + return ((Type*)ndo_cast(members->getSlotVal(idx), &Type::TypeData)); } return NULL; } @@ -43,4 +43,4 @@ namespace obj { return out; } }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/ColorObject.hpp b/Objects/public/primitives/ColorObject.hpp index d24ec38..8ebb243 100644 --- a/Objects/public/primitives/ColorObject.hpp +++ b/Objects/public/primitives/ColorObject.hpp @@ -4,10 +4,10 @@ #include "core/Object.hpp" #include "Color.hpp" -namespace obj { +namespace tp::obj { struct ColorObject : Object { - tp::RGBA mCol; + RGBA mCol; static ObjectType TypeData; static ObjectTypeAriphmetics TypeAriphm; @@ -15,10 +15,10 @@ namespace obj { static void constructor(Object* self); static void copy(ColorObject* self, const ColorObject* in); - static void from_int(ColorObject* self, tp::alni in); - static void from_float(ColorObject* self, tp::alnf in); + static void from_int(ColorObject* self, alni in); + static void from_float(ColorObject* self, alnf in); static std::string to_string(ColorObject* self); - static ColorObject* create(tp::RGBA in); + static ColorObject* create(RGBA in); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/DictObject.hpp b/Objects/public/primitives/DictObject.hpp index 9846cf4..4f2f8f2 100644 --- a/Objects/public/primitives/DictObject.hpp +++ b/Objects/public/primitives/DictObject.hpp @@ -2,7 +2,7 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { struct DictObject : Object { static ObjectType TypeData; @@ -10,22 +10,22 @@ namespace obj { static void destructor(Object* self); static void constructor(Object* self); - static tp::alni save_size(DictObject* self); + static alni save_size(DictObject* self); static void save(DictObject* self, ArchiverOut& file_self); static void load(ArchiverIn& file_self, DictObject* self); - static tp::Buffer childs_retrival(DictObject* self); - static tp::alni allocated_size(DictObject* self); - static tp::alni allocated_size_recursive(DictObject* self); + static Buffer childs_retrival(DictObject* self); + static alni allocated_size(DictObject* self); + static alni allocated_size_recursive(DictObject* self); void put(const std::string&, Object*); void remove(const std::string&); Object* get(const std::string&); - tp::Map::Idx presents(const std::string&); - Object* getSlotVal(tp::Map::Idx); + Map::Idx presents(const std::string&); + Object* getSlotVal(Map::Idx); - [[nodiscard]] const tp::Map& getItems() const; + [[nodiscard]] const Map& getItems() const; private: - tp::Map items; + Map items; }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/EnumObject.hpp b/Objects/public/primitives/EnumObject.hpp index 6db388d..0e49f0a 100644 --- a/Objects/public/primitives/EnumObject.hpp +++ b/Objects/public/primitives/EnumObject.hpp @@ -3,32 +3,32 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { struct EnumObject : Object { // one entry is 2 * sizeof(alni) in size - tp::uhalni active; - tp::uhalni nentries; - tp::alni* entries; + uhalni active; + uhalni nentries; + alni* entries; static ObjectType TypeData; static void constructor(EnumObject* self); static void destructor(EnumObject* self); static void copy(EnumObject* self, const EnumObject* in); - void init(tp::InitialierList list); + void init(InitialierList list); const char* getActiveName(); - const char* getItemName(tp::uhalni idx); + const char* getItemName(uhalni idx); - static void from_int(EnumObject* self, tp::alni in); - static void from_float(EnumObject* self, tp::alnf in); + static void from_int(EnumObject* self, alni in); + static void from_float(EnumObject* self, alnf in); static void from_string(EnumObject* self, const std::string& in); static std::string to_string(EnumObject* self); - static tp::alni to_int(EnumObject* self); - static tp::alnf to_float(EnumObject* self); + static alni to_int(EnumObject* self); + static alnf to_float(EnumObject* self); static bool compare(EnumObject* first, EnumObject* second); - static EnumObject* create(tp::InitialierList list); + static EnumObject* create(InitialierList list); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/FloatObject.hpp b/Objects/public/primitives/FloatObject.hpp index d1e2063..c634206 100644 --- a/Objects/public/primitives/FloatObject.hpp +++ b/Objects/public/primitives/FloatObject.hpp @@ -3,10 +3,10 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { struct FloatObject : Object { - tp::alnf val; + alnf val; static ObjectType TypeData; static ObjectTypeAriphmetics TypeAriphm; @@ -14,13 +14,13 @@ namespace obj { static void constructor(FloatObject* self); static void copy(FloatObject* self, const FloatObject* in); - static FloatObject* create(tp::alnf in); + static FloatObject* create(alnf in); - static void from_int(FloatObject* self, tp::alni in); - static void from_float(FloatObject* self, tp::alnf in); + static void from_int(FloatObject* self, alni in); + static void from_float(FloatObject* self, alnf in); static void from_string(FloatObject* self, const std::string& in); static std::string to_string(FloatObject* self); - static tp::alni to_int(FloatObject* self); - static tp::alnf to_float(FloatObject* self); + static alni to_int(FloatObject* self); + static alnf to_float(FloatObject* self); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/IntObject.hpp b/Objects/public/primitives/IntObject.hpp index 0c9d54c..4f8fc6e 100644 --- a/Objects/public/primitives/IntObject.hpp +++ b/Objects/public/primitives/IntObject.hpp @@ -3,23 +3,23 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { struct IntObject : Object { - tp::alni val; + alni val; static ObjectType TypeData; static ObjectTypeAriphmetics TypeAriphm; static void constructor(Object* self); static void copy(IntObject* self, const IntObject* in); - static IntObject* create(tp::alni in); + static IntObject* create(alni in); - static void from_int(Object* self, tp::alni in); - static void from_float(Object* self, tp::alnf in); + static void from_int(Object* self, alni in); + static void from_float(Object* self, alnf in); static void from_string(Object* self, const std::string& in); static std::string to_string(Object* self); - static tp::alni to_int(Object* self); - static tp::alnf to_float(Object* self); + static alni to_int(Object* self); + static alnf to_float(Object* self); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/InterpreterObject.hpp b/Objects/public/primitives/InterpreterObject.hpp index 7312f22..ff13963 100644 --- a/Objects/public/primitives/InterpreterObject.hpp +++ b/Objects/public/primitives/InterpreterObject.hpp @@ -3,7 +3,7 @@ #include "interpreter/Interpreter.hpp" #include "primitives/ClassObject.hpp" -namespace obj { +namespace tp::obj { struct InterpreterObject : ClassObject { static ObjectType TypeData; Interpreter mInterpreter; @@ -12,8 +12,8 @@ namespace obj { static void constructor(InterpreterObject* self); static void load(ArchiverIn& file_self, InterpreterObject* self); - void exec(obj::ClassObject* self = nullptr, tp::InitialierList globals = {}); + void exec(obj::ClassObject* self = nullptr, InitialierList globals = {}); void debug(); bool running(); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/LinkObject.hpp b/Objects/public/primitives/LinkObject.hpp index 9d4340b..0982d73 100644 --- a/Objects/public/primitives/LinkObject.hpp +++ b/Objects/public/primitives/LinkObject.hpp @@ -3,7 +3,7 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { struct LinkObject : Object { static ObjectType TypeData; @@ -12,12 +12,12 @@ namespace obj { static void copy(Object* self, const Object* in); static LinkObject* create(Object* in); - static tp::alni save_size(LinkObject* self); + static alni save_size(LinkObject* self); static void save(LinkObject* self, ArchiverOut& file_self); static void load(ArchiverIn& file_self, LinkObject* self); - static tp::alni allocated_size(LinkObject* self); - static tp::alni allocated_size_recursive(LinkObject* self); - static tp::Buffer childs_retrival(LinkObject* self); + static alni allocated_size(LinkObject* self); + static alni allocated_size_recursive(LinkObject* self); + static Buffer childs_retrival(LinkObject* self); Object* getLink(); void setLink(Object* obj); @@ -25,5 +25,4 @@ namespace obj { private: Object* link; }; - -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/ListObject.hpp b/Objects/public/primitives/ListObject.hpp index dc6be96..ef88821 100644 --- a/Objects/public/primitives/ListObject.hpp +++ b/Objects/public/primitives/ListObject.hpp @@ -3,7 +3,7 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { enum ListMethods { LISTOBJECT_PUSH_BACK, @@ -16,21 +16,21 @@ namespace obj { static void copy(Object* self, const Object* in); static void destructor(Object* self); - static tp::alni allocated_size_recursive(ListObject* self); - static tp::alni allocated_size(ListObject* self); - static tp::Buffer childs_retrival(ListObject* self); + static alni allocated_size_recursive(ListObject* self); + static alni allocated_size(ListObject* self); + static Buffer childs_retrival(ListObject* self); static void load(ArchiverIn& file_self, ListObject* self); static void save(ListObject* self, ArchiverOut& file_self); - static tp::alni save_size(ListObject* self); + static alni save_size(ListObject* self); - [[nodiscard]] const tp::List& getItems() const; + [[nodiscard]] const List& getItems() const; void pushBack(Object* obj); void pushFront(Object* obj); void popBack(); - void delNode(tp::List::Node*); + void delNode(List::Node*); private: - tp::List items; + List items; }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/MethodObject.hpp b/Objects/public/primitives/MethodObject.hpp index 877cd66..3f9f0f2 100644 --- a/Objects/public/primitives/MethodObject.hpp +++ b/Objects/public/primitives/MethodObject.hpp @@ -3,7 +3,7 @@ #include "primitives/StringObject.hpp" #include "interpreter/Script.hpp" -namespace obj { +namespace tp::obj { struct MethodObject : Object { @@ -14,7 +14,7 @@ namespace obj { static void constructor(MethodObject* self); static void copy(MethodObject* self, MethodObject* in); static void destructor(MethodObject* self); - static tp::alni save_size(MethodObject* self); + static alni save_size(MethodObject* self); static void save(MethodObject* self, ArchiverOut& file_self); static void load(ArchiverIn& file_self, obj::MethodObject* self); @@ -25,4 +25,4 @@ namespace obj { static MethodObject* create(const std::string& script); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/NullObject.hpp b/Objects/public/primitives/NullObject.hpp index 3df54bd..b6e4d55 100644 --- a/Objects/public/primitives/NullObject.hpp +++ b/Objects/public/primitives/NullObject.hpp @@ -3,7 +3,7 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { extern struct NullObject* NdoNull_globalInstance; @@ -15,18 +15,18 @@ namespace obj { static Object* null_return() { if (!NdoNull_globalInstance) { NdoNull_globalInstance = (NullObject*) NDO->create("null"); - obj::NDO->refinc(NdoNull_globalInstance); + NDO->increaseReferenceCount(NdoNull_globalInstance); } return (Object*) NdoNull_globalInstance; } static Object* null_return_ref() { - obj::NDO->refinc(null_return()); + NDO->increaseReferenceCount(null_return()); return NdoNull_globalInstance; } }; - #define NDO_NULL obj::NullObject::null_return() - #define NDO_NULL_REF obj::NullObject::null_return_ref() + #define NDO_NULL NullObject::null_return() + #define NDO_NULL_REF NullObject::null_return_ref() -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/StringObject.hpp b/Objects/public/primitives/StringObject.hpp index 7401aca..191d3f7 100644 --- a/Objects/public/primitives/StringObject.hpp +++ b/Objects/public/primitives/StringObject.hpp @@ -3,7 +3,7 @@ #include "core/Object.hpp" -namespace obj { +namespace tp::obj { struct StringObject : Object { std::string val; @@ -14,11 +14,11 @@ namespace obj { static void copy(Object* self, const Object* in); static StringObject* create(const std::string& in); - static void from_int(StringObject* self, tp::alni in); - static void from_float(StringObject* self, tp::alnf in); + static void from_int(StringObject* self, alni in); + static void from_float(StringObject* self, alnf in); static void from_string(StringObject* self, const std::string& in); static std::string to_string(StringObject* self); - static tp::alni to_int(StringObject* self); - static tp::alnf to_float(StringObject* self); + static alni to_int(StringObject* self); + static alnf to_float(StringObject* self); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/public/primitives/TypeObject.hpp b/Objects/public/primitives/TypeObject.hpp index 27ed5e4..df572a2 100644 --- a/Objects/public/primitives/TypeObject.hpp +++ b/Objects/public/primitives/TypeObject.hpp @@ -3,11 +3,10 @@ #include "core/Object.hpp" -namespace obj { - +namespace tp::obj { struct TypeObject : Object { static ObjectType TypeData; const ObjectType* mTypeRef; static TypeObject* create(const ObjectType* type); }; -}; \ No newline at end of file +} \ No newline at end of file diff --git a/Objects/tests/main.cpp b/Objects/tests/main.cpp index 1a4e6e9..90a8dcd 100644 --- a/Objects/tests/main.cpp +++ b/Objects/tests/main.cpp @@ -3,7 +3,7 @@ #include "primitives/PrimitiveObjects.hpp" -tp::ModuleManifest* objDeps[] = { &obj::gModuleObjects, nullptr }; +tp::ModuleManifest* objDeps[] = { &tp::obj::gModuleObjects, nullptr }; tp::ModuleManifest objTestModule("ObjectsTests", nullptr, nullptr, objDeps); #include