From 828096de17ee6d421d6117112f758798d025307d Mon Sep 17 00:00:00 2001 From: IlyaShurupov Date: Wed, 6 Mar 2024 10:47:37 +0300 Subject: [PATCH] tmp --- Objects/private/compiler/expression.cpp | 78 +++++--- Objects/private/compiler/function.cpp | 40 ++--- Objects/private/compiler/statement.cpp | 135 +++++++------- Objects/private/parser/Bindings.cpp | 10 +- Objects/public/compiler/expression.h | 230 ++++++++++++------------ Objects/public/compiler/statement.h | 210 +++++++++++----------- Objects/tests/TestInterpreter.cpp | 3 - Objects/tests/TestParser.cpp | 3 +- Objects/tests/Tests.cpp | 10 +- 9 files changed, 351 insertions(+), 368 deletions(-) diff --git a/Objects/private/compiler/expression.cpp b/Objects/private/compiler/expression.cpp index 2f52faa..6267724 100644 --- a/Objects/private/compiler/expression.cpp +++ b/Objects/private/compiler/expression.cpp @@ -3,32 +3,13 @@ using namespace obj; using namespace BCgen; -Expression::Expression() {} Expression::Expression(Type type) : mType(type) {} -ExpressionChild* Expression::ExprChild(tp::String id) { return new ExpressionChild(this, id); } +ExpressionChild* Expression::ExprChild(const tp::String& id) { return new ExpressionChild(this, id); } ExpressionCall* Expression::ExprCall(ExpressionList* args) { return new ExpressionCall(this, args); } -ExpressionLocal* obj::BCgen::ExprLocal(tp::String id) { return new ExpressionLocal(id); } - -ExpressionSelf* obj::BCgen::ExprSelf() { return new ExpressionSelf(); } - -ExpressionNew* obj::BCgen::ExprNew(tp::String type) { return new ExpressionNew(type); } - -ExpressionAriphm* obj::BCgen::ExprAriphm(Expression* left, Expression* right, OpCode type) { - return new ExpressionAriphm(left, right, type); -} - -ExpressionFunc* obj::BCgen::ExprFunc(tp::String id) { return new ExpressionFunc(id); } - -ExpressionBoolean* obj::BCgen::ExprBool(Expression* left, Expression* right, obj::OpCode type) { - return new ExpressionBoolean(left, right, ExpressionBoolean::BoolType(type)); -} - -ExpressionBoolean* obj::BCgen::ExprBoolNot(Expression* invert) { return new ExpressionBoolean(invert); } - ExpressionBoolean::ExpressionBoolean(Expression* left, Expression* right, BoolType type) : Expression(Type::BOOLEAN), mLeft(left), @@ -40,60 +21,103 @@ ExpressionBoolean::ExpressionBoolean(Expression* invert) : mLeft(invert), mBoolType(BoolType::NOT) {} +ExpressionBoolean::~ExpressionBoolean() { + delete mLeft; + delete mRight; +} + ExpressionCall::ExpressionCall(Expression* mParent, ExpressionList* args) : Expression(Type::CALL), mParent(mParent) { mArgs = args; } +ExpressionCall::~ExpressionCall() { + delete mParent; + delete mArgs; +} + ExpressionList::ExpressionList() : Expression(Type::LIST) {} -ExpressionNew::ExpressionNew(tp::String type) : +ExpressionList::~ExpressionList() { + for (auto item : mItems) { + delete item.data(); + } +} + +ExpressionNew::ExpressionNew(const tp::String& type) : Expression(Type::NEW), mNewType(type) {} -ExpressionLocal::ExpressionLocal(tp::String id) : + +ExpressionNew::~ExpressionNew() = default; + +ExpressionLocal::ExpressionLocal(const tp::String& id) : Expression(Type::LOCAL), mLocalId(id) {} + +ExpressionLocal::~ExpressionLocal() = default; + ExpressionSelf::ExpressionSelf() : Expression(Type::SELF) {} -ExpressionChild::ExpressionChild(Expression* mParent, tp::String id) : + +ExpressionChild::ExpressionChild(Expression* mParent, const tp::String& id) : Expression(Type::CHILD), mParent(mParent), mLocalId(id) {} -ExpressionAriphm::ExpressionAriphm(Expression* left, Expression* right, OpCode type) : - Expression(Type::ARIPHM), + +ExpressionChild::~ExpressionChild() { delete mParent; } + +ExpressionArithmetics::ExpressionArithmetics(Expression* left, Expression* right, OpCode type) : + Expression(Type::ARITHMETICS), mLeft(left), mRight(right), mOpType(type) {} -ExpressionFunc::ExpressionFunc(tp::String id) : + +ExpressionArithmetics::~ExpressionArithmetics() { + delete mLeft; + delete mRight; +} + +ExpressionFunc::ExpressionFunc(const tp::String& id) : Expression(Type::FUNC), mFuncId(id) {} -ExpressionConst::ExpressionConst(tp::String val) : + +ExpressionFunc::~ExpressionFunc() = default; + +ExpressionConst::ExpressionConst(const tp::String& val) : Expression(Type::CONST_EXPR), mConstType(STR), str(val) {} + ExpressionConst::ExpressionConst(const char* val) : Expression(Type::CONST_EXPR), mConstType(STR), str(val) {} + ExpressionConst::ExpressionConst(tp::int4 val) : Expression(Type::CONST_EXPR), mConstType(INT), integer(val) {} + ExpressionConst::ExpressionConst(tp::flt4 val) : Expression(Type::CONST_EXPR), mConstType(FLT), floating(val) {} + ExpressionConst::ExpressionConst(tp::alni val) : Expression(Type::CONST_EXPR), mConstType(INT), integer(val) {} + ExpressionConst::ExpressionConst(tp::alnf val) : Expression(Type::CONST_EXPR), mConstType(FLT), floating(val) {} + ExpressionConst::ExpressionConst(bool val) : Expression(Type::CONST_EXPR), mConstType(BOOL), boolean(val) {} + +ExpressionConst::~ExpressionConst() = default; diff --git a/Objects/private/compiler/function.cpp b/Objects/private/compiler/function.cpp index 4cc802b..5f029ef 100644 --- a/Objects/private/compiler/function.cpp +++ b/Objects/private/compiler/function.cpp @@ -212,18 +212,17 @@ void FunctionDefinition::EvalStatement(Statement* stm) { type = "str"; break; } - default: - { - ASSERT(0 && "Cantbe"); - } } auto new_expr = new ExpressionNew(type); + auto defLocalExpr = new StatementLocalDef(stm_local_def->mLocalId, new_expr); - EvalStatement(StmDefLocal(stm_local_def->mLocalId, new_expr)); + EvalStatement(defLocalExpr); EvalExpr(stm_local_def->mConstExpr); inst(Instruction(OpCode::LOAD_LOCAL, mConstants.get(stm_local_def->mLocalId))); inst(Instruction(OpCode::OBJ_COPY)); + + delete defLocalExpr; } break; } @@ -256,8 +255,6 @@ void FunctionDefinition::EvalStatement(Statement* stm) { default: ASSERT(0) } - - delete stm; } void FunctionDefinition::EvalExpr(Expression* expr) { @@ -283,9 +280,9 @@ void FunctionDefinition::EvalExpr(Expression* expr) { inst(Instruction(OpCode::LOAD_LOCAL, mConstants.get(func->mFuncId))); break; } - case Expression::Type::ARIPHM: + case Expression::Type::ARITHMETICS: { - auto ariphm = (ExpressionAriphm*) expr; + auto ariphm = (ExpressionArithmetics*) expr; EvalExpr(ariphm->mRight); EvalExpr(ariphm->mLeft); inst(Instruction(ariphm->mOpType)); @@ -359,7 +356,6 @@ void FunctionDefinition::EvalExpr(Expression* expr) { default: ASSERT(0) } - delete expr; } tp::alni instSize(const Instruction& inst) { @@ -553,32 +549,16 @@ tp::List::Node* FunctionDefinition::inst(Instruction inst) { return mInstructions.last(); } -static Parser* sParger = NULL; +void obj::BCgen::init() {} -void obj::BCgen::init() { - ASSERT(!sParger); - if (!sParger) { - sParger = new Parser(); - } -} - -void obj::BCgen::deinit() { - ASSERT(sParger); - if (sParger) { - delete sParger; - sParger = nullptr; - } -} +void obj::BCgen::deinit() {} bool obj::BCgen::Compile(obj::MethodObject* method) { - ASSERT(method); - ASSERT(sParger); - - if (!sParger) return false; + Parser sParger; auto script = method->mScript->mReadable->val; - auto res = sParger->parse(script); + auto res = sParger.parse(script); if (res.err) { // TODO : print parse error diff --git a/Objects/private/compiler/statement.cpp b/Objects/private/compiler/statement.cpp index 1633ce5..45d2717 100644 --- a/Objects/private/compiler/statement.cpp +++ b/Objects/private/compiler/statement.cpp @@ -3,112 +3,105 @@ using namespace obj; using namespace BCgen; -StatementFuncDef::StatementFuncDef(tp::String function_id) { - mType = Type::DEF_FUNC; +StatementFuncDef::StatementFuncDef(const tp::String& function_id) : + Statement(Type::DEF_FUNC) { mFunctionId = function_id; } -StatementLocalDef::StatementLocalDef(tp::String id, Expression* value) : +StatementFuncDef::~StatementFuncDef() { delete mStatements; } + +StatementLocalDef::StatementLocalDef(const tp::String& id, Expression* value) : mLocalId(id), - mNewExpr(value) { - mType = Type::DEF_LOCAL; + Statement(Type::DEF_LOCAL) { + + if (value->mType == Expression::Type::CONST_EXPR) { + mIsConstExpr = true; + mConstExpr = (ExpressionConst*) value; + } else { + mIsConstExpr = false; + mNewExpr = value; + } } -StatementLocalDef::StatementLocalDef(tp::String id, ExpressionConst* value) : - mLocalId(id), - mConstExpr(value), - mIsConstExpr(true) { - mType = Type::DEF_LOCAL; +StatementLocalDef::~StatementLocalDef() { + delete mNewExpr; + delete mConstExpr; } StatementCopy::StatementCopy(Expression* left, Expression* right) : mLeft(left), - mRight(right) { - mType = Type::COPY; + mRight(right), + Statement(Type::COPY) {} + +StatementCopy::~StatementCopy() { + delete mLeft; + delete mRight; } -StatementReturn::StatementReturn() { mType = Type::RET; } +StatementReturn::StatementReturn() : + Statement(Type::RET) {} StatementReturn::StatementReturn(Expression* ret) : - mRet(ret) { - mType = Type::RET; -} + mRet(ret), + Statement(Type::RET) {} + +StatementReturn::~StatementReturn() { delete mRet; } StatementPrint::StatementPrint(Expression* target) : - mTarget(target) { - mType = Type::PRINT; -} + mTarget(target), + Statement(Type::PRINT) {} -StatementScope::StatementScope(tp::InitialierList statements, bool aPushToScopeStack) { - mType = Type::SCOPE; +StatementPrint::~StatementPrint() { delete mTarget; } + +StatementScope::StatementScope(tp::InitialierList statements, bool aPushToScopeStack) : + Statement(Type::SCOPE) { mStatements = statements; mPushToScopeStack = aPushToScopeStack; } -StatementIf::StatementIf(Expression* condition, StatementScope* on_true, StatementScope* on_false) { - mType = Type::IF; +StatementScope::~StatementScope() { + for (auto iter : mStatements) { + delete iter.data(); + } +} + +StatementIf::StatementIf(Expression* condition, StatementScope* on_true, StatementScope* on_false) : + Statement(Type::IF) { mOnFalse = on_false; mOnTrue = on_true; mCondition = condition; } -StatementWhile::StatementWhile(Expression* condition, StatementScope* scope) { - mType = Type::WHILE; +StatementIf::~StatementIf() { + delete mCondition; + delete mOnTrue; + delete mOnFalse; +} + +StatementWhile::StatementWhile(Expression* condition, StatementScope* scope) : + Statement(Type::WHILE) { mScope = scope; mCondition = condition; } -StatementIgnore::StatementIgnore(Expression* expr) { - mType = Type::IGNORE; +StatementWhile::~StatementWhile() { + delete mCondition; + delete mScope; +} + +StatementIgnore::StatementIgnore(Expression* expr) : + Statement(Type::IGNORE) { mExpr = expr; } -StatementClassDef::StatementClassDef(tp::String class_id, StatementScope* scope) { +StatementIgnore::~StatementIgnore() { delete mExpr; } + +StatementClassDef::StatementClassDef(const tp::String& class_id, StatementScope* scope) : + Statement(Type::CLASS_DEF) { mClassId = class_id; mScope = scope; - mType = Type::CLASS_DEF; -} -// helpers - -StatementFuncDef* -obj::BCgen::StmDefFunc(tp::String id, tp::InitialierList args, tp::InitialierList stms) { - auto out = new StatementFuncDef(id); - auto scope = new StatementScope(stms, true); - out->mStatements = scope; - out->mArgs = args; - return out; } -StatementLocalDef* obj::BCgen::StmDefLocal(tp::String id, Expression* value) { - if (value->mType == Expression::Type::CONST_EXPR) { - return new StatementLocalDef(id, (ExpressionConst*) value); - } +StatementClassDef::~StatementClassDef() { delete mScope; } - return new StatementLocalDef(id, value); -} - -StatementCopy* obj::BCgen::StmCopy(Expression* left, Expression* right) { return new StatementCopy(left, right); } - -StatementPrint* obj::BCgen::StmPrint(Expression* target) { return new StatementPrint(target); } - -StatementReturn* obj::BCgen::StmReturn() { return new StatementReturn(); } - -StatementReturn* obj::BCgen::StmReturn(Expression* obj) { return new StatementReturn(obj); } - -StatementIf* obj::BCgen::StmIf(Expression* condition, StatementScope* on_true, StatementScope* on_false) { - return new StatementIf(condition, on_true, on_false); -} - -StatementScope* obj::BCgen::StmScope(tp::InitialierList statements, bool aPushToScopeStack = false) { - return new StatementScope(statements, aPushToScopeStack); -} - -StatementWhile* obj::BCgen::StmWhile(Expression* condition, StatementScope* scope) { - return new StatementWhile(condition, scope); -} - -StatementIgnore* obj::BCgen::StmIgnore(Expression* expr) { return new StatementIgnore(expr); } - -StatementClassDef* obj::BCgen::StmClassDef(tp::String id, StatementScope* scope) { - return new StatementClassDef(id, scope); -} +Statement::Statement(Statement::Type type) { mType = type; } diff --git a/Objects/private/parser/Bindings.cpp b/Objects/private/parser/Bindings.cpp index 58b7249..689623d 100644 --- a/Objects/private/parser/Bindings.cpp +++ b/Objects/private/parser/Bindings.cpp @@ -13,7 +13,7 @@ static UserData scope_empty(const UserData*, const Node*, size_t) { return new S static UserData stm_list_append(const UserData* start, const Node*, size_t) { auto scope = (StatementScope*) start[0]; - auto stm = (Statement*) start[2]; + auto stm = (Statement*) start[1]; scope->mStatements.append(stm); return scope; } @@ -153,19 +153,19 @@ static UserData expr_bool_lesser_eq(const UserData* start, const Node*, size_t) } static UserData expr_add(const UserData* start, const Node*, size_t) { - return new ExpressionAriphm((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_ADD); + return new ExpressionArithmetics((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_ADD); } static UserData expr_subtract(const UserData* start, const Node*, size_t) { - return new ExpressionAriphm((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_SUB); + return new ExpressionArithmetics((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_SUB); } static UserData expr_multiply(const UserData* start, const Node*, size_t) { - return new ExpressionAriphm((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_MUL); + return new ExpressionArithmetics((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_MUL); } static UserData expr_divide(const UserData* start, const Node*, size_t) { - return new ExpressionAriphm((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_DIV); + return new ExpressionArithmetics((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_DIV); } static UserData expr_compound(const UserData* start, const Node*, size_t) { return start[1]; } diff --git a/Objects/public/compiler/expression.h b/Objects/public/compiler/expression.h index 7d04bbd..146e2b1 100644 --- a/Objects/public/compiler/expression.h +++ b/Objects/public/compiler/expression.h @@ -6,126 +6,120 @@ #include "interpreter/opcodes.h" -namespace obj { - namespace BCgen { +namespace obj::BCgen { - struct ExpressionChild; - struct ExpressionCall; + struct Expression { + enum class Type { + NONE, + NEW, + LOCAL, + CONST_EXPR, + CHILD, + CALL, + ARITHMETICS, + FUNC, + BOOLEAN, + SELF, + LIST, + } mType = Type::NONE; - struct Expression { - enum class Type { - NONE, - NEW, - LOCAL, - CONST_EXPR, - CHILD, - CALL, - ARIPHM, - FUNC, - BOOLEAN, - SELF, - LIST, - } mType = Type::NONE; + bool mValueUsed = false; - bool mValueUsed = false; + explicit Expression(Type type); + virtual ~Expression() = default; - Expression(); - Expression(Type type); - - ExpressionChild* ExprChild(tp::String id); - ExpressionCall* ExprCall(class ExpressionList* args); - }; - - struct ExpressionList : public Expression { - tp::Buffer mItems; - ExpressionList(); - }; - - struct ExpressionNew : public Expression { - tp::String mNewType; - ExpressionNew(tp::String type); - }; - - struct ExpressionLocal : public Expression { - tp::String mLocalId; - ExpressionLocal(tp::String id); - }; - - struct ExpressionFunc : public Expression { - tp::String mFuncId; - ExpressionFunc(tp::String id); - }; - - struct ExpressionChild : public Expression { - Expression* mParent = NULL; - tp::String mLocalId; - bool mMethod = false; - ExpressionChild(Expression* mParent, tp::String id); - }; - - struct ExpressionCall : public Expression { - Expression* mParent = NULL; - ExpressionList* mArgs; - ExpressionCall(Expression* mParent, ExpressionList* args); - }; - - struct ExpressionAriphm : public Expression { - Expression* mLeft = NULL; - Expression* mRight = NULL; - OpCode mOpType; - ExpressionAriphm(Expression* left, Expression* right, OpCode type); - }; - - struct ExpressionBoolean : public Expression { - Expression* mLeft = NULL; - Expression* mRight = NULL; - - enum class BoolType : tp::uint1 { - AND = 24U, - OR, - EQUAL, - NOT_EQUAL, - MORE, - LESS, - EQUAL_OR_MORE, - EQUAL_OR_LESS, - NOT, - } mBoolType; - - ExpressionBoolean(Expression* left, Expression* right, BoolType type); - ExpressionBoolean(Expression* invert); - }; - - struct ExpressionConst : public Expression { - enum ConstType { STR, INT, BOOL, FLT } mConstType; - tp::String str; - tp::alni integer = 0; - tp::alnf floating = 0; - bool boolean = 0; - - ExpressionConst(tp::String val); - ExpressionConst(const char* val); - ExpressionConst(tp::alni val); - ExpressionConst(tp::int4 val); - ExpressionConst(tp::flt4 val); - ExpressionConst(tp::alnf val); - ExpressionConst(bool val); - }; - - struct ExpressionSelf : public Expression { - ExpressionSelf(); - }; - - ExpressionLocal* ExprLocal(tp::String id); - ExpressionSelf* ExprSelf(); - ExpressionFunc* ExprFunc(tp::String id); - ExpressionNew* ExprNew(tp::String id); - ExpressionAriphm* ExprAriphm(Expression* left, Expression* right, OpCode type); - ExpressionBoolean* ExprBool(Expression* left, Expression* right, OpCode type); - ExpressionBoolean* ExprBoolNot(Expression* invert); - template - ExpressionConst* ExprConst(ConstType val) { - return new ExpressionConst(val); - } + struct ExpressionChild* ExprChild(const tp::String& id); + struct ExpressionCall* ExprCall(class ExpressionList* args); }; -}; \ No newline at end of file + + struct ExpressionList : public Expression { + tp::Buffer mItems; + ExpressionList(); + ~ExpressionList() override; + }; + + struct ExpressionNew : public Expression { + tp::String mNewType; + explicit ExpressionNew(const tp::String& type); + ~ExpressionNew() override; + }; + + struct ExpressionLocal : public Expression { + tp::String mLocalId; + explicit ExpressionLocal(const tp::String& id); + ~ExpressionLocal() override; + }; + + struct ExpressionFunc : public Expression { + tp::String mFuncId; + explicit ExpressionFunc(const tp::String& id); + ~ExpressionFunc() override; + }; + + struct ExpressionChild : public Expression { + Expression* mParent = nullptr; + tp::String mLocalId; + bool mMethod = false; + ExpressionChild(Expression* mParent, const tp::String& id); + ~ExpressionChild() override; + }; + + struct ExpressionCall : public Expression { + Expression* mParent = nullptr; + ExpressionList* mArgs = nullptr; + ExpressionCall(Expression* mParent, ExpressionList* args); + ~ExpressionCall() override; + }; + + struct ExpressionArithmetics : public Expression { + Expression* mLeft = nullptr; + Expression* mRight = nullptr; + OpCode mOpType = OpCode::NONE; + ExpressionArithmetics(Expression* left, Expression* right, OpCode type); + ~ExpressionArithmetics() override; + }; + + struct ExpressionBoolean : public Expression { + Expression* mLeft = nullptr; + Expression* mRight = nullptr; + + enum class BoolType : tp::uint1 { + AND = 24U, + OR, + EQUAL, + NOT_EQUAL, + MORE, + LESS, + EQUAL_OR_MORE, + EQUAL_OR_LESS, + NOT, + } mBoolType; + + ExpressionBoolean(Expression* left, Expression* right, BoolType type); + explicit ExpressionBoolean(Expression* invert); + ~ExpressionBoolean() override; + }; + + struct ExpressionConst : public Expression { + enum ConstType { STR, INT, BOOL, FLT } mConstType; + tp::String str; + tp::alni integer = 0; + tp::alnf floating = 0; + bool boolean = false; + + explicit ExpressionConst(const tp::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(bool val); + + ~ExpressionConst() override; + }; + + struct ExpressionSelf : public Expression { + ExpressionSelf(); + ~ExpressionSelf() override = default; + }; +} \ No newline at end of file diff --git a/Objects/public/compiler/statement.h b/Objects/public/compiler/statement.h index b7b09c5..0d87a40 100644 --- a/Objects/public/compiler/statement.h +++ b/Objects/public/compiler/statement.h @@ -3,115 +3,109 @@ #include "expression.h" -namespace obj { - namespace BCgen { - struct Statement { - enum class Type { - NONE, - SCOPE, - DEF_FUNC, - DEF_LOCAL, - RET, - PRINT, - COPY, - IF, - WHILE, - IGNORE, - CALL, - CLASS_DEF, - } mType = Type::NONE; +namespace obj::BCgen { + struct Statement { - bool mValueUsed = false; + enum class Type { + NONE, + SCOPE, + DEF_FUNC, + DEF_LOCAL, + RET, + PRINT, + COPY, + IF, + WHILE, + IGNORE, + CALL, + CLASS_DEF, + } mType = Type::NONE; - Statement() {} - Statement(Type type); - }; + bool mValueUsed = false; - struct StatementScope : public Statement { - tp::Buffer mStatements; - bool mPushToScopeStack = false; - - StatementScope(tp::InitialierList statements, bool aPushToScopeStack); - }; - - struct StatementFuncDef : public Statement { - tp::Buffer mArgs; - tp::String mFunctionId; - StatementScope* mStatements; - - StatementFuncDef(tp::String function_id); - }; - - struct StatementLocalDef : public Statement { - tp::String mLocalId; - Expression* mNewExpr = NULL; - ExpressionConst* mConstExpr = NULL; - bool mIsConstExpr = false; - - StatementLocalDef(tp::String id, Expression* value); - StatementLocalDef(tp::String id, ExpressionConst* value); - }; - - struct StatementCopy : public Statement { - Expression* mLeft = NULL; - Expression* mRight = NULL; - - StatementCopy(Expression* left, Expression* right); - }; - - struct StatementReturn : public Statement { - Expression* mRet = NULL; - - StatementReturn(Expression* ret); - StatementReturn(); - }; - - struct StatementPrint : public Statement { - Expression* mTarget = NULL; - - StatementPrint(Expression* mTarget); - }; - - struct StatementIgnore : public Statement { - Expression* mExpr = NULL; - - StatementIgnore(Expression* expr); - }; - - struct StatementIf : public Statement { - Expression* mCondition = NULL; - StatementScope* mOnTrue = NULL; - StatementScope* mOnFalse = NULL; - - StatementIf(Expression* condition, StatementScope* on_true, StatementScope* on_false); - }; - - struct StatementWhile : public Statement { - Expression* mCondition = NULL; - StatementScope* mScope = NULL; - - StatementWhile(Expression* condition, StatementScope* scope); - }; - - struct StatementClassDef : public Statement { - tp::String mClassId; - StatementScope* mScope = NULL; - - StatementClassDef(tp::String class_id, StatementScope* scope); - }; - - // Helpers - StatementFuncDef* - StmDefFunc(tp::String id, tp::InitialierList args, tp::InitialierList stms); - StatementLocalDef* StmDefLocal(tp::String id, Expression* value); - StatementCopy* StmCopy(Expression* left, Expression* right); - StatementPrint* StmPrint(Expression* target); - StatementReturn* StmReturn(Expression* obj); - StatementReturn* StmReturn(); - StatementIf* StmIf(Expression* condition, StatementScope* on_true, StatementScope* on_false); - StatementScope* StmScope(tp::InitialierList statements, bool aPushToScopeStack); - StatementWhile* StmWhile(Expression* condition, StatementScope* scope); - StatementIgnore* StmIgnore(Expression* expr); - StatementClassDef* StmClassDef(tp::String id, StatementScope* scope); + explicit Statement(Type type); + virtual ~Statement() = default; }; -}; \ No newline at end of file + + struct StatementScope : public Statement { + tp::Buffer mStatements; + bool mPushToScopeStack = false; + + StatementScope(tp::InitialierList statements, bool aPushToScopeStack); + ~StatementScope() override; + }; + + struct StatementFuncDef : public Statement { + tp::Buffer mArgs; + tp::String mFunctionId; + StatementScope* mStatements = nullptr; + + explicit StatementFuncDef(const tp::String& function_id); + ~StatementFuncDef() override; + }; + + struct StatementLocalDef : public Statement { + tp::String mLocalId; + Expression* mNewExpr = nullptr; + ExpressionConst* mConstExpr = nullptr; + bool mIsConstExpr = false; + + StatementLocalDef(const tp::String& id, Expression* value); + ~StatementLocalDef() override; + }; + + struct StatementCopy : public Statement { + Expression* mLeft = nullptr; + Expression* mRight = nullptr; + + StatementCopy(Expression* left, Expression* right); + ~StatementCopy() override; + }; + + struct StatementReturn : public Statement { + Expression* mRet = nullptr; + + explicit StatementReturn(Expression* ret); + StatementReturn(); + ~StatementReturn() override; + }; + + struct StatementPrint : public Statement { + Expression* mTarget = nullptr; + + explicit StatementPrint(Expression* mTarget); + ~StatementPrint() override; + }; + + struct StatementIgnore : public Statement { + Expression* mExpr = nullptr; + + explicit StatementIgnore(Expression* expr); + ~StatementIgnore() override; + }; + + struct StatementIf : public Statement { + Expression* mCondition = nullptr; + StatementScope* mOnTrue = nullptr; + StatementScope* mOnFalse = nullptr; + + StatementIf(Expression* condition, StatementScope* on_true, StatementScope* on_false); + ~StatementIf() override; + }; + + struct StatementWhile : public Statement { + Expression* mCondition = nullptr; + StatementScope* mScope = nullptr; + + StatementWhile(Expression* condition, StatementScope* scope); + ~StatementWhile() override; + }; + + struct StatementClassDef : public Statement { + tp::String mClassId; + StatementScope* mScope = nullptr; + + StatementClassDef(const tp::String& class_id, StatementScope* scope); + ~StatementClassDef() override; + }; +} \ No newline at end of file diff --git a/Objects/tests/TestInterpreter.cpp b/Objects/tests/TestInterpreter.cpp index 0577c75..d96eb64 100644 --- a/Objects/tests/TestInterpreter.cpp +++ b/Objects/tests/TestInterpreter.cpp @@ -41,10 +41,8 @@ if (i == 10) { )"; auto script = R"( -{ var i = 10; print (i + 10) * 5; -} )"; TEST_DEF_STATIC(Complex) { @@ -86,6 +84,5 @@ TEST_DEF_STATIC(Simple) { TEST_DEF(Interpreter) { testSimple(); - exit(0); // testComplex(); } diff --git a/Objects/tests/TestParser.cpp b/Objects/tests/TestParser.cpp index ddc3b38..8fe2e41 100644 --- a/Objects/tests/TestParser.cpp +++ b/Objects/tests/TestParser.cpp @@ -9,8 +9,9 @@ using namespace obj; TEST_DEF_STATIC(Basic) { Parser parser; - String stream = "{ var i = true; print (i + 1) * 10; }"; + String stream = "var i = true; print (i + 1) * 10;"; auto res = parser.parse(stream); + delete res.scope; } TEST_DEF(Parser) { testBasic(); } diff --git a/Objects/tests/Tests.cpp b/Objects/tests/Tests.cpp index d5ad769..2d752b2 100644 --- a/Objects/tests/Tests.cpp +++ b/Objects/tests/Tests.cpp @@ -16,11 +16,6 @@ int main() { tp::ModuleManifest* deps[] = { &gModuleObjects, nullptr }; tp::ModuleManifest module("ObjectsTests", nullptr, nullptr, deps); - if (module.initialize()) { - testInterpreter(); - module.deinitialize(); - } - if (module.initialize()) { testParser(); module.deinitialize(); @@ -36,5 +31,10 @@ int main() { module.deinitialize(); } + if (module.initialize()) { + testInterpreter(); + module.deinitialize(); + } + return 0; }