427 lines
20 KiB
C++
427 lines
20 KiB
C++
#include <Ast/Expressions/BinaryExpr.hpp>
|
|
#include <Ast/Expressions/FunctionCall.hpp>
|
|
#include <Ast/Expressions/ValueExpr.hpp>
|
|
#include <Ast/Expressions/VarExpr.hpp>
|
|
#include <Ast/Statements/ControlSt.hpp>
|
|
#include <Ast/astBase.hpp>
|
|
#include <Ast/functionParameters.hpp>
|
|
#include <Evaluator/Context/context.hpp>
|
|
#include <Core/String.hpp>
|
|
#include <Ast/AccessModifier.hpp>
|
|
#include <Evaluator/Value/structType.hpp>
|
|
#include <Evaluator/Value/value.hpp>
|
|
#include <Module/builtins.hpp>
|
|
|
|
#include <memory>
|
|
#include <print>
|
|
#include <iostream>
|
|
#include <cmath>
|
|
#include <chrono>
|
|
#include <numeric>
|
|
#include <unordered_map>
|
|
|
|
namespace Fig::Builtins
|
|
{
|
|
const TypeInfo &getErrorInterfaceTypeInfo()
|
|
{
|
|
static const TypeInfo ErrorInterfaceTypeInfo(U"Error", true);
|
|
return ErrorInterfaceTypeInfo;
|
|
}
|
|
const TypeInfo &getTypeErrorStructTypeInfo()
|
|
{
|
|
static const TypeInfo TypeErrorStructTypeInfo(U"TypeError", true);
|
|
return TypeErrorStructTypeInfo;
|
|
}
|
|
const TypeInfo &getOperationInterfaceTypeInfo()
|
|
{
|
|
static const TypeInfo OperationInterfaceTypeInfo(U"Operation", true);
|
|
return OperationInterfaceTypeInfo;
|
|
}
|
|
const std::unordered_map<String, ObjectPtr> &getBuiltinValues()
|
|
{
|
|
static const std::unordered_map<String, ObjectPtr> builtinValues = {
|
|
{U"null", Object::getNullInstance()},
|
|
{U"true", Object::getTrueInstance()},
|
|
{U"false", Object::getFalseInstance()},
|
|
{U"Error",
|
|
std::make_shared<Object>(InterfaceType(getErrorInterfaceTypeInfo(),
|
|
{Ast::InterfaceMethod(U"toString",
|
|
Ast::FunctionParameters({}, {}),
|
|
std::make_shared<Ast::VarExprAst>(U"String"),
|
|
nullptr),
|
|
Ast::InterfaceMethod(U"getErrorClass",
|
|
Ast::FunctionParameters({}, {}),
|
|
std::make_shared<Ast::VarExprAst>(U"String"),
|
|
nullptr),
|
|
Ast::InterfaceMethod(U"getErrorMessage",
|
|
Ast::FunctionParameters({}, {}),
|
|
std::make_shared<Ast::VarExprAst>(U"String"),
|
|
nullptr)}))},
|
|
{U"TypeError", std::make_shared<Object>(StructType(
|
|
getTypeErrorStructTypeInfo(),
|
|
std::make_shared<Context>(U"<Built-in `TypeError`>"),
|
|
{Field(AccessModifier::Public, U"msg", ValueType::String, nullptr)}
|
|
))},
|
|
{U"Operation", std::make_shared<Object>(InterfaceType(getOperationInterfaceTypeInfo(), {}))},
|
|
|
|
{U"Any", std::make_shared<Object>(StructType(ValueType::Any, nullptr, {}, true))},
|
|
{U"Int", std::make_shared<Object>(StructType(ValueType::Int, nullptr, {}, true))},
|
|
{U"Null", std::make_shared<Object>(StructType(ValueType::Null, nullptr, {}, true))},
|
|
{U"String", std::make_shared<Object>(StructType(ValueType::String, nullptr, {}, true))},
|
|
{U"Bool", std::make_shared<Object>(StructType(ValueType::Bool, nullptr, {}, true))},
|
|
{U"Double", std::make_shared<Object>(StructType(ValueType::Double, nullptr, {}, true))},
|
|
{U"Function", std::make_shared<Object>(StructType(ValueType::Function, nullptr, {}, true))},
|
|
{U"List", std::make_shared<Object>(StructType(ValueType::List, nullptr, {}, true))},
|
|
{U"Map", std::make_shared<Object>(StructType(ValueType::Map, nullptr, {}, true))},
|
|
// Type `StructType` `StructInstance` `Module` `InterfaceType`
|
|
// Not allowed to call constructor!
|
|
|
|
{U"type", std::make_shared<Object>(Function(
|
|
U"type",
|
|
[](const std::vector<ObjectPtr> &_args) -> ObjectPtr
|
|
{
|
|
const ObjectPtr &arg = _args[0];
|
|
return std::make_shared<Object>(prettyType(arg));
|
|
},
|
|
1
|
|
))},
|
|
};
|
|
return builtinValues;
|
|
}
|
|
const std::unordered_map<String, int> &getBuiltinFunctionArgCounts()
|
|
{
|
|
static const std::unordered_map<String, int> builtinFunctionArgCounts = {
|
|
{U"__fstdout_print", -1}, // variadic
|
|
{U"__fstdout_println", -1}, // variadic
|
|
{U"__fstdin_read", 0},
|
|
{U"__fstdin_readln", 0},
|
|
{U"__fvalue_type", 1},
|
|
{U"__fvalue_int_parse", 1},
|
|
{U"__fvalue_int_from", 1},
|
|
{U"__fvalue_double_parse", 1},
|
|
{U"__fvalue_double_from", 1},
|
|
{U"__fvalue_string_from", 1},
|
|
{U"__ftime_now_ns", 0},
|
|
/* math start */
|
|
{U"__fmath_acos", 1},
|
|
{U"__fmath_acosh", 1},
|
|
{U"__fmath_asin", 1},
|
|
{U"__fmath_asinh", 1},
|
|
{U"__fmath_atan", 1},
|
|
{U"__fmath_atan2", 2},
|
|
{U"__fmath_atanh", 1},
|
|
{U"__fmath_ceil", 1},
|
|
{U"__fmath_cos", 1},
|
|
{U"__fmath_cosh", 1},
|
|
{U"__fmath_exp", 1},
|
|
{U"__fmath_expm1", 1},
|
|
{U"__fmath_fabs", 1},
|
|
{U"__fmath_floor", 1},
|
|
{U"__fmath_fmod", 2},
|
|
{U"__fmath_frexp", 1},
|
|
{U"__fmath_gcd", 2},
|
|
{U"__fmath_hypot", 2},
|
|
{U"__fmath_isequal", 2},
|
|
{U"__fmath_log", 1},
|
|
{U"__fmath_log10", 1},
|
|
{U"__fmath_log1p", 1},
|
|
{U"__fmath_log2", 1},
|
|
{U"__fmath_sin", 1},
|
|
{U"__fmath_sinh", 1},
|
|
{U"__fmath_sqrt", 1},
|
|
{U"__fmath_tan", 1},
|
|
{U"__fmath_tanh", 1},
|
|
{U"__fmath_trunc", 1},
|
|
};
|
|
return builtinFunctionArgCounts;
|
|
}
|
|
const std::unordered_map<String, BuiltinFunction> &getBuiltinFunctions()
|
|
{
|
|
static const std::unordered_map<String, BuiltinFunction> builtinFunctions{
|
|
{U"__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()));
|
|
}},
|
|
{U"__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()));
|
|
}},
|
|
{U"__fstdin_read",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
std::string input;
|
|
std::cin >> input;
|
|
return std::make_shared<Object>(String(input));
|
|
}},
|
|
{U"__fstdin_readln",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
std::string line;
|
|
std::getline(std::cin, line);
|
|
return std::make_shared<Object>(String(line));
|
|
}},
|
|
{U"__fvalue_type",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
return std::make_shared<Object>(args[0]->getTypeInfo().toString());
|
|
}},
|
|
{U"__fvalue_int_parse",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
String str = args[0]->as<ValueType::StringClass>();
|
|
try
|
|
{
|
|
ValueType::IntClass val = std::stoi(str.toBasicString());
|
|
return std::make_shared<Object>(val);
|
|
}
|
|
catch (...)
|
|
{
|
|
throw RuntimeError(String(std::format("Invalid int string for parsing", str.toBasicString())));
|
|
}
|
|
}},
|
|
{U"__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(String(std::format("Type '{}' cannot be converted to int",
|
|
val->getTypeInfo().toString().toBasicString())));
|
|
}
|
|
}},
|
|
{U"__fvalue_double_parse",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
String 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(String(std::format("Invalid double string for parsing", str.toBasicString())));
|
|
}
|
|
}},
|
|
{U"__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(String(std::format("Type '{}' cannot be converted to double",
|
|
val->getTypeInfo().toString().toBasicString())));
|
|
}
|
|
}},
|
|
{U"__fvalue_string_from",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
return std::make_shared<Object>(val->toStringIO());
|
|
}},
|
|
{U"__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 */
|
|
{U"__fmath_acos",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(acos(d));
|
|
}},
|
|
{U"__fmath_acosh",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(acosh(d));
|
|
}},
|
|
{U"__fmath_asin",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(asin(d));
|
|
}},
|
|
{U"__fmath_asinh",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(asinh(d));
|
|
}},
|
|
{U"__fmath_atan",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(atan(d));
|
|
}},
|
|
{U"__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));
|
|
}},
|
|
{U"__fmath_atanh",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(atanh(d));
|
|
}},
|
|
{U"__fmath_ceil",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(ceil(d));
|
|
}},
|
|
{U"__fmath_cos",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(cos(d));
|
|
}},
|
|
{U"__fmath_cosh",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(cosh(d));
|
|
}},
|
|
{U"__fmath_exp",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(exp(d));
|
|
}},
|
|
{U"__fmath_expm1",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(expm1(d));
|
|
}},
|
|
{U"__fmath_fabs",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(fabs(d));
|
|
}},
|
|
{U"__fmath_floor",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(floor(d));
|
|
}},
|
|
{U"__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));
|
|
}},
|
|
{U"__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))}));
|
|
}},
|
|
{U"__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));
|
|
}},
|
|
{U"__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));
|
|
}},
|
|
{U"__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);
|
|
}},
|
|
{U"__fmath_log",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(log(d));
|
|
}},
|
|
{U"__fmath_log10",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(log10(d));
|
|
}},
|
|
{U"__fmath_log1p",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(log1p(d));
|
|
}},
|
|
{U"__fmath_log2",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(log2(d));
|
|
}},
|
|
{U"__fmath_sin",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(sin(d));
|
|
}},
|
|
{U"__fmath_sinh",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(sinh(d));
|
|
}},
|
|
{U"__fmath_sqrt",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(sqrt(d));
|
|
}},
|
|
{U"__fmath_tan",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(tan(d));
|
|
}},
|
|
{U"__fmath_tanh",
|
|
[](const std::vector<ObjectPtr> &args) -> ObjectPtr {
|
|
ObjectPtr val = args[0];
|
|
ValueType::DoubleClass d = val->getNumericValue();
|
|
return std::make_shared<Object>(tanh(d));
|
|
}},
|
|
{U"__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;
|
|
}
|
|
} // namespace Fig::Builtins
|