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

tmp

Browse source
This commit is contained in:
IlyaShurupov 2024-03-06 10:47:37 +03:00 • committed by Ilusha
parent e628e7c1e2
commit 828096de17
9 changed files with 351 additions and 368 deletions
Download patch file Download diff file Expand all files Collapse all files

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

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

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

@ -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<Instruction>::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

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

@ -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<Statement*> statements, bool aPushToScopeStack) {
mType = Type::SCOPE;
StatementPrint::~StatementPrint() { delete mTarget; }
StatementScope::StatementScope(tp::InitialierList<Statement*> 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<tp::String> args, tp::InitialierList<Statement*> 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<Statement*> statements, bool aPushToScopeStack = false) {
return new StatementScope(statements, aPushToScopeStack);
}
StatementWhile* obj::BCgen::StmWhile(Expression* condition, StatementScope* scope) {
return new StatementWhile(condition, scope);
}
StatementIgnore* obj::BCgen::StmIgnore(Expression* expr) { return new StatementIgnore(expr); }
StatementClassDef* obj::BCgen::StmClassDef(tp::String id, StatementScope* scope) {
return new StatementClassDef(id, scope);
}
Statement::Statement(Statement::Type type) { mType = type; }

10
Objects/private/parser/Bindings.cpp
View file

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

86
Objects/public/compiler/expression.h
View file

@ -6,11 +6,7 @@
#include "interpreter/opcodes.h"
namespace obj {
namespace BCgen {
struct ExpressionChild;
struct ExpressionCall;
namespace obj::BCgen {
struct Expression {
enum class Type {
@ -20,7 +16,7 @@ namespace obj {
CONST_EXPR,
CHILD,
CALL,
ARIPHM,
ARITHMETICS,
FUNC,
BOOLEAN,
SELF,
@ -29,56 +25,63 @@ namespace obj {
bool mValueUsed = false;
Expression();
Expression(Type type);
explicit Expression(Type type);
virtual ~Expression() = default;
ExpressionChild* ExprChild(tp::String id);
ExpressionCall* ExprCall(class ExpressionList* args);
struct ExpressionChild* ExprChild(const tp::String& id);
struct ExpressionCall* ExprCall(class ExpressionList* args);
};
struct ExpressionList : public Expression {
tp::Buffer<Expression*> mItems;
ExpressionList();
~ExpressionList() override;
};
struct ExpressionNew : public Expression {
tp::String mNewType;
ExpressionNew(tp::String type);
explicit ExpressionNew(const tp::String& type);
~ExpressionNew() override;
};
struct ExpressionLocal : public Expression {
tp::String mLocalId;
ExpressionLocal(tp::String id);
explicit ExpressionLocal(const tp::String& id);
~ExpressionLocal() override;
};
struct ExpressionFunc : public Expression {
tp::String mFuncId;
ExpressionFunc(tp::String id);
explicit ExpressionFunc(const tp::String& id);
~ExpressionFunc() override;
};
struct ExpressionChild : public Expression {
Expression* mParent = NULL;
Expression* mParent = nullptr;
tp::String mLocalId;
bool mMethod = false;
ExpressionChild(Expression* mParent, tp::String id);
ExpressionChild(Expression* mParent, const tp::String& id);
~ExpressionChild() override;
};
struct ExpressionCall : public Expression {
Expression* mParent = NULL;
ExpressionList* mArgs;
Expression* mParent = nullptr;
ExpressionList* mArgs = nullptr;
ExpressionCall(Expression* mParent, ExpressionList* args);
~ExpressionCall() override;
};
struct ExpressionAriphm : public Expression {
Expression* mLeft = NULL;
Expression* mRight = NULL;
OpCode mOpType;
ExpressionAriphm(Expression* left, Expression* right, OpCode type);
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 = NULL;
Expression* mRight = NULL;
Expression* mLeft = nullptr;
Expression* mRight = nullptr;
enum class BoolType : tp::uint1 {
AND = 24U,
@ -93,7 +96,8 @@ namespace obj {
} mBoolType;
ExpressionBoolean(Expression* left, Expression* right, BoolType type);
ExpressionBoolean(Expression* invert);
explicit ExpressionBoolean(Expression* invert);
~ExpressionBoolean() override;
};
struct ExpressionConst : public Expression {
@ -101,31 +105,21 @@ namespace obj {
tp::String str;
tp::alni integer = 0;
tp::alnf floating = 0;
bool boolean = 0;
bool boolean = false;
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);
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;
};
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 <typename ConstType>
ExpressionConst* ExprConst(ConstType val) {
return new ExpressionConst(val);
}
};
};

76
Objects/public/compiler/statement.h
View file

@ -3,9 +3,9 @@
#include "expression.h"
namespace obj {
namespace BCgen {
namespace obj::BCgen {
struct Statement {
enum class Type {
NONE,
SCOPE,
@ -23,8 +23,8 @@ namespace obj {
bool mValueUsed = false;
Statement() {}
Statement(Type type);
explicit Statement(Type type);
virtual ~Statement() = default;
};
struct StatementScope : public Statement {
@ -32,86 +32,80 @@ namespace obj {
bool mPushToScopeStack = false;
StatementScope(tp::InitialierList<Statement*> statements, bool aPushToScopeStack);
~StatementScope() override;
};
struct StatementFuncDef : public Statement {
tp::Buffer<tp::String> mArgs;
tp::String mFunctionId;
StatementScope* mStatements;
StatementScope* mStatements = nullptr;
StatementFuncDef(tp::String function_id);
explicit StatementFuncDef(const tp::String& function_id);
~StatementFuncDef() override;
};
struct StatementLocalDef : public Statement {
tp::String mLocalId;
Expression* mNewExpr = NULL;
ExpressionConst* mConstExpr = NULL;
Expression* mNewExpr = nullptr;
ExpressionConst* mConstExpr = nullptr;
bool mIsConstExpr = false;
StatementLocalDef(tp::String id, Expression* value);
StatementLocalDef(tp::String id, ExpressionConst* value);
StatementLocalDef(const tp::String& id, Expression* value);
~StatementLocalDef() override;
};
struct StatementCopy : public Statement {
Expression* mLeft = NULL;
Expression* mRight = NULL;
Expression* mLeft = nullptr;
Expression* mRight = nullptr;
StatementCopy(Expression* left, Expression* right);
~StatementCopy() override;
};
struct StatementReturn : public Statement {
Expression* mRet = NULL;
Expression* mRet = nullptr;
StatementReturn(Expression* ret);
explicit StatementReturn(Expression* ret);
StatementReturn();
~StatementReturn() override;
};
struct StatementPrint : public Statement {
Expression* mTarget = NULL;
Expression* mTarget = nullptr;
StatementPrint(Expression* mTarget);
explicit StatementPrint(Expression* mTarget);
~StatementPrint() override;
};
struct StatementIgnore : public Statement {
Expression* mExpr = NULL;
Expression* mExpr = nullptr;
StatementIgnore(Expression* expr);
explicit StatementIgnore(Expression* expr);
~StatementIgnore() override;
};
struct StatementIf : public Statement {
Expression* mCondition = NULL;
StatementScope* mOnTrue = NULL;
StatementScope* mOnFalse = NULL;
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 = NULL;
StatementScope* mScope = NULL;
Expression* mCondition = nullptr;
StatementScope* mScope = nullptr;
StatementWhile(Expression* condition, StatementScope* scope);
~StatementWhile() override;
};
struct StatementClassDef : public Statement {
tp::String mClassId;
StatementScope* mScope = NULL;
StatementScope* mScope = nullptr;
StatementClassDef(tp::String class_id, StatementScope* scope);
};
// Helpers
StatementFuncDef*
StmDefFunc(tp::String id, tp::InitialierList<tp::String> args, tp::InitialierList<Statement*> 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<Statement*> statements, bool aPushToScopeStack);
StatementWhile* StmWhile(Expression* condition, StatementScope* scope);
StatementIgnore* StmIgnore(Expression* expr);
StatementClassDef* StmClassDef(tp::String id, StatementScope* scope);
};
StatementClassDef(const tp::String& class_id, StatementScope* scope);
~StatementClassDef() override;
};
}

3
Objects/tests/TestInterpreter.cpp
View file

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

3
Objects/tests/TestParser.cpp
View file

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

10
Objects/tests/Tests.cpp
View file

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