tmp
This commit is contained in:
IlyaShurupov
Ilusha
parent
e628e7c1e2
commit
828096de17
9 changed files with 351 additions and 368 deletions
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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; }
|
||||
|
|
|
|||
|
|
@ -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]; }
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue