调整了项目文件夹层次，evaluator.cpp拆分
This commit is contained in:
@@ -2,7 +2,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <Ast/astBase.hpp>
|
||||
#include <Value/value.hpp>
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
|
||||
namespace Fig::Ast
|
||||
{
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
#include <Ast/astBase.hpp>
|
||||
|
||||
#include <Value/value.hpp>
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
|
||||
namespace Fig::Ast
|
||||
{
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
#include <Ast/astBase.hpp>
|
||||
#include <Ast/functionParameters.hpp>
|
||||
|
||||
#include <Value/value.hpp>
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
|
||||
namespace Fig::Ast
|
||||
{
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <Ast/astBase.hpp>
|
||||
#include <Value/Type.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
|
||||
namespace Fig::Ast
|
||||
{
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <Ast/astBase.hpp>
|
||||
#include <Value/Type.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
#include <Core/fig_string.hpp>
|
||||
|
||||
#include <format>
|
||||
|
||||
@@ -1,17 +1,17 @@
|
||||
#pragma once
|
||||
|
||||
#include "Ast/Statements/InterfaceDefSt.hpp"
|
||||
#include "Value/interface.hpp"
|
||||
#include <Value/Type.hpp>
|
||||
#include <Ast/Statements/InterfaceDefSt.hpp>
|
||||
#include <Evaluator/Value/interface.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
#include <algorithm>
|
||||
#include <unordered_map>
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
|
||||
#include <Context/context_forward.hpp>
|
||||
#include <Evaluator/Context/context_forward.hpp>
|
||||
#include <Core/fig_string.hpp>
|
||||
#include <Value/value.hpp>
|
||||
#include <Value/VariableSlot.hpp>
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
#include <Evaluator/Value/VariableSlot.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
|
||||
125
src/Evaluator/Core/Eval.cpp
Normal file
125
src/Evaluator/Core/Eval.cpp
Normal file
@@ -0,0 +1,125 @@
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
RvObject Evaluator::eval(Ast::Expression exp, ContextPtr ctx)
|
||||
{
|
||||
using Ast::AstType;
|
||||
AstType type = exp->getType();
|
||||
switch (type)
|
||||
{
|
||||
case AstType::ValueExpr: {
|
||||
auto val = std::static_pointer_cast<Ast::ValueExprAst>(exp);
|
||||
assert(val != nullptr);
|
||||
return val->val;
|
||||
}
|
||||
case AstType::VarExpr: {
|
||||
auto varExpr = std::static_pointer_cast<Ast::VarExprAst>(exp);
|
||||
assert(varExpr != nullptr);
|
||||
return evalVarExpr(varExpr, ctx).get(); // LvObject -> RvObject
|
||||
}
|
||||
case AstType::BinaryExpr: {
|
||||
auto bin = std::static_pointer_cast<Ast::BinaryExprAst>(exp);
|
||||
assert(bin != nullptr);
|
||||
return evalBinary(bin, ctx);
|
||||
}
|
||||
case AstType::UnaryExpr: {
|
||||
auto un = std::static_pointer_cast<Ast::UnaryExprAst>(exp);
|
||||
assert(un != nullptr);
|
||||
return evalUnary(un, ctx);
|
||||
}
|
||||
case AstType::TernaryExpr: {
|
||||
auto te = std::static_pointer_cast<Ast::TernaryExprAst>(exp);
|
||||
assert(te != nullptr);
|
||||
return evalTernary(te, ctx);
|
||||
}
|
||||
case AstType::MemberExpr:
|
||||
case AstType::IndexExpr: return evalLv(exp, ctx).get();
|
||||
|
||||
case AstType::FunctionCall: {
|
||||
auto fnCall = std::static_pointer_cast<Ast::FunctionCallExpr>(exp);
|
||||
assert(fnCall != nullptr);
|
||||
|
||||
Ast::Expression callee = fnCall->callee;
|
||||
ObjectPtr fnObj = eval(callee, ctx);
|
||||
if (fnObj->getTypeInfo() != ValueType::Function)
|
||||
{
|
||||
throw EvaluatorError(u8"ObjectNotCallable",
|
||||
std::format("Object `{}` isn't callable", fnObj->toString().toBasicString()),
|
||||
callee);
|
||||
}
|
||||
const Function &fn = fnObj->as<Function>();
|
||||
size_t fnId = fn.id;
|
||||
// const auto &fnNameOpt = ctx->getFunctionName(fnId);
|
||||
// const FString &fnName = (fnNameOpt ? *fnNameOpt :
|
||||
// u8"<anonymous>");
|
||||
|
||||
auto fnNameOpt = ctx->getFunctionName(fnId);
|
||||
if (!fnNameOpt && fn.closureContext) fnNameOpt = fn.closureContext->getFunctionName(fnId);
|
||||
|
||||
const FString &fnName = (fnNameOpt ? *fnNameOpt : u8"<anonymous>");
|
||||
|
||||
return evalFunctionCall(fn, fnCall->arg, fnName, ctx);
|
||||
}
|
||||
case AstType::FunctionLiteralExpr: {
|
||||
auto fnLiteral = std::static_pointer_cast<Ast::FunctionLiteralExprAst>(exp);
|
||||
assert(fnLiteral != nullptr);
|
||||
|
||||
Ast::BlockStatement body = nullptr;
|
||||
if (fnLiteral->isExprMode())
|
||||
{
|
||||
Ast::Expression exprBody = fnLiteral->getExprBody();
|
||||
assert(exprBody != nullptr);
|
||||
|
||||
const Ast::AstAddressInfo &aai = exprBody->getAAI();
|
||||
Ast::Return st = std::make_shared<Ast::ReturnSt>(exprBody);
|
||||
st->setAAI(aai);
|
||||
|
||||
body = std::make_shared<Ast::BlockStatementAst>();
|
||||
body->stmts.push_back(st); // convert to Ast::Statement
|
||||
body->setAAI(aai);
|
||||
}
|
||||
else
|
||||
{
|
||||
body = fnLiteral->getBlockBody();
|
||||
assert(body != nullptr);
|
||||
}
|
||||
Function fn(fnLiteral->paras, ValueType::Any, body, ctx
|
||||
/*
|
||||
pass the ctx(fnLiteral eval context) as closure context
|
||||
*/
|
||||
);
|
||||
return std::make_shared<Object>(std::move(fn));
|
||||
}
|
||||
case AstType::InitExpr: {
|
||||
auto initExpr = std::static_pointer_cast<Ast::InitExprAst>(exp);
|
||||
assert(initExpr != nullptr);
|
||||
return evalInitExpr(initExpr, ctx);
|
||||
}
|
||||
|
||||
case AstType::ListExpr: {
|
||||
auto lstExpr = std::static_pointer_cast<Ast::ListExprAst>(exp);
|
||||
assert(lstExpr != nullptr);
|
||||
|
||||
List list;
|
||||
for (auto &exp : lstExpr->val) { list.push_back(eval(exp, ctx)); }
|
||||
return std::make_shared<Object>(std::move(list));
|
||||
}
|
||||
|
||||
case AstType::MapExpr: {
|
||||
auto mapExpr = std::static_pointer_cast<Ast::MapExprAst>(exp);
|
||||
assert(mapExpr != nullptr);
|
||||
|
||||
Map map;
|
||||
for (auto &[key, value] : mapExpr->val) { map[eval(key, ctx)] = eval(value, ctx); }
|
||||
return std::make_shared<Object>(std::move(map));
|
||||
}
|
||||
|
||||
default: {
|
||||
throw RuntimeError(FString(std::format("err type of expr: {}", magic_enum::enum_name(type))));
|
||||
}
|
||||
}
|
||||
return Object::getNullInstance(); // ignore warning
|
||||
}
|
||||
};
|
||||
278
src/Evaluator/Core/EvalBinary.cpp
Normal file
278
src/Evaluator/Core/EvalBinary.cpp
Normal file
@@ -0,0 +1,278 @@
|
||||
#include <Evaluator/Value/LvObject.hpp>
|
||||
#include <Evaluator/Value/IntPool.hpp>
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
RvObject Evaluator::evalBinary(Ast::BinaryExpr bin, ContextPtr ctx)
|
||||
{
|
||||
using Ast::Operator;
|
||||
Operator op = bin->op;
|
||||
Ast::Expression lexp = bin->lexp, rexp = bin->rexp;
|
||||
switch (op)
|
||||
{
|
||||
case Operator::Add: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result = lhs->as<ValueType::IntClass>() + rhs->as<ValueType::IntClass>();
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
|
||||
return std::make_shared<Object>(*lhs + *rhs);
|
||||
}
|
||||
case Operator::Subtract: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result = lhs->as<ValueType::IntClass>() - rhs->as<ValueType::IntClass>();
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
|
||||
return std::make_shared<Object>(*lhs - *rhs);
|
||||
};
|
||||
case Operator::Multiply: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result = lhs->as<ValueType::IntClass>() * rhs->as<ValueType::IntClass>();
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
|
||||
return std::make_shared<Object>((*lhs) * (*rhs));
|
||||
};
|
||||
case Operator::Divide: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs / *rhs);
|
||||
};
|
||||
case Operator::Modulo: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass lv = lhs->as<ValueType::IntClass>();
|
||||
ValueType::IntClass rv = lhs->as<ValueType::IntClass>();
|
||||
if (rv == 0) { throw ValueError(FString(std::format("Modulo by zero: {} % {}", lv, rv))); }
|
||||
ValueType::IntClass result = lv / rv;
|
||||
ValueType::IntClass r = lv % rv;
|
||||
if (r != 0 && ((lv < 0) != (rv < 0))) { result -= 1; }
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
|
||||
return std::make_shared<Object>(*lhs % *rhs);
|
||||
};
|
||||
case Operator::Power: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result =
|
||||
std::pow(lhs->as<ValueType::IntClass>(), rhs->as<ValueType::IntClass>());
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
return std::make_shared<Object>(power(*lhs, *rhs));
|
||||
}
|
||||
case Operator::And: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs && *rhs);
|
||||
};
|
||||
case Operator::Or: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs || *rhs);
|
||||
};
|
||||
case Operator::Equal: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs == *rhs);
|
||||
}
|
||||
case Operator::NotEqual: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs != *rhs);
|
||||
}
|
||||
case Operator::Less: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs < *rhs);
|
||||
}
|
||||
case Operator::LessEqual: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs <= *rhs);
|
||||
}
|
||||
case Operator::Greater: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs > *rhs);
|
||||
}
|
||||
case Operator::GreaterEqual: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
return std::make_shared<Object>(*lhs >= *rhs);
|
||||
}
|
||||
case Operator::Is: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
const TypeInfo &lhsType = lhs->getTypeInfo();
|
||||
const TypeInfo &rhsType = rhs->getTypeInfo();
|
||||
|
||||
if (lhs->is<StructInstance>() && rhs->is<StructType>())
|
||||
{
|
||||
const StructInstance &si = lhs->as<StructInstance>();
|
||||
const StructType &st = rhs->as<StructType>();
|
||||
return std::make_shared<Object>(si.parentType == st.type);
|
||||
}
|
||||
if (lhs->is<StructInstance>() && rhs->is<InterfaceType>())
|
||||
{
|
||||
const StructInstance &si = lhs->as<StructInstance>();
|
||||
const InterfaceType &it = rhs->as<InterfaceType>();
|
||||
return std::make_shared<Object>(implements(si.parentType, it.type, ctx));
|
||||
}
|
||||
|
||||
if (ValueType::isTypeBuiltin(lhsType) && rhsType == ValueType::StructType)
|
||||
{
|
||||
const StructType &st = rhs->as<StructType>();
|
||||
const TypeInfo &type = st.type;
|
||||
/*
|
||||
如果是内置类型(e.g. Int, String)
|
||||
那么 eval出来String这个字，出来的是StructType
|
||||
而出来的StructType.type就不会是一个独立的TypeInfo,而是内置的ValueType::String
|
||||
依次我们可以判断内置类型
|
||||
|
||||
e.g:
|
||||
"123" is String
|
||||
L OP R
|
||||
|
||||
其中 L 类型为 String
|
||||
而 R 类型为 StructType (builtins.hpp) 中注册
|
||||
拿到 R 的 StructType, 其中的 type 为 String
|
||||
*/
|
||||
if (lhs->getTypeInfo() == type) { return Object::getTrueInstance(); }
|
||||
return Object::getFalseInstance();
|
||||
}
|
||||
|
||||
throw EvaluatorError(u8"TypeError",
|
||||
std::format("Unsupported operator `is` for '{}' && '{}'",
|
||||
prettyType(lhs).toBasicString(),
|
||||
prettyType(rhs).toBasicString()),
|
||||
bin->lexp);
|
||||
}
|
||||
|
||||
case Operator::BitAnd: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result = lhs->as<ValueType::IntClass>() & rhs->as<ValueType::IntClass>();
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
return std::make_shared<Object>(bit_and(*lhs, *rhs));
|
||||
}
|
||||
case Operator::BitOr: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result = lhs->as<ValueType::IntClass>() | rhs->as<ValueType::IntClass>();
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
return std::make_shared<Object>(bit_or(*lhs, *rhs));
|
||||
}
|
||||
case Operator::BitXor: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result = lhs->as<ValueType::IntClass>() ^ rhs->as<ValueType::IntClass>();
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
return std::make_shared<Object>(bit_xor(*lhs, *rhs));
|
||||
}
|
||||
case Operator::ShiftLeft: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result = lhs->as<ValueType::IntClass>() << rhs->as<ValueType::IntClass>();
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
return std::make_shared<Object>(shift_left(*lhs, *rhs));
|
||||
}
|
||||
case Operator::ShiftRight: {
|
||||
ObjectPtr lhs = eval(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
|
||||
if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
|
||||
{
|
||||
ValueType::IntClass result = lhs->as<ValueType::IntClass>() >> rhs->as<ValueType::IntClass>();
|
||||
return IntPool::getInstance().createInt(result);
|
||||
}
|
||||
return std::make_shared<Object>(shift_right(*lhs, *rhs));
|
||||
}
|
||||
|
||||
case Operator::Assign: {
|
||||
LvObject lv = evalLv(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
lv.set(rhs);
|
||||
return rhs;
|
||||
}
|
||||
case Operator::PlusAssign: {
|
||||
LvObject lv = evalLv(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
lv.set(std::make_shared<Object>(*(lv.get()) + *rhs));
|
||||
return rhs;
|
||||
}
|
||||
case Operator::MinusAssign: {
|
||||
LvObject lv = evalLv(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
lv.set(std::make_shared<Object>(*(lv.get()) - *rhs));
|
||||
return rhs;
|
||||
}
|
||||
case Operator::AsteriskAssign: {
|
||||
LvObject lv = evalLv(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
lv.set(std::make_shared<Object>(*(lv.get()) * (*rhs)));
|
||||
return rhs;
|
||||
}
|
||||
case Operator::SlashAssign: {
|
||||
LvObject lv = evalLv(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
lv.set(std::make_shared<Object>(*(lv.get()) / *rhs));
|
||||
return rhs;
|
||||
}
|
||||
case Operator::PercentAssign: {
|
||||
LvObject lv = evalLv(lexp, ctx);
|
||||
ObjectPtr rhs = eval(rexp, ctx);
|
||||
lv.set(std::make_shared<Object>(*(lv.get()) / *rhs));
|
||||
return rhs;
|
||||
}
|
||||
// case Operator::CaretAssign: {
|
||||
// LvObject lv = evalLv(lexp, ctx);
|
||||
// ObjectPtr rhs = eval(rexp, ctx);
|
||||
// lv.set(std::make_shared<Object>(
|
||||
// *(lv.get()) ^ *rhs));
|
||||
// }
|
||||
default:
|
||||
throw EvaluatorError(u8"UnsupportedOp",
|
||||
std::format("Unsupport operator '{}' for binary", magic_enum::enum_name(op)),
|
||||
bin);
|
||||
}
|
||||
}
|
||||
};
|
||||
175
src/Evaluator/Core/EvalFunctionCall.cpp
Normal file
175
src/Evaluator/Core/EvalFunctionCall.cpp
Normal file
@@ -0,0 +1,175 @@
|
||||
#include <Evaluator/Value/LvObject.hpp>
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
RvObject Evaluator::evalFunctionCall(const Function &fn,
|
||||
const Ast::FunctionArguments &fnArgs,
|
||||
const FString &fnName,
|
||||
ContextPtr ctx)
|
||||
{
|
||||
const Function &fnStruct = fn;
|
||||
Ast::FunctionCallArgs evaluatedArgs;
|
||||
if (fnStruct.isBuiltin)
|
||||
{
|
||||
for (const auto &argExpr : fnArgs.argv) { evaluatedArgs.argv.push_back(eval(argExpr, ctx)); }
|
||||
if (fnStruct.builtinParamCount != -1 && fnStruct.builtinParamCount != evaluatedArgs.getLength())
|
||||
{
|
||||
throw EvaluatorError(u8"BuiltinArgumentMismatchError",
|
||||
std::format("Builtin function '{}' expects {} arguments, but {} were provided",
|
||||
fnName.toBasicString(),
|
||||
fnStruct.builtinParamCount,
|
||||
evaluatedArgs.getLength()),
|
||||
fnArgs.argv.back());
|
||||
}
|
||||
return fnStruct.builtin(evaluatedArgs.argv);
|
||||
}
|
||||
|
||||
// check argument, all types of parameters
|
||||
Ast::FunctionParameters fnParas = fnStruct.paras;
|
||||
|
||||
// create new context for function call
|
||||
auto newContext = std::make_shared<Context>(FString(std::format("<Function {}()>", fnName.toBasicString())),
|
||||
fnStruct.closureContext);
|
||||
|
||||
if (fnParas.variadic)
|
||||
goto VariadicFilling;
|
||||
else
|
||||
goto NormalFilling;
|
||||
|
||||
NormalFilling: {
|
||||
if (fnArgs.getLength() < fnParas.posParas.size() || fnArgs.getLength() > fnParas.size())
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Function '{}' expects {} to {} arguments, but {} were provided",
|
||||
fnName.toBasicString(),
|
||||
fnParas.posParas.size(),
|
||||
fnParas.size(),
|
||||
fnArgs.getLength())));
|
||||
}
|
||||
|
||||
// positional parameters type check
|
||||
size_t i;
|
||||
for (i = 0; i < fnParas.posParas.size(); i++)
|
||||
{
|
||||
TypeInfo expectedType(fnParas.posParas[i].second); // look up type info, if exists a type with the
|
||||
// name, use it, else throw
|
||||
ObjectPtr argVal = eval(fnArgs.argv[i], ctx);
|
||||
TypeInfo actualType = argVal->getTypeInfo();
|
||||
if (!isTypeMatch(expectedType, argVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(u8"ArgumentTypeMismatchError",
|
||||
std::format("In function '{}', argument '{}' expects type '{}', but got type '{}'",
|
||||
fnName.toBasicString(),
|
||||
fnParas.posParas[i].first.toBasicString(),
|
||||
expectedType.toString().toBasicString(),
|
||||
actualType.toString().toBasicString()),
|
||||
fnArgs.argv[i]);
|
||||
}
|
||||
evaluatedArgs.argv.push_back(argVal);
|
||||
}
|
||||
// default parameters type check
|
||||
for (; i < fnArgs.getLength(); i++)
|
||||
{
|
||||
size_t defParamIndex = i - fnParas.posParas.size();
|
||||
TypeInfo expectedType(fnParas.defParas[defParamIndex].second.first);
|
||||
|
||||
ObjectPtr defaultVal = eval(fnParas.defParas[defParamIndex].second.second, ctx);
|
||||
if (!isTypeMatch(expectedType, defaultVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"DefaultParameterTypeError",
|
||||
std::format(
|
||||
"In function '{}', default parameter '{}' has type '{}', which does not match the expected type '{}'",
|
||||
fnName.toBasicString(),
|
||||
fnParas.defParas[defParamIndex].first.toBasicString(),
|
||||
prettyType(defaultVal).toBasicString(),
|
||||
expectedType.toString().toBasicString()),
|
||||
fnArgs.argv[i]);
|
||||
}
|
||||
|
||||
ObjectPtr argVal = eval(fnArgs.argv[i], ctx);
|
||||
TypeInfo actualType = argVal->getTypeInfo();
|
||||
if (!isTypeMatch(expectedType, argVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(u8"ArgumentTypeMismatchError",
|
||||
std::format("In function '{}', argument '{}' expects type '{}', but got type '{}'",
|
||||
fnName.toBasicString(),
|
||||
fnParas.defParas[defParamIndex].first.toBasicString(),
|
||||
expectedType.toString().toBasicString(),
|
||||
actualType.toString().toBasicString()),
|
||||
fnArgs.argv[i]);
|
||||
}
|
||||
evaluatedArgs.argv.push_back(argVal);
|
||||
}
|
||||
// default parameters filling
|
||||
for (; i < fnParas.size(); i++)
|
||||
{
|
||||
size_t defParamIndex = i - fnParas.posParas.size();
|
||||
ObjectPtr defaultVal = eval(fnParas.defParas[defParamIndex].second.second, ctx);
|
||||
evaluatedArgs.argv.push_back(defaultVal);
|
||||
}
|
||||
|
||||
// define parameters in new context
|
||||
for (size_t j = 0; j < fnParas.size(); j++)
|
||||
{
|
||||
FString paramName;
|
||||
TypeInfo paramType;
|
||||
if (j < fnParas.posParas.size())
|
||||
{
|
||||
paramName = fnParas.posParas[j].first;
|
||||
paramType = TypeInfo(fnParas.posParas[j].second);
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t defParamIndex = j - fnParas.posParas.size();
|
||||
paramName = fnParas.defParas[defParamIndex].first;
|
||||
paramType = TypeInfo(fnParas.defParas[defParamIndex].second.first);
|
||||
}
|
||||
AccessModifier argAm = AccessModifier::Const;
|
||||
newContext->def(paramName, paramType, argAm, evaluatedArgs.argv[j]);
|
||||
}
|
||||
goto ExecuteBody;
|
||||
}
|
||||
|
||||
VariadicFilling: {
|
||||
List list;
|
||||
for (auto &exp : fnArgs.argv)
|
||||
{
|
||||
list.push_back(eval(exp, ctx)); // eval arguments in current scope
|
||||
}
|
||||
newContext->def(fnParas.variadicPara, ValueType::List, AccessModifier::Const, std::make_shared<Object>(list));
|
||||
goto ExecuteBody;
|
||||
}
|
||||
|
||||
ExecuteBody: {
|
||||
// execute function body
|
||||
ObjectPtr retVal = Object::getNullInstance();
|
||||
for (const auto &stmt : fnStruct.body->stmts)
|
||||
{
|
||||
StatementResult sr = evalStatement(stmt, newContext);
|
||||
if (sr.isError())
|
||||
{
|
||||
throw EvaluatorError(u8"UncaughtExceptionError",
|
||||
std::format("Uncaught exception: {}", sr.result->toString().toBasicString()),
|
||||
stmt);
|
||||
}
|
||||
if (!sr.isNormal())
|
||||
{
|
||||
retVal = sr.result;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!isTypeMatch(fnStruct.retType, retVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(u8"ReturnTypeMismatchError",
|
||||
std::format("Function '{}' expects return type '{}', but got type '{}'",
|
||||
fnName.toBasicString(),
|
||||
fnStruct.retType.toString().toBasicString(),
|
||||
prettyType(retVal).toBasicString()),
|
||||
fnStruct.body);
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
}
|
||||
};
|
||||
362
src/Evaluator/Core/EvalInitExpr.cpp
Normal file
362
src/Evaluator/Core/EvalInitExpr.cpp
Normal file
@@ -0,0 +1,362 @@
|
||||
#include <Evaluator/Value/LvObject.hpp>
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
RvObject Evaluator::evalInitExpr(Ast::InitExpr initExpr, ContextPtr ctx)
|
||||
{
|
||||
LvObject structeLv = evalLv(initExpr->structe, ctx);
|
||||
ObjectPtr structTypeVal = structeLv.get();
|
||||
const FString &structName = structeLv.name();
|
||||
if (!structTypeVal->is<StructType>())
|
||||
{
|
||||
throw EvaluatorError(u8"NotAStructTypeError",
|
||||
std::format("'{}' is not a structure type", structName.toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
const StructType &structT = structTypeVal->as<StructType>();
|
||||
|
||||
if (structT.builtin)
|
||||
{
|
||||
const TypeInfo &type = structT.type;
|
||||
auto &args = initExpr->args;
|
||||
size_t argSize = args.size();
|
||||
|
||||
if (argSize > 1)
|
||||
{
|
||||
throw EvaluatorError(u8"StructInitArgumentMismatchError",
|
||||
std::format("Builtin class `{}` expects 0 or 1 argument, but {} were provided",
|
||||
type.toString().toBasicString(),
|
||||
argSize),
|
||||
initExpr);
|
||||
}
|
||||
|
||||
// default value
|
||||
if (argSize == 0)
|
||||
{
|
||||
if (type == ValueType::Any || type == ValueType::Null || type == ValueType::Function)
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"BuiltinNotConstructibleError",
|
||||
std::format("Builtin type `{}` cannot be constructed", type.toString().toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
return std::make_shared<Object>(Object::defaultValue(type));
|
||||
}
|
||||
|
||||
ObjectPtr val = eval(args[0].second, ctx);
|
||||
|
||||
auto err = [&](const char *msg) {
|
||||
throw EvaluatorError(u8"BuiltinInitTypeMismatchError",
|
||||
std::format("Builtin `{}` constructor {}", type.toString().toBasicString(), msg),
|
||||
initExpr);
|
||||
};
|
||||
|
||||
// ===================== Int =====================
|
||||
if (type == ValueType::Int)
|
||||
{
|
||||
if (!val->is<ValueType::IntClass>()) err("expects Int");
|
||||
return std::make_shared<Object>(val->as<ValueType::IntClass>());
|
||||
}
|
||||
|
||||
// ===================== Double =====================
|
||||
if (type == ValueType::Double)
|
||||
{
|
||||
if (!val->is<ValueType::DoubleClass>()) err("expects Double");
|
||||
return std::make_shared<Object>(val->as<ValueType::DoubleClass>());
|
||||
}
|
||||
|
||||
// ===================== Bool =====================
|
||||
if (type == ValueType::Bool)
|
||||
{
|
||||
if (!val->is<ValueType::BoolClass>()) err("expects Bool");
|
||||
return std::make_shared<Object>(val->as<ValueType::BoolClass>());
|
||||
}
|
||||
|
||||
// ===================== String =====================
|
||||
if (type == ValueType::String)
|
||||
{
|
||||
if (!val->is<ValueType::StringClass>()) err("expects String");
|
||||
return std::make_shared<Object>(val->as<ValueType::StringClass>());
|
||||
}
|
||||
|
||||
// ===================== Null =====================
|
||||
if (type == ValueType::Null)
|
||||
{
|
||||
// Null basically ignores input but keep invariant strict:
|
||||
if (!val->is<ValueType::NullClass>()) err("expects Null");
|
||||
return Object::getNullInstance();
|
||||
}
|
||||
|
||||
// ===================== List =====================
|
||||
if (type == ValueType::List)
|
||||
{
|
||||
if (!val->is<List>()) err("expects List");
|
||||
|
||||
const auto &src = val->as<List>();
|
||||
auto copied = std::make_shared<Object>(List{});
|
||||
|
||||
auto &dst = copied->as<List>();
|
||||
dst.reserve(src.size());
|
||||
for (auto &e : src) dst.push_back(e); // shallow element copy, but new container
|
||||
|
||||
return copied;
|
||||
}
|
||||
|
||||
// ===================== Map =====================
|
||||
if (type == ValueType::Map)
|
||||
{
|
||||
if (!val->is<Map>()) err("expects Map");
|
||||
|
||||
const auto &src = val->as<Map>();
|
||||
auto copied = std::make_shared<Object>(Map{});
|
||||
|
||||
auto &dst = copied->as<Map>();
|
||||
for (auto &[k, v] : src) dst.emplace(k, v);
|
||||
|
||||
return copied;
|
||||
}
|
||||
|
||||
throw EvaluatorError(
|
||||
u8"BuiltinNotConstructibleError",
|
||||
std::format("Builtin type `{}` cannot be constructed", type.toString().toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
|
||||
ContextPtr defContext = structT.defContext; // definition context
|
||||
// check init args
|
||||
|
||||
size_t minArgs = 0;
|
||||
size_t maxArgs = structT.fields.size();
|
||||
|
||||
for (auto &f : structT.fields)
|
||||
{
|
||||
if (f.defaultValue == nullptr) minArgs++;
|
||||
}
|
||||
|
||||
size_t got = initExpr->args.size();
|
||||
if (got > maxArgs || got < minArgs)
|
||||
{
|
||||
throw EvaluatorError(u8"StructInitArgumentMismatchError",
|
||||
std::format("Structure '{}' expects {} to {} fields, but {} were provided",
|
||||
structName.toBasicString(),
|
||||
minArgs,
|
||||
maxArgs,
|
||||
initExpr->args.size()),
|
||||
initExpr);
|
||||
}
|
||||
|
||||
std::vector<std::pair<FString, ObjectPtr>> evaluatedArgs;
|
||||
|
||||
auto evalArguments = [&evaluatedArgs, initExpr, ctx, this]() {
|
||||
for (const auto &[argName, argExpr] : initExpr->args)
|
||||
{
|
||||
evaluatedArgs.push_back({argName, eval(argExpr, ctx)});
|
||||
}
|
||||
};
|
||||
|
||||
ContextPtr instanceCtx =
|
||||
std::make_shared<Context>(FString(std::format("<StructInstance {}>", structName.toBasicString())), ctx);
|
||||
/*
|
||||
3 ways of calling constructor
|
||||
.1 Person {"Fig", 1, "IDK"};
|
||||
.2 Person {name: "Fig", age: 1, sex: "IDK"}; // can be unordered
|
||||
.3 Person {name, age, sex};
|
||||
*/
|
||||
{
|
||||
using enum Ast::InitExprAst::InitMode;
|
||||
if (initExpr->initMode == Positional)
|
||||
{
|
||||
evalArguments();
|
||||
|
||||
for (size_t i = 0; i < maxArgs; ++i)
|
||||
{
|
||||
const Field &field = structT.fields[i];
|
||||
const FString &fieldName = field.name;
|
||||
const TypeInfo &expectedType = field.type;
|
||||
if (i >= evaluatedArgs.size())
|
||||
{
|
||||
// we've checked argument count before, so here
|
||||
// must be a default value
|
||||
|
||||
// evaluate default value in definition context
|
||||
ObjectPtr defaultVal = eval(field.defaultValue,
|
||||
ctx); // it can't be null here
|
||||
|
||||
// type check
|
||||
if (!isTypeMatch(expectedType, defaultVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"StructFieldTypeMismatchError",
|
||||
std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
|
||||
structName.toBasicString(),
|
||||
fieldName.toBasicString(),
|
||||
expectedType.toString().toBasicString(),
|
||||
prettyType(defaultVal).toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
|
||||
instanceCtx->def(fieldName, expectedType, field.am, defaultVal);
|
||||
continue;
|
||||
}
|
||||
|
||||
const ObjectPtr &argVal = evaluatedArgs[i].second;
|
||||
if (!isTypeMatch(expectedType, argVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"StructFieldTypeMismatchError",
|
||||
std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
|
||||
structName.toBasicString(),
|
||||
fieldName.toBasicString(),
|
||||
expectedType.toString().toBasicString(),
|
||||
prettyType(argVal).toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
instanceCtx->def(fieldName, expectedType, field.am, argVal);
|
||||
}
|
||||
}
|
||||
else if (initExpr->initMode == Named)
|
||||
{
|
||||
evalArguments();
|
||||
|
||||
// named
|
||||
for (size_t i = 0; i < maxArgs; ++i)
|
||||
{
|
||||
const Field &field = structT.fields[i];
|
||||
const FString &fieldName = (field.name.empty() ? evaluatedArgs[i].first : field.name);
|
||||
if (instanceCtx->containsInThisScope(fieldName))
|
||||
{
|
||||
throw EvaluatorError(u8"StructFieldRedeclarationError",
|
||||
std::format("Field '{}' already initialized in structure '{}'",
|
||||
fieldName.toBasicString(),
|
||||
structName.toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
if (i + 1 > got)
|
||||
{
|
||||
// use default value //
|
||||
// evaluate default value in definition context
|
||||
ObjectPtr defaultVal = eval(field.defaultValue,
|
||||
defContext); // it can't be null here
|
||||
|
||||
// type check
|
||||
const TypeInfo &expectedType = field.type;
|
||||
if (!isTypeMatch(expectedType, defaultVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"StructFieldTypeMismatchError",
|
||||
std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
|
||||
structName.toBasicString(),
|
||||
fieldName.toBasicString(),
|
||||
expectedType.toString().toBasicString(),
|
||||
prettyType(defaultVal).toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
|
||||
instanceCtx->def(fieldName, field.type, field.am, defaultVal);
|
||||
continue;
|
||||
}
|
||||
const ObjectPtr &argVal = evaluatedArgs[i].second;
|
||||
if (!isTypeMatch(field.type, argVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"StructFieldTypeMismatchError",
|
||||
std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
|
||||
structName.toBasicString(),
|
||||
fieldName.toBasicString(),
|
||||
field.type.toString().toBasicString(),
|
||||
prettyType(argVal).toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
instanceCtx->def(fieldName, field.type, field.am, argVal);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// shorthand, can be unordered
|
||||
// in this mode, initExpr args are all VarExpr
|
||||
// field name is the variable name
|
||||
for (const auto &[argName, argExpr] : initExpr->args)
|
||||
{
|
||||
// assert(argExpr->getType() == Ast::AstType::VarExpr);
|
||||
// argName is var name
|
||||
const ObjectPtr &argVal = eval(argExpr, ctx); // get the value
|
||||
// find field
|
||||
auto fieldIt = std::find_if(structT.fields.begin(),
|
||||
structT.fields.end(),
|
||||
[&argName](const Field &f) { return f.name == argName; });
|
||||
if (fieldIt == structT.fields.end())
|
||||
{
|
||||
throw EvaluatorError(u8"StructFieldNotFoundError",
|
||||
std::format("Field '{}' not found in structure '{}'",
|
||||
argName.toBasicString(),
|
||||
structName.toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
const Field &field = *fieldIt;
|
||||
if (!isTypeMatch(field.type, argVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"StructFieldTypeMismatchError",
|
||||
std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
|
||||
structName.toBasicString(),
|
||||
field.name.toBasicString(),
|
||||
field.type.toString().toBasicString(),
|
||||
prettyType(argVal).toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
// field.name is argName (var name)
|
||||
// Point{x=x, y=y} --> Point{x, y}
|
||||
|
||||
instanceCtx->def(field.name, field.type, field.am, argVal);
|
||||
}
|
||||
// fill default values
|
||||
size_t currentFieldCount =
|
||||
initExpr->args.size(); // we have already check argument count, min <= got <= max
|
||||
// so remain fields start from currentFieldCount to maxArgs
|
||||
for (size_t i = currentFieldCount; i < maxArgs; ++i)
|
||||
{
|
||||
const Field &field = structT.fields[i];
|
||||
|
||||
// evaluate default value in definition context
|
||||
ObjectPtr defaultVal = eval(field.defaultValue,
|
||||
defContext); // it can't be null here
|
||||
|
||||
// type check
|
||||
if (!isTypeMatch(field.type, defaultVal, ctx))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"StructFieldTypeMismatchError",
|
||||
std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
|
||||
structName.toBasicString(),
|
||||
field.name.toBasicString(),
|
||||
field.type.toString().toBasicString(),
|
||||
prettyType(defaultVal).toBasicString()),
|
||||
initExpr);
|
||||
}
|
||||
|
||||
instanceCtx->def(field.name, field.type, field.am, defaultVal);
|
||||
}
|
||||
}
|
||||
}
|
||||
ContextPtr stDefCtx = structT.defContext;
|
||||
|
||||
// load struct method
|
||||
for (auto &[id, fn] : stDefCtx->getFunctions())
|
||||
{
|
||||
auto funcNameOpt = stDefCtx->getFunctionName(id);
|
||||
assert(funcNameOpt.has_value());
|
||||
|
||||
const FString &funcName = *funcNameOpt;
|
||||
auto funcSlot = stDefCtx->get(funcName);
|
||||
|
||||
instanceCtx->def(funcName,
|
||||
ValueType::Function,
|
||||
funcSlot->am,
|
||||
std::make_shared<Object>(Function(fn.paras, fn.retType, fn.body, instanceCtx)));
|
||||
}
|
||||
|
||||
return std::make_shared<Object>(StructInstance(structT.type, instanceCtx));
|
||||
}
|
||||
};
|
||||
191
src/Evaluator/Core/EvalLvObject.cpp
Normal file
191
src/Evaluator/Core/EvalLvObject.cpp
Normal file
@@ -0,0 +1,191 @@
|
||||
#include <Evaluator/Value/LvObject.hpp>
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
LvObject Evaluator::evalVarExpr(Ast::VarExpr var, ContextPtr ctx)
|
||||
{
|
||||
const FString &name = var->name;
|
||||
if (!ctx->contains(name)) { throw EvaluatorError(u8"UndeclaredIdentifierError", name, var); }
|
||||
return LvObject(ctx->get(name), ctx);
|
||||
}
|
||||
LvObject Evaluator::evalMemberExpr(Ast::MemberExpr me, ContextPtr ctx)
|
||||
{
|
||||
// LvObject base = evalLv(me->base, ctx);
|
||||
RvObject baseVal = eval(me->base, ctx);
|
||||
const FString &member = me->member;
|
||||
if (baseVal->getTypeInfo() == ValueType::Module)
|
||||
{
|
||||
const Module &mod = baseVal->as<Module>();
|
||||
if (mod.ctx->contains(member) && mod.ctx->isVariablePublic(member))
|
||||
{
|
||||
return LvObject(mod.ctx->get(member), ctx);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw EvaluatorError(u8"VariableNotFoundError",
|
||||
std::format("`{}` has not variable '{}', check if it is public",
|
||||
baseVal->toString().toBasicString(),
|
||||
member.toBasicString()),
|
||||
me->base);
|
||||
}
|
||||
}
|
||||
if (baseVal->hasMemberFunction(member))
|
||||
{
|
||||
return LvObject(std::make_shared<VariableSlot>(
|
||||
member,
|
||||
std::make_shared<Object>(Function(baseVal->getMemberFunction(member),
|
||||
baseVal->getMemberFunctionParaCount(member))),
|
||||
ValueType::Function,
|
||||
AccessModifier::PublicConst),
|
||||
ctx); // fake l-value
|
||||
}
|
||||
|
||||
if (ctx->hasMethodImplemented(baseVal->getTypeInfo(), member))
|
||||
{
|
||||
// builtin type implementation!
|
||||
// e.g. impl xxx for Int
|
||||
|
||||
auto &fn = ctx->getImplementedMethod(baseVal->getTypeInfo(), member);
|
||||
Function boundFn(fn.paras,
|
||||
fn.retType,
|
||||
fn.body,
|
||||
ctx // current context
|
||||
);
|
||||
return LvObject(
|
||||
std::make_shared<VariableSlot>(
|
||||
member, std::make_shared<Object>(boundFn), ValueType::Function, AccessModifier::PublicConst),
|
||||
ctx);
|
||||
}
|
||||
|
||||
if (baseVal->getTypeInfo() != ValueType::StructInstance) // and not member function found
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"NoAttributeError",
|
||||
std::format("`{}` has not attribute '{}'", baseVal->toString().toBasicString(), member.toBasicString()),
|
||||
me->base);
|
||||
}
|
||||
const StructInstance &si = baseVal->as<StructInstance>();
|
||||
if (ctx->hasMethodImplemented(si.parentType, member))
|
||||
{
|
||||
auto &fn = ctx->getImplementedMethod(si.parentType, member);
|
||||
Function boundFn(fn.paras,
|
||||
fn.retType,
|
||||
fn.body,
|
||||
si.localContext // create a new function and set closure context
|
||||
// to struct instance context
|
||||
);
|
||||
return LvObject(
|
||||
std::make_shared<VariableSlot>(
|
||||
member, std::make_shared<Object>(boundFn), ValueType::Function, AccessModifier::PublicConst),
|
||||
ctx);
|
||||
}
|
||||
else if (si.localContext->containsInThisScope(member) && si.localContext->isVariablePublic(member))
|
||||
{
|
||||
return LvObject(si.localContext->get(member), ctx);
|
||||
}
|
||||
else if (ctx->hasDefaultImplementedMethod(si.parentType, member))
|
||||
{
|
||||
const auto &ifm = ctx->getDefaultImplementedMethod(si.parentType, member);
|
||||
Function fn(ifm.paras, actualType(eval(ifm.returnType, ctx)), ifm.defaultBody, ctx);
|
||||
|
||||
return LvObject(std::make_shared<VariableSlot>(
|
||||
member, std::make_shared<Object>(fn), ValueType::Function, AccessModifier::PublicConst),
|
||||
ctx);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw EvaluatorError(u8"NoAttributeError",
|
||||
std::format("`{}` has not attribute '{}' and no interfaces have been implemented it",
|
||||
baseVal->toString().toBasicString(),
|
||||
member.toBasicString()),
|
||||
me->base);
|
||||
}
|
||||
}
|
||||
LvObject Evaluator::evalIndexExpr(Ast::IndexExpr ie, ContextPtr ctx)
|
||||
{
|
||||
LvObject base = evalLv(ie->base, ctx);
|
||||
RvObject index = eval(ie->index, ctx);
|
||||
|
||||
const TypeInfo &type = base.get()->getTypeInfo();
|
||||
|
||||
if (type == ValueType::List)
|
||||
{
|
||||
if (index->getTypeInfo() != ValueType::Int)
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"TypeError",
|
||||
std::format("Type `List` indices must be `Int`, got '{}'", prettyType(index).toBasicString()),
|
||||
ie->index);
|
||||
}
|
||||
List &list = base.get()->as<List>();
|
||||
ValueType::IntClass indexVal = index->as<ValueType::IntClass>();
|
||||
if (indexVal >= list.size())
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"IndexOutOfRangeError",
|
||||
std::format("Index {} out of list `{}` range", indexVal, base.get()->toString().toBasicString()),
|
||||
ie->index);
|
||||
}
|
||||
return LvObject(base.get(), indexVal, LvObject::Kind::ListElement, ctx);
|
||||
}
|
||||
else if (type == ValueType::Map) { return LvObject(base.get(), index, LvObject::Kind::MapElement, ctx); }
|
||||
else if (type == ValueType::String)
|
||||
{
|
||||
if (index->getTypeInfo() != ValueType::Int)
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"TypeError",
|
||||
std::format("Type `String` indices must be `Int`, got '{}'", prettyType(index).toBasicString()),
|
||||
ie->index);
|
||||
}
|
||||
FString &string = base.get()->as<ValueType::StringClass>();
|
||||
ValueType::IntClass indexVal = index->as<ValueType::IntClass>();
|
||||
if (indexVal >= string.length())
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"IndexOutOfRangeError",
|
||||
std::format("Index {} out of string `{}` range", indexVal, base.get()->toString().toBasicString()),
|
||||
ie->index);
|
||||
}
|
||||
return LvObject(base.get(), indexVal, LvObject::Kind::StringElement, ctx);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"NoSubscriptableError",
|
||||
std::format("`{}` object is not subscriptable", base.declaredType().toString().toBasicString()),
|
||||
ie->base);
|
||||
}
|
||||
}
|
||||
LvObject Evaluator::evalLv(Ast::Expression exp, ContextPtr ctx)
|
||||
{
|
||||
using Ast::Operator;
|
||||
using Ast::AstType;
|
||||
switch (exp->getType())
|
||||
{
|
||||
case AstType::VarExpr: {
|
||||
Ast::VarExpr var = std::static_pointer_cast<Ast::VarExprAst>(exp);
|
||||
assert(var != nullptr);
|
||||
return evalVarExpr(var, ctx);
|
||||
}
|
||||
case AstType::MemberExpr: {
|
||||
Ast::MemberExpr me = std::static_pointer_cast<Ast::MemberExprAst>(exp);
|
||||
assert(me != nullptr);
|
||||
return evalMemberExpr(me, ctx);
|
||||
}
|
||||
case AstType::IndexExpr: {
|
||||
Ast::IndexExpr ie = std::static_pointer_cast<Ast::IndexExprAst>(exp);
|
||||
assert(ie != nullptr);
|
||||
return evalIndexExpr(ie, ctx);
|
||||
}
|
||||
default: {
|
||||
throw EvaluatorError(
|
||||
u8"TypeError",
|
||||
std::format("Expression '{}' doesn't refer to a lvalue", exp->typeName().toBasicString()),
|
||||
exp);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
513
src/Evaluator/Core/EvalStatement.cpp
Normal file
513
src/Evaluator/Core/EvalStatement.cpp
Normal file
@@ -0,0 +1,513 @@
|
||||
#include <Evaluator/Value/LvObject.hpp>
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
#include <Utils/utils.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
StatementResult Evaluator::evalStatement(Ast::Statement stmt, ContextPtr ctx)
|
||||
{
|
||||
using enum Ast::AstType;
|
||||
switch (stmt->getType())
|
||||
{
|
||||
case ImportSt: {
|
||||
auto i = std::static_pointer_cast<Ast::ImportSt>(stmt);
|
||||
assert(i != nullptr);
|
||||
return evalImportSt(i, ctx);
|
||||
}
|
||||
case VarDefSt: {
|
||||
auto varDef = std::static_pointer_cast<Ast::VarDefAst>(stmt);
|
||||
assert(varDef != nullptr);
|
||||
|
||||
if (ctx->containsInThisScope(varDef->name))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"RedeclarationError",
|
||||
std::format("Variable `{}` already declared in this scope", varDef->name.toBasicString()),
|
||||
varDef);
|
||||
}
|
||||
|
||||
RvObject value = nullptr;
|
||||
if (varDef->expr) { value = eval(varDef->expr, ctx); }
|
||||
|
||||
TypeInfo declaredType; // default is Any
|
||||
const Ast::Expression &declaredTypeExp = varDef->declaredType;
|
||||
|
||||
if (varDef->followupType) { declaredType = actualType(value); }
|
||||
else if (declaredTypeExp)
|
||||
{
|
||||
ObjectPtr declaredTypeValue = eval(declaredTypeExp, ctx);
|
||||
declaredType = actualType(declaredTypeValue);
|
||||
|
||||
if (value != nullptr && !isTypeMatch(declaredType, value, ctx))
|
||||
{
|
||||
throw EvaluatorError(u8"TypeError",
|
||||
std::format("Variable `{}` expects init-value type `{}`, but got '{}'",
|
||||
varDef->name.toBasicString(),
|
||||
prettyType(declaredTypeValue).toBasicString(),
|
||||
prettyType(value).toBasicString()),
|
||||
varDef->expr);
|
||||
}
|
||||
else if (value == nullptr)
|
||||
{
|
||||
value = std::make_shared<Object>(Object::defaultValue(declaredType));
|
||||
} // else -> Ok
|
||||
} // else -> type is Any (default)
|
||||
AccessModifier am =
|
||||
(varDef->isConst ? (varDef->isPublic ? AccessModifier::PublicConst : AccessModifier::Const) :
|
||||
(varDef->isPublic ? AccessModifier::Public : AccessModifier::Normal));
|
||||
ctx->def(varDef->name, declaredType, am, value);
|
||||
return StatementResult::normal();
|
||||
}
|
||||
|
||||
case FunctionDefSt: {
|
||||
auto fnDef = std::static_pointer_cast<Ast::FunctionDefSt>(stmt);
|
||||
assert(fnDef != nullptr);
|
||||
|
||||
const FString &fnName = fnDef->name;
|
||||
if (ctx->containsInThisScope(fnName))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"RedeclarationError",
|
||||
std::format("Function `{}` already declared in this scope", fnName.toBasicString()),
|
||||
fnDef);
|
||||
}
|
||||
TypeInfo returnType = ValueType::Any;
|
||||
if (fnDef->retType)
|
||||
{
|
||||
ObjectPtr returnTypeValue = eval(fnDef->retType, ctx);
|
||||
returnType = actualType(returnTypeValue);
|
||||
}
|
||||
|
||||
Function fn(fnDef->paras, returnType, fnDef->body, ctx);
|
||||
ctx->def(fnName,
|
||||
ValueType::Function,
|
||||
(fnDef->isPublic ? AccessModifier::PublicConst : AccessModifier::Const),
|
||||
std::make_shared<Object>(fn));
|
||||
return StatementResult::normal();
|
||||
}
|
||||
|
||||
case StructSt: {
|
||||
auto stDef = std::static_pointer_cast<Ast::StructDefSt>(stmt);
|
||||
assert(stDef != nullptr);
|
||||
|
||||
if (ctx->containsInThisScope(stDef->name))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"RedeclarationError",
|
||||
std::format("Structure '{}' already defined in this scope", stDef->name.toBasicString()),
|
||||
stDef);
|
||||
}
|
||||
std::vector<Field> fields;
|
||||
std::vector<FString> _fieldNames;
|
||||
for (Ast::StructDefField field : stDef->fields)
|
||||
{
|
||||
if (Utils::vectorContains(field.fieldName, _fieldNames))
|
||||
{
|
||||
throw EvaluatorError(u8"RedeclarationError",
|
||||
std::format("Field '{}' already defined in structure '{}'",
|
||||
field.fieldName.toBasicString(),
|
||||
stDef->name.toBasicString()),
|
||||
stDef);
|
||||
}
|
||||
TypeInfo fieldType = ValueType::Any;
|
||||
if (field.declaredType)
|
||||
{
|
||||
ObjectPtr declaredTypeValue = eval(field.declaredType, ctx);
|
||||
fieldType = actualType(declaredTypeValue);
|
||||
}
|
||||
|
||||
fields.push_back(Field(field.am, field.fieldName, fieldType, field.defaultValueExpr));
|
||||
}
|
||||
ContextPtr defContext = std::make_shared<Context>(FString(std::format("<Struct {} at {}:{}>",
|
||||
stDef->name.toBasicString(),
|
||||
stDef->getAAI().line,
|
||||
stDef->getAAI().column)),
|
||||
ctx);
|
||||
const Ast::BlockStatement &body = stDef->body;
|
||||
for (auto &st : body->stmts)
|
||||
{
|
||||
if (st->getType() != Ast::AstType::FunctionDefSt)
|
||||
{
|
||||
throw EvaluatorError(u8"UnexpectedStatementInStructError",
|
||||
std::format("Unexpected statement `{}` in struct declaration",
|
||||
st->toString().toBasicString()),
|
||||
st);
|
||||
}
|
||||
evalStatement(st, defContext); // function def st
|
||||
}
|
||||
|
||||
AccessModifier am = (stDef->isPublic ? AccessModifier::PublicConst : AccessModifier::Const);
|
||||
TypeInfo type(stDef->name, true); // register type name
|
||||
ctx->def(stDef->name,
|
||||
ValueType::StructType,
|
||||
am,
|
||||
std::make_shared<Object>(StructType(type, defContext, fields)));
|
||||
return StatementResult::normal();
|
||||
}
|
||||
|
||||
case InterfaceDefSt: {
|
||||
auto ifd = std::static_pointer_cast<Ast::InterfaceDefAst>(stmt);
|
||||
assert(ifd != nullptr);
|
||||
|
||||
const FString &interfaceName = ifd->name;
|
||||
|
||||
if (ctx->containsInThisScope(interfaceName))
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"RedeclarationError",
|
||||
std::format("Interface `{}` already declared in this scope", interfaceName.toBasicString()),
|
||||
ifd);
|
||||
}
|
||||
TypeInfo type(interfaceName, true); // register interface
|
||||
ctx->def(interfaceName,
|
||||
type,
|
||||
(ifd->isPublic ? AccessModifier::PublicConst : AccessModifier::Const),
|
||||
std::make_shared<Object>(InterfaceType(type, ifd->methods)));
|
||||
return StatementResult::normal();
|
||||
}
|
||||
|
||||
case ImplementSt: {
|
||||
auto ip = std::static_pointer_cast<Ast::ImplementAst>(stmt);
|
||||
assert(ip != nullptr);
|
||||
|
||||
TypeInfo structType(ip->structName);
|
||||
TypeInfo interfaceType(ip->interfaceName);
|
||||
if (ctx->hasImplRegisted(structType, interfaceType))
|
||||
{
|
||||
throw EvaluatorError(u8"DuplicateImplError",
|
||||
std::format("Duplicate implement `{}` for `{}`",
|
||||
interfaceType.toString().toBasicString(),
|
||||
structType.toString().toBasicString()),
|
||||
ip);
|
||||
}
|
||||
if (!ctx->contains(ip->interfaceName))
|
||||
{
|
||||
throw EvaluatorError(u8"InterfaceNotFoundError",
|
||||
std::format("Interface '{}' not found", ip->interfaceName.toBasicString()),
|
||||
ip);
|
||||
}
|
||||
if (!ctx->contains(ip->structName))
|
||||
{
|
||||
throw EvaluatorError(u8"StructNotFoundError",
|
||||
std::format("Struct '{}' not found", ip->structName.toBasicString()),
|
||||
ip);
|
||||
}
|
||||
auto interfaceSlot = ctx->get(ip->interfaceName);
|
||||
auto structSlot = ctx->get(ip->structName);
|
||||
|
||||
LvObject interfaceLv(interfaceSlot, ctx);
|
||||
LvObject structLv(structSlot, ctx);
|
||||
|
||||
ObjectPtr interfaceObj = interfaceLv.get();
|
||||
ObjectPtr structTypeObj = structLv.get();
|
||||
|
||||
if (!interfaceObj->is<InterfaceType>())
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"NotAInterfaceError",
|
||||
std::format("Variable `{}` is not a interface", ip->interfaceName.toBasicString()),
|
||||
ip);
|
||||
}
|
||||
if (!structTypeObj->is<StructType>())
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"NotAStructType",
|
||||
std::format("Variable `{}` is not a struct type", ip->structName.toBasicString()),
|
||||
ip);
|
||||
}
|
||||
auto &implementMethods = ip->methods;
|
||||
InterfaceType &interface = interfaceObj->as<InterfaceType>();
|
||||
|
||||
// ===== interface implementation validation =====
|
||||
ImplRecord record{interfaceType, structType, {}};
|
||||
|
||||
std::unordered_map<FString, Ast::InterfaceMethod> ifaceMethods;
|
||||
for (auto &m : interface.methods)
|
||||
{
|
||||
if (ifaceMethods.contains(m.name))
|
||||
{
|
||||
throw EvaluatorError(u8"InterfaceDuplicateMethodError",
|
||||
std::format("Interface '{}' has duplicate method '{}'",
|
||||
interfaceType.toString().toBasicString(),
|
||||
m.name.toBasicString()),
|
||||
ip);
|
||||
}
|
||||
ifaceMethods[m.name] = m;
|
||||
}
|
||||
|
||||
std::unordered_set<FString> implemented;
|
||||
|
||||
for (auto &implMethod : implementMethods)
|
||||
{
|
||||
const FString &name = implMethod.name;
|
||||
|
||||
// ---- redundant impl ----
|
||||
if (!ifaceMethods.contains(name))
|
||||
{
|
||||
throw EvaluatorError(u8"RedundantImplementationError",
|
||||
std::format("Struct '{}' implements extra method '{}' "
|
||||
"which is not required by interface '{}'",
|
||||
structType.toString().toBasicString(),
|
||||
name.toBasicString(),
|
||||
interfaceType.toString().toBasicString()),
|
||||
ip);
|
||||
}
|
||||
|
||||
if (implemented.contains(name))
|
||||
{
|
||||
throw EvaluatorError(u8"DuplicateImplementMethodError",
|
||||
std::format("Duplicate implement method '{}'", name.toBasicString()),
|
||||
ip);
|
||||
}
|
||||
|
||||
auto &ifMethod = ifaceMethods[name];
|
||||
|
||||
// ---- signature check ----
|
||||
if (!isInterfaceSignatureMatch(implMethod, ifMethod))
|
||||
{
|
||||
throw EvaluatorError(u8"InterfaceSignatureMismatch",
|
||||
std::format("Interface method '{}({})' signature mismatch with "
|
||||
"implementation '{}({})'",
|
||||
ifMethod.name.toBasicString(),
|
||||
ifMethod.paras.toString().toBasicString(),
|
||||
implMethod.name.toBasicString(),
|
||||
implMethod.paras.toString().toBasicString()),
|
||||
ip);
|
||||
}
|
||||
|
||||
if (ctx->hasMethodImplemented(structType, name))
|
||||
{
|
||||
throw EvaluatorError(u8"DuplicateImplementMethodError",
|
||||
std::format("Method '{}' already implemented by another interface "
|
||||
"for struct '{}'",
|
||||
name.toBasicString(),
|
||||
structType.toString().toBasicString()),
|
||||
ip);
|
||||
}
|
||||
|
||||
implemented.insert(name);
|
||||
|
||||
ObjectPtr returnTypeValue = eval(ifMethod.returnType, ctx);
|
||||
|
||||
record.implMethods[name] =
|
||||
Function(implMethod.paras, actualType(returnTypeValue), implMethod.body, ctx);
|
||||
}
|
||||
|
||||
for (auto &m : interface.methods)
|
||||
{
|
||||
if (implemented.contains(m.name)) continue;
|
||||
|
||||
if (m.hasDefaultBody()) continue;
|
||||
|
||||
throw EvaluatorError(u8"MissingImplementationError",
|
||||
std::format("Struct '{}' does not implement required interface method '{}' "
|
||||
"and interface '{}' provides no default implementation",
|
||||
structType.toString().toBasicString(),
|
||||
m.name.toBasicString(),
|
||||
interfaceType.toString().toBasicString()),
|
||||
ip);
|
||||
}
|
||||
|
||||
ctx->setImplRecord(structType, interfaceType, record);
|
||||
return StatementResult::normal();
|
||||
}
|
||||
|
||||
case IfSt: {
|
||||
auto ifSt = std::static_pointer_cast<Ast::IfSt>(stmt);
|
||||
ObjectPtr condVal = eval(ifSt->condition, ctx);
|
||||
if (condVal->getTypeInfo() != ValueType::Bool)
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"TypeError",
|
||||
std::format("Condition must be boolean, but got '{}'", prettyType(condVal).toBasicString()),
|
||||
ifSt->condition);
|
||||
}
|
||||
if (condVal->as<ValueType::BoolClass>()) { return evalBlockStatement(ifSt->body, ctx); }
|
||||
// else
|
||||
for (const auto &elif : ifSt->elifs)
|
||||
{
|
||||
ObjectPtr elifCondVal = eval(elif->condition, ctx);
|
||||
if (elifCondVal->getTypeInfo() != ValueType::Bool)
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"TypeError",
|
||||
std::format("Condition must be boolean, but got '{}'", prettyType(condVal).toBasicString()),
|
||||
ifSt->condition);
|
||||
}
|
||||
if (elifCondVal->as<ValueType::BoolClass>()) { return evalBlockStatement(elif->body, ctx); }
|
||||
}
|
||||
if (ifSt->els) { return evalBlockStatement(ifSt->els->body, ctx); }
|
||||
return StatementResult::normal();
|
||||
};
|
||||
case WhileSt: {
|
||||
auto whileSt = std::static_pointer_cast<Ast::WhileSt>(stmt);
|
||||
while (true)
|
||||
{
|
||||
ObjectPtr condVal = eval(whileSt->condition, ctx);
|
||||
if (condVal->getTypeInfo() != ValueType::Bool)
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"TypeError",
|
||||
std::format("Condition must be boolean, but got '{}'", prettyType(condVal).toBasicString()),
|
||||
whileSt->condition);
|
||||
}
|
||||
if (!condVal->as<ValueType::BoolClass>()) { break; }
|
||||
ContextPtr loopContext = std::make_shared<Context>(
|
||||
FString(std::format("<While {}:{}>", whileSt->getAAI().line, whileSt->getAAI().column)),
|
||||
ctx); // every loop has its own context
|
||||
StatementResult sr = evalBlockStatement(whileSt->body, loopContext);
|
||||
if (sr.shouldReturn()) { return sr; }
|
||||
if (sr.shouldBreak()) { break; }
|
||||
if (sr.shouldContinue()) { continue; }
|
||||
}
|
||||
return StatementResult::normal();
|
||||
};
|
||||
case ForSt: {
|
||||
auto forSt = std::static_pointer_cast<Ast::ForSt>(stmt);
|
||||
ContextPtr loopContext = std::make_shared<Context>(
|
||||
FString(std::format("<For {}:{}>", forSt->getAAI().line, forSt->getAAI().column)),
|
||||
ctx); // for loop has its own context
|
||||
|
||||
evalStatement(forSt->initSt,
|
||||
loopContext); // ignore init statement result
|
||||
size_t iteration = 0;
|
||||
|
||||
while (true) // use while loop to simulate for loop, cause we
|
||||
// need to check condition type every iteration
|
||||
{
|
||||
ObjectPtr condVal = eval(forSt->condition, loopContext);
|
||||
if (condVal->getTypeInfo() != ValueType::Bool)
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"TypeError",
|
||||
std::format("Condition must be boolean, but got '{}'", prettyType(condVal).toBasicString()),
|
||||
forSt->condition);
|
||||
}
|
||||
if (!condVal->as<ValueType::BoolClass>()) { break; }
|
||||
iteration++;
|
||||
ContextPtr iterationContext = std::make_shared<Context>(
|
||||
FString(std::format(
|
||||
"<For {}:{}, Iteration {}>", forSt->getAAI().line, forSt->getAAI().column, iteration)),
|
||||
loopContext); // every loop has its own context
|
||||
StatementResult sr = evalBlockStatement(forSt->body, iterationContext);
|
||||
if (sr.shouldReturn()) { return sr; }
|
||||
if (sr.shouldBreak()) { break; }
|
||||
if (sr.shouldContinue())
|
||||
{
|
||||
// continue to next iteration
|
||||
continue;
|
||||
}
|
||||
evalStatement(forSt->incrementSt,
|
||||
loopContext); // ignore increment statement result
|
||||
}
|
||||
return StatementResult::normal();
|
||||
}
|
||||
|
||||
case TrySt: {
|
||||
auto tryst = std::static_pointer_cast<Ast::TrySt>(stmt);
|
||||
assert(tryst != nullptr);
|
||||
|
||||
ContextPtr tryCtx = std::make_shared<Context>(
|
||||
FString(std::format("<Try at {}:{}>", tryst->getAAI().line, tryst->getAAI().column)), ctx);
|
||||
StatementResult sr = StatementResult::normal();
|
||||
for (auto &stmt : tryst->body->stmts)
|
||||
{
|
||||
sr = evalStatement(stmt, tryCtx); // eval in try context
|
||||
if (sr.isError()) { break; }
|
||||
}
|
||||
bool catched = false;
|
||||
for (auto &cat : tryst->catches)
|
||||
{
|
||||
const FString &errVarName = cat.errVarName;
|
||||
TypeInfo errVarType = (cat.hasType ? TypeInfo(cat.errVarType) : ValueType::Any);
|
||||
if (isTypeMatch(errVarType, sr.result, ctx))
|
||||
{
|
||||
ContextPtr catchCtx = std::make_shared<Context>(
|
||||
FString(
|
||||
std::format("<Catch at {}:{}>", cat.body->getAAI().line, cat.body->getAAI().column)),
|
||||
ctx);
|
||||
catchCtx->def(errVarName, errVarType, AccessModifier::Normal, sr.result);
|
||||
sr = evalBlockStatement(cat.body, catchCtx);
|
||||
catched = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!catched)
|
||||
{
|
||||
throw EvaluatorError(u8"UncaughtExceptionError",
|
||||
std::format("Uncaught exception: {}", sr.result->toString().toBasicString()),
|
||||
tryst);
|
||||
}
|
||||
if (tryst->finallyBlock) { sr = evalBlockStatement(tryst->finallyBlock, ctx); }
|
||||
return sr;
|
||||
}
|
||||
|
||||
case ThrowSt: {
|
||||
auto ts = std::static_pointer_cast<Ast::ThrowSt>(stmt);
|
||||
assert(ts != nullptr);
|
||||
|
||||
ObjectPtr value = eval(ts->value, ctx);
|
||||
if (value->is<ValueType::NullClass>())
|
||||
{
|
||||
throw EvaluatorError(u8"TypeError", u8"Why did you throw a null?", ts);
|
||||
}
|
||||
return StatementResult::errorFlow(value);
|
||||
}
|
||||
|
||||
case ReturnSt: {
|
||||
auto returnSt = std::static_pointer_cast<Ast::ReturnSt>(stmt);
|
||||
assert(returnSt != nullptr);
|
||||
|
||||
ObjectPtr returnValue = Object::getNullInstance(); // default is null
|
||||
if (returnSt->retValue) returnValue = eval(returnSt->retValue, ctx);
|
||||
return StatementResult::returnFlow(returnValue);
|
||||
}
|
||||
|
||||
case BreakSt: {
|
||||
if (!ctx->parent)
|
||||
{
|
||||
throw EvaluatorError(u8"BreakOutsideLoopError", u8"`break` statement outside loop", stmt);
|
||||
}
|
||||
if (!ctx->isInLoopContext())
|
||||
{
|
||||
throw EvaluatorError(u8"BreakOutsideLoopError", u8"`break` statement outside loop", stmt);
|
||||
}
|
||||
return StatementResult::breakFlow();
|
||||
}
|
||||
|
||||
case ContinueSt: {
|
||||
if (!ctx->parent)
|
||||
{
|
||||
throw EvaluatorError(u8"ContinueOutsideLoopError", u8"`continue` statement outside loop", stmt);
|
||||
}
|
||||
if (!ctx->isInLoopContext())
|
||||
{
|
||||
throw EvaluatorError(u8"ContinueOutsideLoopError", u8"`continue` statement outside loop", stmt);
|
||||
}
|
||||
return StatementResult::continueFlow();
|
||||
}
|
||||
|
||||
case ExpressionStmt: {
|
||||
auto exprStmt = std::static_pointer_cast<Ast::ExpressionStmtAst>(stmt);
|
||||
assert(exprStmt != nullptr);
|
||||
|
||||
return StatementResult::normal(eval(exprStmt->exp, ctx));
|
||||
}
|
||||
|
||||
case BlockStatement: {
|
||||
auto block = std::static_pointer_cast<Ast::BlockStatementAst>(stmt);
|
||||
assert(block != nullptr);
|
||||
|
||||
ContextPtr blockCtx = std::make_shared<Context>(
|
||||
FString(std::format("<Block at {}:{}>", block->getAAI().line, block->getAAI().column)), ctx);
|
||||
return evalBlockStatement(block, blockCtx);
|
||||
}
|
||||
|
||||
default:
|
||||
throw RuntimeError(
|
||||
FString(std::format("Feature stmt {} unsupported yet", magic_enum::enum_name(stmt->getType()))));
|
||||
}
|
||||
}
|
||||
};
|
||||
20
src/Evaluator/Core/EvalTernary.cpp
Normal file
20
src/Evaluator/Core/EvalTernary.cpp
Normal file
@@ -0,0 +1,20 @@
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
|
||||
RvObject Evaluator::evalTernary(Ast::TernaryExpr te, ContextPtr ctx)
|
||||
{
|
||||
RvObject condVal = eval(te->condition, ctx);
|
||||
if (condVal->getTypeInfo() != ValueType::Bool)
|
||||
{
|
||||
throw EvaluatorError(
|
||||
u8"TypeError",
|
||||
std::format("Condition must be boolean, got '{}'", prettyType(condVal).toBasicString()),
|
||||
te->condition);
|
||||
}
|
||||
ValueType::BoolClass cond = condVal->as<ValueType::BoolClass>();
|
||||
return (cond ? eval(te->valueT, ctx) : eval(te->valueF, ctx));
|
||||
}
|
||||
};
|
||||
31
src/Evaluator/Core/EvalUnary.cpp
Normal file
31
src/Evaluator/Core/EvalUnary.cpp
Normal file
@@ -0,0 +1,31 @@
|
||||
#include <Evaluator/Value/LvObject.hpp>
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
RvObject Evaluator::evalUnary(Ast::UnaryExpr un, ContextPtr ctx)
|
||||
{
|
||||
using Ast::Operator;
|
||||
Operator op = un->op;
|
||||
Ast::Expression exp = un->exp;
|
||||
ObjectPtr value = eval(exp, ctx);
|
||||
switch (op)
|
||||
{
|
||||
case Operator::Not: {
|
||||
return std::make_shared<Object>(!(*value));
|
||||
}
|
||||
case Operator::Subtract: {
|
||||
return std::make_shared<Object>(-(*value));
|
||||
}
|
||||
case Operator::BitNot: {
|
||||
return std::make_shared<Object>(bit_not((*value)));
|
||||
}
|
||||
default: {
|
||||
throw EvaluatorError(u8"UnsupportedOpError",
|
||||
std::format("Unsupported op '{}' for unary expression", magic_enum::enum_name(op)),
|
||||
un);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
114
src/Evaluator/Core/ResolveModulePath.cpp
Normal file
114
src/Evaluator/Core/ResolveModulePath.cpp
Normal file
@@ -0,0 +1,114 @@
|
||||
#include <Core/executablePath.hpp>
|
||||
|
||||
#include <Evaluator/evaluator.hpp>
|
||||
#include <Evaluator/evaluator_error.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
|
||||
std::filesystem::path Evaluator::resolveModulePath(const std::vector<FString> &pathVec)
|
||||
{
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
static const std::vector<fs::path> defaultLibraryPath{"Library", "Library/fpm"};
|
||||
|
||||
std::vector<fs::path> pathToFind(defaultLibraryPath);
|
||||
|
||||
fs::path interpreterPath = getExecutablePath().parent_path();
|
||||
|
||||
for (fs::path &p : pathToFind)
|
||||
{
|
||||
p = interpreterPath / p; // 相对路径 -> 绝对路径
|
||||
}
|
||||
|
||||
pathToFind.insert(
|
||||
pathToFind.begin(),
|
||||
fs::path(this->sourcePath.toBasicString()).parent_path()); // first search module at the source file path
|
||||
|
||||
fs::path path;
|
||||
|
||||
/*
|
||||
Example:
|
||||
import comp.config;
|
||||
*/
|
||||
|
||||
const FString &modPathStrTop = pathVec.at(0);
|
||||
fs::path modPath;
|
||||
|
||||
bool found = false;
|
||||
for (auto &parentFolder : pathToFind)
|
||||
{
|
||||
modPath = parentFolder / FString(modPathStrTop + u8".fig").toBasicString();
|
||||
if (fs::exists(modPath))
|
||||
{
|
||||
path = modPath;
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
modPath = parentFolder / modPathStrTop.toBasicString();
|
||||
if (fs::is_directory(modPath)) // comp is a directory
|
||||
{
|
||||
modPath = modPath / FString(modPathStrTop + u8".fig").toBasicString();
|
||||
/*
|
||||
if module name is a directory, we require [module
|
||||
name].fig at the directory
|
||||
*/
|
||||
if (!fs::exists(modPath))
|
||||
{
|
||||
throw RuntimeError(FString(std::format("requires module file, {}\\{}",
|
||||
modPathStrTop.toBasicString(),
|
||||
FString(modPathStrTop + u8".fig").toBasicString())));
|
||||
}
|
||||
found = true;
|
||||
path = modPath;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!found)
|
||||
throw RuntimeError(FString(std::format("Could not find module `{}`", modPathStrTop.toBasicString())));
|
||||
|
||||
bool found2 = false;
|
||||
|
||||
for (size_t i = 1; i < pathVec.size(); ++i) // has next module
|
||||
{
|
||||
const FString &next = pathVec.at(i);
|
||||
modPath = modPath.parent_path(); // get the folder
|
||||
modPath = modPath / FString(next + u8".fig").toBasicString();
|
||||
if (fs::exists(modPath))
|
||||
{
|
||||
if (i != pathVec.size() - 1)
|
||||
throw RuntimeError(FString(std::format(
|
||||
"expects {} as parent directory and find next module, but got a file", next.toBasicString())));
|
||||
// it's the last module
|
||||
found2 = true;
|
||||
path = modPath;
|
||||
break;
|
||||
}
|
||||
// `next` is a folder
|
||||
modPath = modPath.parent_path() / next.toBasicString();
|
||||
if (!fs::exists(modPath))
|
||||
throw RuntimeError(FString(std::format("Could not find module `{}`", next.toBasicString())));
|
||||
if (i == pathVec.size() - 1)
|
||||
{
|
||||
// `next` is the last module
|
||||
modPath = modPath / FString(next + u8".fig").toBasicString();
|
||||
if (!fs::exists(modPath))
|
||||
{
|
||||
throw RuntimeError(FString(std::format(
|
||||
"expects {} as parent directory and find next module, but got a file", next.toBasicString())));
|
||||
}
|
||||
found2 = true;
|
||||
path = modPath;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found2 && !fs::exists(modPath))
|
||||
throw RuntimeError(FString(std::format("Could not find module `{}`", pathVec.end()->toBasicString())));
|
||||
|
||||
return path;
|
||||
}
|
||||
};
|
||||
37
src/Evaluator/Core/StatementResult.hpp
Normal file
37
src/Evaluator/Core/StatementResult.hpp
Normal file
@@ -0,0 +1,37 @@
|
||||
#pragma once
|
||||
|
||||
#include <Core/fig_string.hpp>
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
struct StatementResult
|
||||
{
|
||||
ObjectPtr result;
|
||||
enum class Flow
|
||||
{
|
||||
Normal,
|
||||
Return,
|
||||
Break,
|
||||
Continue,
|
||||
Error
|
||||
} flow;
|
||||
|
||||
StatementResult(ObjectPtr val, Flow f = Flow::Normal) : result(val), flow(f) {}
|
||||
|
||||
static StatementResult normal(ObjectPtr val = Object::getNullInstance())
|
||||
{
|
||||
return StatementResult(val, Flow::Normal);
|
||||
}
|
||||
static StatementResult returnFlow(ObjectPtr val) { return StatementResult(val, Flow::Return); }
|
||||
static StatementResult breakFlow() { return StatementResult(Object::getNullInstance(), Flow::Break); }
|
||||
static StatementResult continueFlow() { return StatementResult(Object::getNullInstance(), Flow::Continue); }
|
||||
static StatementResult errorFlow(ObjectPtr val) { return StatementResult(val, Flow::Error); }
|
||||
|
||||
bool isNormal() const { return flow == Flow::Normal; }
|
||||
bool shouldReturn() const { return flow == Flow::Return; }
|
||||
bool shouldBreak() const { return flow == Flow::Break; }
|
||||
bool shouldContinue() const { return flow == Flow::Continue; }
|
||||
bool isError() const { return flow == Flow::Error; }
|
||||
};
|
||||
};
|
||||
@@ -1,9 +1,9 @@
|
||||
#pragma once
|
||||
|
||||
#include "Value/value.hpp"
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
#include <Core/fig_string.hpp>
|
||||
#include <Value/value_forward.hpp>
|
||||
#include <Value/Type.hpp>
|
||||
#include <Evaluator/Value/value_forward.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
#include <array>
|
||||
#include <memory>
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <Value/VariableSlot.hpp>
|
||||
#include <Value/value.hpp>
|
||||
#include <Evaluator/Value/VariableSlot.hpp>
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
|
||||
@@ -14,44 +14,32 @@ namespace Fig
|
||||
private:
|
||||
size_t id;
|
||||
|
||||
std::map<FString, size_t> &getTypeMap()
|
||||
{
|
||||
static std::map<FString, size_t> typeMap;
|
||||
return typeMap;
|
||||
}
|
||||
|
||||
public:
|
||||
friend class TypeInfoHash;
|
||||
|
||||
FString name;
|
||||
|
||||
FString toString() const
|
||||
{
|
||||
return name;
|
||||
}
|
||||
FString toString() const { return name; }
|
||||
|
||||
static std::map<FString, size_t> typeMap;
|
||||
|
||||
static size_t getID(FString _name)
|
||||
{
|
||||
return typeMap.at(_name);
|
||||
}
|
||||
size_t getInstanceID() const
|
||||
{
|
||||
return id;
|
||||
}
|
||||
size_t getInstanceID() const { return id; }
|
||||
|
||||
TypeInfo();
|
||||
explicit TypeInfo(const FString &_name, bool reg = false);
|
||||
TypeInfo(const TypeInfo &other) = default;
|
||||
|
||||
bool operator==(const TypeInfo &other) const
|
||||
{
|
||||
return id == other.id;
|
||||
}
|
||||
bool operator==(const TypeInfo &other) const { return id == other.id; }
|
||||
};
|
||||
|
||||
|
||||
class TypeInfoHash
|
||||
{
|
||||
public:
|
||||
std::size_t operator()(const TypeInfo &ti) const
|
||||
{
|
||||
return std::hash<size_t>{}(ti.id);
|
||||
}
|
||||
std::size_t operator()(const TypeInfo &ti) const { return std::hash<size_t>{}(ti.id); }
|
||||
};
|
||||
|
||||
// class Value;
|
||||
@@ -77,39 +65,31 @@ namespace Fig
|
||||
using NullClass = std::monostate;
|
||||
using StringClass = FString;
|
||||
|
||||
static const std::unordered_set<TypeInfo, TypeInfoHash> builtinTypes
|
||||
{
|
||||
Any,
|
||||
Null,
|
||||
Int,
|
||||
String,
|
||||
Bool,
|
||||
Double,
|
||||
Function,
|
||||
StructType,
|
||||
StructInstance,
|
||||
List,
|
||||
Map,
|
||||
Module,
|
||||
InterfaceType
|
||||
};
|
||||
|
||||
inline bool isTypeBuiltin(const TypeInfo &type)
|
||||
{
|
||||
static const std::unordered_set<TypeInfo, TypeInfoHash> builtinTypes{Any,
|
||||
Null,
|
||||
Int,
|
||||
String,
|
||||
Bool,
|
||||
Double,
|
||||
Function,
|
||||
StructType,
|
||||
StructInstance,
|
||||
List,
|
||||
Map,
|
||||
Module,
|
||||
InterfaceType};
|
||||
return builtinTypes.contains(type);
|
||||
}
|
||||
}; // namespace ValueType
|
||||
}; // namespace Fig
|
||||
|
||||
|
||||
namespace std
|
||||
{
|
||||
template <>
|
||||
struct hash<Fig::TypeInfo>
|
||||
{
|
||||
size_t operator()(const Fig::TypeInfo &t)
|
||||
{
|
||||
return std::hash<size_t>{}(t.getInstanceID());
|
||||
}
|
||||
size_t operator()(const Fig::TypeInfo &t) { return std::hash<size_t>{}(t.getInstanceID()); }
|
||||
};
|
||||
};
|
||||
}; // namespace std
|
||||
@@ -3,8 +3,8 @@
|
||||
|
||||
#include <Ast/AccessModifier.hpp>
|
||||
#include <Core/fig_string.hpp>
|
||||
#include <Value/Type.hpp>
|
||||
#include <Value/value_forward.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
#include <Evaluator/Value/value_forward.hpp>
|
||||
|
||||
#include <memory>
|
||||
namespace Fig
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <Ast/functionParameters.hpp>
|
||||
#include <Context/context_forward.hpp>
|
||||
#include <Evaluator/Context/context_forward.hpp>
|
||||
|
||||
#include <atomic>
|
||||
#include <functional>
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <Ast/Statements/InterfaceDefSt.hpp>
|
||||
#include <Value/Type.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
|
||||
#include <vector>
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
#include <Core/fig_string.hpp>
|
||||
|
||||
#include <Context/context_forward.hpp>
|
||||
#include <Evaluator/Context/context_forward.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <Context/context_forward.hpp>
|
||||
#include <Value/Type.hpp>
|
||||
#include <Evaluator/Context/context_forward.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
|
||||
@@ -3,9 +3,9 @@
|
||||
#include <Core/fig_string.hpp>
|
||||
#include <Ast/Statements/StructDefSt.hpp>
|
||||
|
||||
#include <Value/Type.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
|
||||
#include <Context/context_forward.hpp>
|
||||
#include <Evaluator/Context/context_forward.hpp>
|
||||
#include <atomic>
|
||||
#include <vector>
|
||||
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
#include "Value/structType.hpp"
|
||||
#include <Value/Type.hpp>
|
||||
#include <Value/value.hpp>
|
||||
#include <Context/context.hpp>
|
||||
#include <Evaluator/Value/structType.hpp>
|
||||
#include <Evaluator/Value/value_forward.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
#include <Evaluator/Context/context.hpp>
|
||||
|
||||
// #include <iostream>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
std::map<FString, size_t> TypeInfo::typeMap = {};
|
||||
|
||||
TypeInfo::TypeInfo() : // only allow use in evaluate time !! <---- dynamic type system requirement
|
||||
id(1), name(FString(u8"Any"))
|
||||
@@ -20,17 +20,17 @@ namespace Fig
|
||||
// std::cerr << "TypeInfo constructor called for type name: " << name.toBasicString() << "\n";
|
||||
if (reg)
|
||||
{
|
||||
typeMap[name] = ++id_count;
|
||||
getTypeMap()[name] = ++id_count;
|
||||
id = id_count;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!typeMap.contains(_name))
|
||||
if (!getTypeMap().contains(_name))
|
||||
{
|
||||
throw RuntimeError(FString(std::format("No type named '{}'", _name.toBasicString())));
|
||||
// *this = ValueType::String;
|
||||
}
|
||||
id = typeMap.at(name); // may throw
|
||||
id = getTypeMap().at(name); // may throw
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
#pragma once
|
||||
#include <Value/function.hpp>
|
||||
#include <Value/interface.hpp>
|
||||
#include <Value/structType.hpp>
|
||||
#include <Value/structInstance.hpp>
|
||||
#include <Value/Type.hpp>
|
||||
#include <Value/valueError.hpp>
|
||||
#include <Value/module.hpp>
|
||||
#include <Value/value_forward.hpp>
|
||||
#include <Evaluator/Value/function.hpp>
|
||||
#include <Evaluator/Value/interface.hpp>
|
||||
#include <Evaluator/Value/structType.hpp>
|
||||
#include <Evaluator/Value/structInstance.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
#include <Evaluator/Value/valueError.hpp>
|
||||
#include <Evaluator/Value/module.hpp>
|
||||
#include <Evaluator/Value/value_forward.hpp>
|
||||
|
||||
#include <memory>
|
||||
#include <variant>
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,62 +1,19 @@
|
||||
#include "Ast/Expressions/InitExpr.hpp"
|
||||
#include <Ast/Expressions/InitExpr.hpp>
|
||||
#include <Ast/Statements/ImplementSt.hpp>
|
||||
#include <Ast/Statements/InterfaceDefSt.hpp>
|
||||
#include <Value/Type.hpp>
|
||||
#include <Evaluator/Value/Type.hpp>
|
||||
#include <Ast/ast.hpp>
|
||||
|
||||
#include <Context/context.hpp>
|
||||
#include <Evaluator/Context/context.hpp>
|
||||
#include <Error/error.hpp>
|
||||
#include <Module/builtins.hpp>
|
||||
#include <Value/LvObject.hpp>
|
||||
#include <Evaluator/Value/LvObject.hpp>
|
||||
#include <filesystem>
|
||||
|
||||
#include <Evaluator/Core/StatementResult.hpp>
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
struct StatementResult
|
||||
{
|
||||
ObjectPtr result;
|
||||
enum class Flow
|
||||
{
|
||||
Normal,
|
||||
Return,
|
||||
Break,
|
||||
Continue,
|
||||
Error
|
||||
} flow;
|
||||
|
||||
StatementResult(ObjectPtr val, Flow f = Flow::Normal) :
|
||||
result(val), flow(f)
|
||||
{
|
||||
}
|
||||
|
||||
static StatementResult normal(ObjectPtr val = Object::getNullInstance())
|
||||
{
|
||||
return StatementResult(val, Flow::Normal);
|
||||
}
|
||||
static StatementResult returnFlow(ObjectPtr val)
|
||||
{
|
||||
return StatementResult(val, Flow::Return);
|
||||
}
|
||||
static StatementResult breakFlow()
|
||||
{
|
||||
return StatementResult(Object::getNullInstance(), Flow::Break);
|
||||
}
|
||||
static StatementResult continueFlow()
|
||||
{
|
||||
return StatementResult(Object::getNullInstance(), Flow::Continue);
|
||||
}
|
||||
static StatementResult errorFlow(ObjectPtr val)
|
||||
{
|
||||
return StatementResult(val, Flow::Error);
|
||||
}
|
||||
|
||||
bool isNormal() const { return flow == Flow::Normal; }
|
||||
bool shouldReturn() const { return flow == Flow::Return; }
|
||||
bool shouldBreak() const { return flow == Flow::Break; }
|
||||
bool shouldContinue() const { return flow == Flow::Continue; }
|
||||
bool isError() const { return flow == Flow::Error; }
|
||||
};
|
||||
|
||||
class Evaluator
|
||||
{
|
||||
private:
|
||||
@@ -92,7 +49,7 @@ namespace Fig
|
||||
{
|
||||
assert(global != nullptr);
|
||||
|
||||
for (auto &[name, fn] : Builtins::builtinFunctions)
|
||||
for (auto &[name, fn] : Builtins::getBuiltinFunctions())
|
||||
{
|
||||
int argc = Builtins::getBuiltinFunctionParamCount(name);
|
||||
Function f(fn, argc);
|
||||
@@ -108,7 +65,7 @@ namespace Fig
|
||||
{
|
||||
assert(global != nullptr);
|
||||
|
||||
for (auto &[name, val] : Builtins::builtinValues)
|
||||
for (auto &[name, val] : Builtins::getBuiltinValues())
|
||||
{
|
||||
global->def(
|
||||
name,
|
||||
|
||||
380
src/Module/builtins.cpp
Normal file
380
src/Module/builtins.cpp
Normal file
@@ -0,0 +1,380 @@
|
||||
#include <Module/builtins.hpp>
|
||||
|
||||
#include <print>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
#include <chrono>
|
||||
#include <numeric>
|
||||
|
||||
namespace Fig::Builtins
|
||||
{
|
||||
const std::unordered_map<FString, ObjectPtr> &getBuiltinValues()
|
||||
{
|
||||
static const std::unordered_map<FString, ObjectPtr> builtinValues = {
|
||||
{u8"null", Object::getNullInstance()},
|
||||
{u8"true", Object::getTrueInstance()},
|
||||
{u8"false", Object::getFalseInstance()},
|
||||
{u8"Error",
|
||||
std::make_shared<Object>(InterfaceType(ErrorInterfaceTypeInfo,
|
||||
{Ast::InterfaceMethod(u8"toString",
|
||||
Ast::FunctionParameters({}, {}),
|
||||
std::make_shared<Ast::VarExprAst>(u8"String"),
|
||||
nullptr),
|
||||
Ast::InterfaceMethod(u8"getErrorClass",
|
||||
Ast::FunctionParameters({}, {}),
|
||||
std::make_shared<Ast::VarExprAst>(u8"String"),
|
||||
nullptr),
|
||||
Ast::InterfaceMethod(u8"getErrorMessage",
|
||||
Ast::FunctionParameters({}, {}),
|
||||
std::make_shared<Ast::VarExprAst>(u8"String"),
|
||||
nullptr)}))},
|
||||
|
||||
{u8"Any", std::make_shared<Object>(StructType(ValueType::Any, nullptr, {}, true))},
|
||||
{u8"Int", std::make_shared<Object>(StructType(ValueType::Int, nullptr, {}, true))},
|
||||
{u8"Null", std::make_shared<Object>(StructType(ValueType::Null, nullptr, {}, true))},
|
||||
{u8"String", std::make_shared<Object>(StructType(ValueType::String, nullptr, {}, true))},
|
||||
{u8"Bool", std::make_shared<Object>(StructType(ValueType::Bool, nullptr, {}, true))},
|
||||
{u8"Double", std::make_shared<Object>(StructType(ValueType::Double, nullptr, {}, true))},
|
||||
{u8"Function", std::make_shared<Object>(StructType(ValueType::Function, nullptr, {}, true))},
|
||||
{u8"List", std::make_shared<Object>(StructType(ValueType::List, nullptr, {}, true))},
|
||||
{u8"Map", std::make_shared<Object>(StructType(ValueType::Map, nullptr, {}, true))},
|
||||
// Type `StructType` `StructInstance` `Module` `InterfaceType`
|
||||
// Not allowed to call constructor!
|
||||
};
|
||||
return builtinValues;
|
||||
}
|
||||
const std::unordered_map<FString, int> &getBuiltinFunctionArgCounts()
|
||||
{
|
||||
static const std::unordered_map<FString, int> builtinFunctionArgCounts = {
|
||||
{u8"__fstdout_print", -1}, // variadic
|
||||
{u8"__fstdout_println", -1}, // variadic
|
||||
{u8"__fstdin_read", 0},
|
||||
{u8"__fstdin_readln", 0},
|
||||
{u8"__fvalue_type", 1},
|
||||
{u8"__fvalue_int_parse", 1},
|
||||
{u8"__fvalue_int_from", 1},
|
||||
{u8"__fvalue_double_parse", 1},
|
||||
{u8"__fvalue_double_from", 1},
|
||||
{u8"__fvalue_string_from", 1},
|
||||
{u8"__ftime_now_ns", 0},
|
||||
/* math start */
|
||||
{u8"__fmath_acos", 1},
|
||||
{u8"__fmath_acosh", 1},
|
||||
{u8"__fmath_asin", 1},
|
||||
{u8"__fmath_asinh", 1},
|
||||
{u8"__fmath_atan", 1},
|
||||
{u8"__fmath_atan2", 2},
|
||||
{u8"__fmath_atanh", 1},
|
||||
{u8"__fmath_ceil", 1},
|
||||
{u8"__fmath_cos", 1},
|
||||
{u8"__fmath_cosh", 1},
|
||||
{u8"__fmath_exp", 1},
|
||||
{u8"__fmath_expm1", 1},
|
||||
{u8"__fmath_fabs", 1},
|
||||
{u8"__fmath_floor", 1},
|
||||
{u8"__fmath_fmod", 2},
|
||||
{u8"__fmath_frexp", 1},
|
||||
{u8"__fmath_gcd", 2},
|
||||
{u8"__fmath_hypot", 2},
|
||||
{u8"__fmath_isequal", 2},
|
||||
{u8"__fmath_log", 1},
|
||||
{u8"__fmath_log10", 1},
|
||||
{u8"__fmath_log1p", 1},
|
||||
{u8"__fmath_log2", 1},
|
||||
{u8"__fmath_sin", 1},
|
||||
{u8"__fmath_sinh", 1},
|
||||
{u8"__fmath_sqrt", 1},
|
||||
{u8"__fmath_tan", 1},
|
||||
{u8"__fmath_tanh", 1},
|
||||
{u8"__fmath_trunc", 1},
|
||||
};
|
||||
return builtinFunctionArgCounts;
|
||||
}
|
||||
const std::unordered_map<FString, BuiltinFunction> &getBuiltinFunctions()
|
||||
{
|
||||
static const std::unordered_map<FString, BuiltinFunction> builtinFunctions{
|
||||
{u8"__fstdout_print",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
for (auto arg : args) { std::print("{}", arg->toStringIO().toBasicString()); }
|
||||
return std::make_shared<Object>(ValueType::IntClass(args.size()));
|
||||
}},
|
||||
{u8"__fstdout_println",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
for (auto arg : args) { std::print("{}", arg->toStringIO().toBasicString()); }
|
||||
std::print("\n");
|
||||
return std::make_shared<Object>(ValueType::IntClass(args.size()));
|
||||
}},
|
||||
{u8"__fstdin_read",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
std::string input;
|
||||
std::cin >> input;
|
||||
return std::make_shared<Object>(FString::fromBasicString(input));
|
||||
}},
|
||||
{u8"__fstdin_readln",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
std::string line;
|
||||
std::getline(std::cin, line);
|
||||
return std::make_shared<Object>(FString::fromBasicString(line));
|
||||
}},
|
||||
{u8"__fvalue_type",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr { return std::make_shared<Object>(); }},
|
||||
{u8"__fvalue_int_parse",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
FString str = args[0]->as<ValueType::StringClass>();
|
||||
try
|
||||
{
|
||||
ValueType::IntClass val = std::stoi(str.toBasicString());
|
||||
return std::make_shared<Object>(val);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Invalid int string for parsing", str.toBasicString())));
|
||||
}
|
||||
}},
|
||||
{u8"__fvalue_int_from",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
if (val->is<ValueType::DoubleClass>())
|
||||
{
|
||||
return std::make_shared<Object>(
|
||||
static_cast<ValueType::IntClass>(val->as<ValueType::DoubleClass>()));
|
||||
}
|
||||
else if (val->is<ValueType::BoolClass>())
|
||||
{
|
||||
return std::make_shared<Object>(
|
||||
static_cast<ValueType::IntClass>(val->as<ValueType::BoolClass>() ? 1 : 0));
|
||||
}
|
||||
else
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Type '{}' cannot be converted to int",
|
||||
val->getTypeInfo().toString().toBasicString())));
|
||||
}
|
||||
}},
|
||||
{u8"__fvalue_double_parse",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
FString str = args[0]->as<ValueType::StringClass>();
|
||||
try
|
||||
{
|
||||
ValueType::DoubleClass val = std::stod(str.toBasicString());
|
||||
return std::make_shared<Object>(ValueType::DoubleClass(val));
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Invalid double string for parsing", str.toBasicString())));
|
||||
}
|
||||
}},
|
||||
{u8"__fvalue_double_from",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
if (val->is<ValueType::IntClass>())
|
||||
{
|
||||
return std::make_shared<Object>(
|
||||
static_cast<ValueType::DoubleClass>(val->as<ValueType::IntClass>()));
|
||||
}
|
||||
else if (val->is<ValueType::BoolClass>())
|
||||
{
|
||||
return std::make_shared<Object>(
|
||||
ValueType::DoubleClass(val->as<ValueType::BoolClass>() ? 1.0 : 0.0));
|
||||
}
|
||||
else
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Type '{}' cannot be converted to double",
|
||||
val->getTypeInfo().toString().toBasicString())));
|
||||
}
|
||||
}},
|
||||
{u8"__fvalue_string_from",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
return std::make_shared<Object>(val->toStringIO());
|
||||
}},
|
||||
{u8"__ftime_now_ns",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
// returns nanoseconds
|
||||
using namespace Fig::Time;
|
||||
auto now = Clock::now();
|
||||
return std::make_shared<Object>(static_cast<ValueType::IntClass>(
|
||||
std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time).count()));
|
||||
}},
|
||||
|
||||
/* math start */
|
||||
{u8"__fmath_acos",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(acos(d));
|
||||
}},
|
||||
{u8"__fmath_acosh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(acosh(d));
|
||||
}},
|
||||
{u8"__fmath_asin",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(asin(d));
|
||||
}},
|
||||
{u8"__fmath_asinh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(asinh(d));
|
||||
}},
|
||||
{u8"__fmath_atan",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(atan(d));
|
||||
}},
|
||||
{u8"__fmath_atan2",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::DoubleClass y = args[0]->getNumericValue();
|
||||
ValueType::DoubleClass x = args[1]->getNumericValue();
|
||||
return std::make_shared<Object>(atan2(y, x));
|
||||
}},
|
||||
{u8"__fmath_atanh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(atanh(d));
|
||||
}},
|
||||
{u8"__fmath_ceil",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(ceil(d));
|
||||
}},
|
||||
{u8"__fmath_cos",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(cos(d));
|
||||
}},
|
||||
{u8"__fmath_cosh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(cosh(d));
|
||||
}},
|
||||
{u8"__fmath_exp",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(exp(d));
|
||||
}},
|
||||
{u8"__fmath_expm1",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(expm1(d));
|
||||
}},
|
||||
{u8"__fmath_fabs",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(fabs(d));
|
||||
}},
|
||||
{u8"__fmath_floor",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(floor(d));
|
||||
}},
|
||||
{u8"__fmath_fmod",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::DoubleClass x = args[0]->getNumericValue();
|
||||
ValueType::DoubleClass y = args[1]->getNumericValue();
|
||||
return std::make_shared<Object>(fmod(x, y));
|
||||
}},
|
||||
{u8"__fmath_frexp",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
int e;
|
||||
return std::make_shared<Object>(List({std::make_shared<Object>(frexp(d, &e)),
|
||||
std::make_shared<Object>(static_cast<ValueType::IntClass>(e))}));
|
||||
}},
|
||||
{u8"__fmath_gcd",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::IntClass x = args[0]->as<ValueType::IntClass>();
|
||||
ValueType::IntClass y = args[1]->as<ValueType::IntClass>();
|
||||
return std::make_shared<Object>(std::gcd(x, y));
|
||||
}},
|
||||
{u8"__fmath_hypot",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::DoubleClass x = args[0]->getNumericValue();
|
||||
ValueType::DoubleClass y = args[1]->getNumericValue();
|
||||
return std::make_shared<Object>(hypot(x, y));
|
||||
}},
|
||||
{u8"__fmath_isequal",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::DoubleClass x = args[0]->getNumericValue();
|
||||
ValueType::DoubleClass y = args[1]->getNumericValue();
|
||||
static const double epsilon = 1e-9;
|
||||
return std::make_shared<Object>(fabs(x - y) < epsilon);
|
||||
}},
|
||||
{u8"__fmath_log",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(log(d));
|
||||
}},
|
||||
{u8"__fmath_log10",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(log10(d));
|
||||
}},
|
||||
{u8"__fmath_log1p",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(log1p(d));
|
||||
}},
|
||||
{u8"__fmath_log2",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(log2(d));
|
||||
}},
|
||||
{u8"__fmath_sin",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(sin(d));
|
||||
}},
|
||||
{u8"__fmath_sinh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(sinh(d));
|
||||
}},
|
||||
{u8"__fmath_sqrt",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(sqrt(d));
|
||||
}},
|
||||
{u8"__fmath_tan",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(tan(d));
|
||||
}},
|
||||
{u8"__fmath_tanh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(tanh(d));
|
||||
}},
|
||||
{u8"__fmath_trunc",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(trunc(d));
|
||||
}},
|
||||
};
|
||||
return builtinFunctions;
|
||||
}
|
||||
}
|
||||
@@ -1,28 +1,23 @@
|
||||
#pragma once
|
||||
|
||||
#include "Ast/Expressions/VarExpr.hpp"
|
||||
#include "Ast/Statements/VarDef.hpp"
|
||||
#include "Ast/astBase.hpp"
|
||||
#include <Ast/Statements/InterfaceDefSt.hpp>
|
||||
#include <Ast/Expressions/VarExpr.hpp>
|
||||
|
||||
#include <Ast/functionParameters.hpp>
|
||||
#include <Core/fig_string.hpp>
|
||||
#include <Value/value.hpp>
|
||||
#include <Evaluator/Value/value.hpp>
|
||||
#include <Core/runtimeTime.hpp>
|
||||
|
||||
#include <chrono>
|
||||
#include <numeric>
|
||||
|
||||
#include <unordered_map>
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
#include <print>
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
|
||||
|
||||
namespace Fig
|
||||
{
|
||||
namespace Builtins
|
||||
{
|
||||
const TypeInfo ErrorInterfaceTypeInfo(u8"Error", true);
|
||||
static const TypeInfo ErrorInterfaceTypeInfo(u8"Error", true);
|
||||
/*
|
||||
// error's interface like:
|
||||
interface Error
|
||||
@@ -33,379 +28,24 @@ namespace Fig
|
||||
}
|
||||
*/
|
||||
|
||||
const std::unordered_map<FString, ObjectPtr> builtinValues = {
|
||||
{u8"null", Object::getNullInstance()},
|
||||
{u8"true", Object::getTrueInstance()},
|
||||
{u8"false", Object::getFalseInstance()},
|
||||
{u8"Error",
|
||||
std::make_shared<Object>(InterfaceType(ErrorInterfaceTypeInfo,
|
||||
{Ast::InterfaceMethod(u8"toString",
|
||||
Ast::FunctionParameters({}, {}),
|
||||
std::make_shared<Ast::VarExprAst>(u8"String"),
|
||||
nullptr),
|
||||
Ast::InterfaceMethod(u8"getErrorClass",
|
||||
Ast::FunctionParameters({}, {}),
|
||||
std::make_shared<Ast::VarExprAst>(u8"String"),
|
||||
nullptr),
|
||||
Ast::InterfaceMethod(u8"getErrorMessage",
|
||||
Ast::FunctionParameters({}, {}),
|
||||
std::make_shared<Ast::VarExprAst>(u8"String"),
|
||||
nullptr)}))},
|
||||
|
||||
{u8"Any", std::make_shared<Object>(StructType(ValueType::Any, nullptr, {}, true))},
|
||||
{u8"Int", std::make_shared<Object>(StructType(ValueType::Int, nullptr, {}, true))},
|
||||
{u8"Null", std::make_shared<Object>(StructType(ValueType::Null, nullptr, {}, true))},
|
||||
{u8"String", std::make_shared<Object>(StructType(ValueType::String, nullptr, {}, true))},
|
||||
{u8"Bool", std::make_shared<Object>(StructType(ValueType::Bool, nullptr, {}, true))},
|
||||
{u8"Double", std::make_shared<Object>(StructType(ValueType::Double, nullptr, {}, true))},
|
||||
{u8"Function", std::make_shared<Object>(StructType(ValueType::Function, nullptr, {}, true))},
|
||||
{u8"List", std::make_shared<Object>(StructType(ValueType::List, nullptr, {}, true))},
|
||||
{u8"Map", std::make_shared<Object>(StructType(ValueType::Map, nullptr, {}, true))},
|
||||
// Type `StructType` `StructInstance` `Module` `InterfaceType`
|
||||
// Not allowed to call constructor!
|
||||
};
|
||||
const std::unordered_map<FString, ObjectPtr> &getBuiltinValues();
|
||||
|
||||
using BuiltinFunction = std::function<ObjectPtr(const std::vector<ObjectPtr> &)>;
|
||||
|
||||
const std::unordered_map<FString, int> builtinFunctionArgCounts = {
|
||||
{u8"__fstdout_print", -1}, // variadic
|
||||
{u8"__fstdout_println", -1}, // variadic
|
||||
{u8"__fstdin_read", 0},
|
||||
{u8"__fstdin_readln", 0},
|
||||
{u8"__fvalue_type", 1},
|
||||
{u8"__fvalue_int_parse", 1},
|
||||
{u8"__fvalue_int_from", 1},
|
||||
{u8"__fvalue_double_parse", 1},
|
||||
{u8"__fvalue_double_from", 1},
|
||||
{u8"__fvalue_string_from", 1},
|
||||
{u8"__ftime_now_ns", 0},
|
||||
/* math start */
|
||||
{u8"__fmath_acos", 1},
|
||||
{u8"__fmath_acosh", 1},
|
||||
{u8"__fmath_asin", 1},
|
||||
{u8"__fmath_asinh", 1},
|
||||
{u8"__fmath_atan", 1},
|
||||
{u8"__fmath_atan2", 2},
|
||||
{u8"__fmath_atanh", 1},
|
||||
{u8"__fmath_ceil", 1},
|
||||
{u8"__fmath_cos", 1},
|
||||
{u8"__fmath_cosh", 1},
|
||||
{u8"__fmath_exp", 1},
|
||||
{u8"__fmath_expm1", 1},
|
||||
{u8"__fmath_fabs", 1},
|
||||
{u8"__fmath_floor", 1},
|
||||
{u8"__fmath_fmod", 2},
|
||||
{u8"__fmath_frexp", 1},
|
||||
{u8"__fmath_gcd", 2},
|
||||
{u8"__fmath_hypot", 2},
|
||||
{u8"__fmath_isequal", 2},
|
||||
{u8"__fmath_log", 1},
|
||||
{u8"__fmath_log10", 1},
|
||||
{u8"__fmath_log1p", 1},
|
||||
{u8"__fmath_log2", 1},
|
||||
{u8"__fmath_sin", 1},
|
||||
{u8"__fmath_sinh", 1},
|
||||
{u8"__fmath_sqrt", 1},
|
||||
{u8"__fmath_tan", 1},
|
||||
{u8"__fmath_tanh", 1},
|
||||
{u8"__fmath_trunc", 1},
|
||||
};
|
||||
|
||||
const std::unordered_map<FString, BuiltinFunction> builtinFunctions{
|
||||
{u8"__fstdout_print",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
for (auto arg : args) { std::print("{}", arg->toStringIO().toBasicString()); }
|
||||
return std::make_shared<Object>(ValueType::IntClass(args.size()));
|
||||
}},
|
||||
{u8"__fstdout_println",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
for (auto arg : args) { std::print("{}", arg->toStringIO().toBasicString()); }
|
||||
std::print("\n");
|
||||
return std::make_shared<Object>(ValueType::IntClass(args.size()));
|
||||
}},
|
||||
{u8"__fstdin_read",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
std::string input;
|
||||
std::cin >> input;
|
||||
return std::make_shared<Object>(FString::fromBasicString(input));
|
||||
}},
|
||||
{u8"__fstdin_readln",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
std::string line;
|
||||
std::getline(std::cin, line);
|
||||
return std::make_shared<Object>(FString::fromBasicString(line));
|
||||
}},
|
||||
{u8"__fvalue_type",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
return std::make_shared<Object>(args[0]->getTypeInfo().toString());
|
||||
}},
|
||||
{u8"__fvalue_int_parse",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
FString str = args[0]->as<ValueType::StringClass>();
|
||||
try
|
||||
{
|
||||
ValueType::IntClass val = std::stoi(str.toBasicString());
|
||||
return std::make_shared<Object>(val);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Invalid int string for parsing", str.toBasicString())));
|
||||
}
|
||||
}},
|
||||
{u8"__fvalue_int_from",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
if (val->is<ValueType::DoubleClass>())
|
||||
{
|
||||
return std::make_shared<Object>(
|
||||
static_cast<ValueType::IntClass>(val->as<ValueType::DoubleClass>()));
|
||||
}
|
||||
else if (val->is<ValueType::BoolClass>())
|
||||
{
|
||||
return std::make_shared<Object>(
|
||||
static_cast<ValueType::IntClass>(val->as<ValueType::BoolClass>() ? 1 : 0));
|
||||
}
|
||||
else
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Type '{}' cannot be converted to int",
|
||||
val->getTypeInfo().toString().toBasicString())));
|
||||
}
|
||||
}},
|
||||
{u8"__fvalue_double_parse",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
FString str = args[0]->as<ValueType::StringClass>();
|
||||
try
|
||||
{
|
||||
ValueType::DoubleClass val = std::stod(str.toBasicString());
|
||||
return std::make_shared<Object>(ValueType::DoubleClass(val));
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Invalid double string for parsing", str.toBasicString())));
|
||||
}
|
||||
}},
|
||||
{u8"__fvalue_double_from",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
if (val->is<ValueType::IntClass>())
|
||||
{
|
||||
return std::make_shared<Object>(
|
||||
static_cast<ValueType::DoubleClass>(val->as<ValueType::IntClass>()));
|
||||
}
|
||||
else if (val->is<ValueType::BoolClass>())
|
||||
{
|
||||
return std::make_shared<Object>(
|
||||
ValueType::DoubleClass(val->as<ValueType::BoolClass>() ? 1.0 : 0.0));
|
||||
}
|
||||
else
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Type '{}' cannot be converted to double",
|
||||
val->getTypeInfo().toString().toBasicString())));
|
||||
}
|
||||
}},
|
||||
{u8"__fvalue_string_from",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
return std::make_shared<Object>(val->toStringIO());
|
||||
}},
|
||||
{u8"__ftime_now_ns",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
// returns nanoseconds
|
||||
using namespace Fig::Time;
|
||||
auto now = Clock::now();
|
||||
return std::make_shared<Object>(static_cast<ValueType::IntClass>(
|
||||
std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time).count()));
|
||||
}},
|
||||
const std::unordered_map<FString, int> &getBuiltinFunctionArgCounts();
|
||||
const std::unordered_map<FString, BuiltinFunction> &getBuiltinFunctions();
|
||||
|
||||
/* math start */
|
||||
{u8"__fmath_acos",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(acos(d));
|
||||
}},
|
||||
{u8"__fmath_acosh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(acosh(d));
|
||||
}},
|
||||
{u8"__fmath_asin",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(asin(d));
|
||||
}},
|
||||
{u8"__fmath_asinh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(asinh(d));
|
||||
}},
|
||||
{u8"__fmath_atan",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(atan(d));
|
||||
}},
|
||||
{u8"__fmath_atan2",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::DoubleClass y = args[0]->getNumericValue();
|
||||
ValueType::DoubleClass x = args[1]->getNumericValue();
|
||||
return std::make_shared<Object>(atan2(y, x));
|
||||
}},
|
||||
{u8"__fmath_atanh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(atanh(d));
|
||||
}},
|
||||
{u8"__fmath_ceil",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(ceil(d));
|
||||
}},
|
||||
{u8"__fmath_cos",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(cos(d));
|
||||
}},
|
||||
{u8"__fmath_cosh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(cosh(d));
|
||||
}},
|
||||
{u8"__fmath_exp",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(exp(d));
|
||||
}},
|
||||
{u8"__fmath_expm1",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(expm1(d));
|
||||
}},
|
||||
{u8"__fmath_fabs",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(fabs(d));
|
||||
}},
|
||||
{u8"__fmath_floor",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(floor(d));
|
||||
}},
|
||||
{u8"__fmath_fmod",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::DoubleClass x = args[0]->getNumericValue();
|
||||
ValueType::DoubleClass y = args[1]->getNumericValue();
|
||||
return std::make_shared<Object>(fmod(x, y));
|
||||
}},
|
||||
{u8"__fmath_frexp",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
int e;
|
||||
return std::make_shared<Object>(List({std::make_shared<Object>(frexp(d, &e)),
|
||||
std::make_shared<Object>(static_cast<ValueType::IntClass>(e))}));
|
||||
}},
|
||||
{u8"__fmath_gcd",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::IntClass x = args[0]->as<ValueType::IntClass>();
|
||||
ValueType::IntClass y = args[1]->as<ValueType::IntClass>();
|
||||
return std::make_shared<Object>(std::gcd(x, y));
|
||||
}},
|
||||
{u8"__fmath_hypot",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::DoubleClass x = args[0]->getNumericValue();
|
||||
ValueType::DoubleClass y = args[1]->getNumericValue();
|
||||
return std::make_shared<Object>(hypot(x, y));
|
||||
}},
|
||||
{u8"__fmath_isequal",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ValueType::DoubleClass x = args[0]->getNumericValue();
|
||||
ValueType::DoubleClass y = args[1]->getNumericValue();
|
||||
static const double epsilon = 1e-9;
|
||||
return std::make_shared<Object>(fabs(x - y) < epsilon);
|
||||
}},
|
||||
{u8"__fmath_log",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(log(d));
|
||||
}},
|
||||
{u8"__fmath_log10",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(log10(d));
|
||||
}},
|
||||
{u8"__fmath_log1p",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(log1p(d));
|
||||
}},
|
||||
{u8"__fmath_log2",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(log2(d));
|
||||
}},
|
||||
{u8"__fmath_sin",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(sin(d));
|
||||
}},
|
||||
{u8"__fmath_sinh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(sinh(d));
|
||||
}},
|
||||
{u8"__fmath_sqrt",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(sqrt(d));
|
||||
}},
|
||||
{u8"__fmath_tan",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(tan(d));
|
||||
}},
|
||||
{u8"__fmath_tanh",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(tanh(d));
|
||||
}},
|
||||
{u8"__fmath_trunc",
|
||||
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
||||
ObjectPtr val = args[0];
|
||||
ValueType::DoubleClass d = val->getNumericValue();
|
||||
return std::make_shared<Object>(trunc(d));
|
||||
}},
|
||||
};
|
||||
|
||||
inline bool isBuiltinFunction(const FString &name)
|
||||
{
|
||||
return builtinFunctions.find(name) != builtinFunctions.end();
|
||||
return getBuiltinFunctions().find(name) != getBuiltinFunctions().end();
|
||||
}
|
||||
|
||||
inline BuiltinFunction getBuiltinFunction(const FString &name)
|
||||
{
|
||||
auto it = builtinFunctions.find(name);
|
||||
if (it == builtinFunctions.end())
|
||||
auto it = getBuiltinFunctions().find(name);
|
||||
if (it == getBuiltinFunctions().end())
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Builtin function '{}' not found", name.toBasicString())));
|
||||
}
|
||||
@@ -414,8 +54,8 @@ namespace Fig
|
||||
|
||||
inline int getBuiltinFunctionParamCount(const FString &name)
|
||||
{
|
||||
auto it = builtinFunctionArgCounts.find(name);
|
||||
if (it == builtinFunctionArgCounts.end())
|
||||
auto it = getBuiltinFunctionArgCounts().find(name);
|
||||
if (it == getBuiltinFunctionArgCounts().end())
|
||||
{
|
||||
throw RuntimeError(FString(std::format("Builtin function '{}' not found", name.toBasicString())));
|
||||
}
|
||||
|
||||
14
xmake.lua
14
xmake.lua
@@ -26,16 +26,22 @@ target("Fig")
|
||||
end
|
||||
|
||||
|
||||
add_files("src/Evaluator/main.cpp")
|
||||
|
||||
add_files("src/Core/warning.cpp")
|
||||
add_files("src/Core/runtimeTime.cpp")
|
||||
add_files("src/Evaluator/evaluator.cpp")
|
||||
add_files("src/Evaluator/Value/value.cpp")
|
||||
|
||||
add_files("src/Lexer/lexer.cpp")
|
||||
add_files("src/Parser/parser.cpp")
|
||||
|
||||
add_files("src/Module/builtins.cpp")
|
||||
|
||||
add_files("src/Evaluator/Value/value.cpp")
|
||||
add_files("src/Evaluator/Core/*.cpp")
|
||||
add_files("src/Evaluator/evaluator.cpp")
|
||||
add_files("src/Evaluator/main.cpp")
|
||||
|
||||
add_includedirs("src")
|
||||
add_includedirs("src/Evaluator")
|
||||
-- add_includedirs("src/Evaluator")
|
||||
|
||||
set_warnings("all")
|
||||
|
||||
|
||||
Reference in New Issue
Block a user