You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1005 lines
33 KiB
1005 lines
33 KiB
#include <map>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <peglib.h>
|
|
|
|
namespace culebra {
|
|
|
|
const auto grammar_ = R"(
|
|
|
|
PROGRAM <- _ STATEMENTS _
|
|
STATEMENTS <- (STATEMENT (_sp_ (';' / _nl_) (_ STATEMENT)?)*)?
|
|
STATEMENT <- DEBUGGER / RETURN / LEXICAL_SCOPE / EXPRESSION
|
|
|
|
DEBUGGER <- debugger
|
|
RETURN <- return (_sp_ !_nl_ EXPRESSION)?
|
|
LEXICAL_SCOPE <- BLOCK
|
|
|
|
EXPRESSION <- ASSIGNMENT / LOGICAL_OR
|
|
|
|
ASSIGNMENT <- LET _ MUTABLE _ PRIMARY (_ (ARGUMENTS / INDEX / DOT))* _ '=' _ EXPRESSION
|
|
|
|
LOGICAL_OR <- LOGICAL_AND (_ '||' _ LOGICAL_AND)*
|
|
LOGICAL_AND <- CONDITION (_ '&&' _ CONDITION)*
|
|
CONDITION <- ADDITIVE (_ CONDITION_OPERATOR _ ADDITIVE)*
|
|
ADDITIVE <- UNARY_PLUS (_ ADDITIVE_OPERATOR _ UNARY_PLUS)*
|
|
UNARY_PLUS <- UNARY_PLUS_OPERATOR? UNARY_MINUS
|
|
UNARY_MINUS <- UNARY_MINUS_OPERATOR? UNARY_NOT
|
|
UNARY_NOT <- UNARY_NOT_OPERATOR? MULTIPLICATIVE
|
|
MULTIPLICATIVE <- CALL (_ MULTIPLICATIVE_OPERATOR _ CALL)*
|
|
|
|
CALL <- PRIMARY (_ (ARGUMENTS / INDEX / DOT))*
|
|
ARGUMENTS <- '(' _ SEQUENCE _ ')'
|
|
INDEX <- '[' _ EXPRESSION _ ']'
|
|
DOT <- '.' _ IDENTIFIER
|
|
|
|
SEQUENCE <- (EXPRESSION (_ ',' _ EXPRESSION)*)?
|
|
|
|
WHILE <- while _ EXPRESSION _ BLOCK
|
|
IF <- if _ EXPRESSION _ BLOCK (_ else _ if _ EXPRESSION _ BLOCK)* (_ else _ BLOCK)?
|
|
|
|
PRIMARY <- WHILE / IF / FUNCTION / OBJECT / ARRAY / NIL / BOOLEAN / NUMBER / IDENTIFIER / STRING / INTERPOLATED_STRING / '(' _ EXPRESSION _ ')'
|
|
|
|
FUNCTION <- fn _ PARAMETERS _ BLOCK
|
|
PARAMETERS <- '(' _ (PARAMETER (_ ',' _ PARAMETER)*)? _ ')'
|
|
PARAMETER <- MUTABLE _ IDENTIFIER
|
|
|
|
BLOCK <- '{' _ STATEMENTS _ '}'
|
|
|
|
CONDITION_OPERATOR <- '==' / '!=' / '<=' / '<' / '>=' / '>'
|
|
ADDITIVE_OPERATOR <- [-+]
|
|
UNARY_PLUS_OPERATOR <- '+'
|
|
UNARY_MINUS_OPERATOR <- '-'
|
|
UNARY_NOT_OPERATOR <- '!'
|
|
MULTIPLICATIVE_OPERATOR <- [*/%]
|
|
|
|
LET <- < ('let' _wd_)? >
|
|
MUTABLE <- < ('mut' _wd_)? >
|
|
|
|
IDENTIFIER <- < IdentInitChar IdentChar* >
|
|
|
|
OBJECT <- '{' _ (OBJECT_PROPERTY (_ ',' _ OBJECT_PROPERTY)*)? _ '}'
|
|
OBJECT_PROPERTY <- MUTABLE _ IDENTIFIER _ ':' _ EXPRESSION
|
|
|
|
ARRAY <- '[' _ SEQUENCE _ ']' (_ '(' _ EXPRESSION (_ ',' _ EXPRESSION)? _ ')')?
|
|
|
|
NIL <- < 'nil' _wd_ >
|
|
BOOLEAN <- < ('true' / 'false') _wd_ >
|
|
|
|
NUMBER <- < [0-9]+ >
|
|
STRING <- ['] < (!['] .)* > [']
|
|
|
|
INTERPOLATED_STRING <- '"' ('{' _ EXPRESSION _ '}' / INTERPOLATED_CONTENT)* '"'
|
|
INTERPOLATED_CONTENT <- (!["{] .) (!["{] .)*
|
|
|
|
~debugger <- 'debugger' _wd_
|
|
~while <- 'while' _wd_
|
|
~if <- 'if' _wd_
|
|
~else <- 'else' _wd_
|
|
~fn <- 'fn' _wd_
|
|
~return <- 'return' _wd_
|
|
|
|
~_ <- (WhiteSpace / End)*
|
|
~_sp_ <- SpaceChar*
|
|
~_nl_ <- LineComment? End
|
|
~_wd_ <- !IdentInitChar
|
|
|
|
WhiteSpace <- SpaceChar / Comment
|
|
End <- EndOfLine / EndOfFile
|
|
Comment <- BlockComment / LineComment
|
|
|
|
SpaceChar <- ' ' / '\t'
|
|
EndOfLine <- '\r\n' / '\n' / '\r'
|
|
EndOfFile <- !.
|
|
IdentInitChar <- [a-zA-Z_]
|
|
IdentChar <- [a-zA-Z0-9_]
|
|
BlockComment <- '/*' (!'*/' .)* '*/'
|
|
LineComment <- ('#' / '//') (!End .)* &End
|
|
|
|
)";
|
|
|
|
inline peg::parser& get_parser()
|
|
{
|
|
static peg::parser parser;
|
|
static bool initialized = false;
|
|
|
|
if (!initialized) {
|
|
initialized = true;
|
|
|
|
parser.log = [&](size_t ln, size_t col, const std::string& msg) {
|
|
std::cerr << ln << ":" << col << ": " << msg << std::endl;
|
|
};
|
|
|
|
if (!parser.load_grammar(grammar_)) {
|
|
throw std::logic_error("invalid peg grammar");
|
|
}
|
|
|
|
parser.enable_ast();
|
|
}
|
|
|
|
return parser;
|
|
}
|
|
|
|
struct Value;
|
|
struct Symbol;
|
|
struct Environment;
|
|
|
|
struct FunctionValue {
|
|
struct Parameter {
|
|
std::string name;
|
|
bool mut;
|
|
};
|
|
|
|
FunctionValue(
|
|
const std::vector<Parameter>& params,
|
|
const std::function<Value (std::shared_ptr<Environment> env)>& eval)
|
|
: params(std::make_shared<std::vector<Parameter>>(params))
|
|
, eval(eval) {}
|
|
|
|
std::shared_ptr<std::vector<Parameter>> params;
|
|
std::function<Value (std::shared_ptr<Environment> env)> eval;
|
|
};
|
|
|
|
struct ObjectValue {
|
|
bool has(const std::string& name) const;
|
|
const Value& get(const std::string& name) const;
|
|
void assign(const std::string& name, const Value& val);
|
|
void initialize(const std::string& name, const Value& val, bool mut);
|
|
virtual std::map<std::string, Value>& builtins();
|
|
|
|
std::shared_ptr<std::map<std::string, Symbol>> properties =
|
|
std::make_shared<std::map<std::string, Symbol>>();
|
|
};
|
|
|
|
struct ArrayValue : public ObjectValue {
|
|
std::map<std::string, Value>& builtins() override;
|
|
|
|
std::shared_ptr<std::vector<Value>> values =
|
|
std::make_shared<std::vector<Value>>();
|
|
};
|
|
|
|
struct Value
|
|
{
|
|
enum Type { Nil, Bool, Long, String, Object, Array, Function };
|
|
|
|
Value() : type(Nil) {}
|
|
Value(const Value& rhs) : type(rhs.type), v(rhs.v) {}
|
|
Value(Value&& rhs) : type(rhs.type), v(rhs.v) {}
|
|
|
|
Value& operator=(const Value& rhs) {
|
|
if (this != &rhs) {
|
|
type = rhs.type;
|
|
v = rhs.v;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Value& operator=(Value&& rhs) {
|
|
type = rhs.type;
|
|
v = rhs.v;
|
|
return *this;
|
|
}
|
|
|
|
explicit Value(bool b) : type(Bool), v(b) {}
|
|
explicit Value(long l) : type(Long), v(l) {}
|
|
explicit Value(std::string&& s) : type(String), v(s) {}
|
|
explicit Value(ObjectValue&& o) : type(Object), v(o) {}
|
|
explicit Value(ArrayValue&& a) : type(Array), v(a) {}
|
|
explicit Value(FunctionValue&& f) : type(Function), v(f) {}
|
|
|
|
bool to_bool() const {
|
|
switch (type) {
|
|
case Bool: return v.get<bool>();
|
|
case Long: return v.get<long>() != 0;
|
|
default: throw std::runtime_error("type error.");
|
|
}
|
|
}
|
|
|
|
long to_long() const {
|
|
switch (type) {
|
|
//case Bool: return v.get<bool>();
|
|
case Long: return v.get<long>();
|
|
default: throw std::runtime_error("type error.");
|
|
}
|
|
}
|
|
|
|
std::string to_string() const {
|
|
switch (type) {
|
|
case String: return v.get<std::string>();
|
|
default: throw std::runtime_error("type error.");
|
|
}
|
|
}
|
|
|
|
FunctionValue to_function() const {
|
|
switch (type) {
|
|
case Function: return v.get<FunctionValue>();
|
|
default: throw std::runtime_error("type error.");
|
|
}
|
|
}
|
|
|
|
const ObjectValue& to_object() const {
|
|
switch (type) {
|
|
case Object: return v.get<ObjectValue>();
|
|
case Array: return v.get<ArrayValue>();
|
|
default: throw std::runtime_error("type error.");
|
|
}
|
|
}
|
|
|
|
ObjectValue& to_object() {
|
|
switch (type) {
|
|
case Object: return v.get<ObjectValue>();
|
|
default: throw std::runtime_error("type error.");
|
|
}
|
|
}
|
|
|
|
const ArrayValue& to_array() const {
|
|
switch (type) {
|
|
case Array: return v.get<ArrayValue>();
|
|
default: throw std::runtime_error("type error.");
|
|
}
|
|
}
|
|
|
|
std::string str_object() const;
|
|
|
|
std::string str_array() const {
|
|
const auto& values = *to_array().values;
|
|
std::string s = "[";
|
|
for (auto i = 0u; i < values.size(); i++) {
|
|
if (i != 0) {
|
|
s += ", ";
|
|
}
|
|
s += values[i].str();
|
|
}
|
|
s += "]";
|
|
return s;
|
|
}
|
|
|
|
std::string str() const {
|
|
switch (type) {
|
|
case Nil: return "nil";
|
|
case Bool: return to_bool() ? "true" : "false";
|
|
case Long: return std::to_string(to_long());
|
|
case String: return "'" + to_string() + "'";
|
|
case Object: return str_object();
|
|
case Array: return str_array();
|
|
case Function: return "[function]";
|
|
default: throw std::logic_error("invalid internal condition.");
|
|
}
|
|
// NOTREACHED
|
|
}
|
|
|
|
std::ostream& out(std::ostream& os) const {
|
|
os << str();
|
|
return os;
|
|
}
|
|
|
|
bool operator==(const Value& rhs) const {
|
|
switch (type) {
|
|
case Nil: return rhs.type == Nil;
|
|
case Bool: return to_bool() == rhs.to_bool();
|
|
case Long: return to_long() == rhs.to_long();
|
|
case String: return to_string() == rhs.to_string();
|
|
// TODO: Object and Array support
|
|
default: throw std::logic_error("invalid internal condition.");
|
|
}
|
|
// NOTREACHED
|
|
}
|
|
|
|
bool operator!=(const Value& rhs) const {
|
|
return !operator==(rhs);
|
|
}
|
|
|
|
bool operator<=(const Value& rhs) const {
|
|
switch (type) {
|
|
case Nil: return false;
|
|
case Bool: return to_bool() <= rhs.to_bool();
|
|
case Long: return to_long() <= rhs.to_long();
|
|
case String: return to_string() <= rhs.to_string();
|
|
// TODO: Object and Array support
|
|
default: throw std::logic_error("invalid internal condition.");
|
|
}
|
|
// NOTREACHED
|
|
}
|
|
|
|
bool operator<(const Value& rhs) const {
|
|
switch (type) {
|
|
case Nil: return false;
|
|
case Bool: return to_bool() < rhs.to_bool();
|
|
case Long: return to_long() < rhs.to_long();
|
|
case String: return to_string() < rhs.to_string();
|
|
// TODO: Object and Array support
|
|
default: throw std::logic_error("invalid internal condition.");
|
|
}
|
|
// NOTREACHED
|
|
}
|
|
|
|
bool operator>=(const Value& rhs) const {
|
|
switch (type) {
|
|
case Nil: return false;
|
|
case Bool: return to_bool() >= rhs.to_bool();
|
|
case Long: return to_long() >= rhs.to_long();
|
|
case String: return to_string() >= rhs.to_string();
|
|
// TODO: Object and Array support
|
|
default: throw std::logic_error("invalid internal condition.");
|
|
}
|
|
// NOTREACHED
|
|
}
|
|
|
|
bool operator>(const Value& rhs) const {
|
|
switch (type) {
|
|
case Nil: return false;
|
|
case Bool: return to_bool() > rhs.to_bool();
|
|
case Long: return to_long() > rhs.to_long();
|
|
case String: return to_string() > rhs.to_string();
|
|
// TODO: Object and Array support
|
|
default: throw std::logic_error("invalid internal condition.");
|
|
}
|
|
// NOTREACHED
|
|
}
|
|
|
|
Type type;
|
|
peg::any v;
|
|
};
|
|
|
|
struct Symbol {
|
|
Value val;
|
|
bool mut;
|
|
};
|
|
|
|
inline std::ostream& operator<<(std::ostream& os, const Value& val)
|
|
{
|
|
return val.out(os);
|
|
}
|
|
|
|
struct Environment
|
|
{
|
|
Environment(std::shared_ptr<Environment> parent = nullptr)
|
|
: level(parent ? parent->level + 1 : 0) {
|
|
}
|
|
|
|
void append_outer(std::shared_ptr<Environment> outer) {
|
|
if (this->outer) {
|
|
this->outer->append_outer(outer);
|
|
} else {
|
|
this->outer = outer;
|
|
}
|
|
}
|
|
|
|
bool has(const std::string& s) const {
|
|
if (dictionary.find(s) != dictionary.end()) {
|
|
return true;
|
|
}
|
|
return outer && outer->has(s);
|
|
}
|
|
|
|
const Value& get(const std::string& s) const {
|
|
if (dictionary.find(s) != dictionary.end()) {
|
|
return dictionary.at(s).val;
|
|
} else if (outer) {
|
|
return outer->get(s);
|
|
}
|
|
std::string msg = "undefined variable '" + s + "'...";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
|
|
void assign(const std::string& s, const Value& val) {
|
|
assert(has(s));
|
|
if (dictionary.find(s) != dictionary.end()) {
|
|
auto& sym = dictionary[s];
|
|
if (!sym.mut) {
|
|
std::string msg = "immutable variable '" + s + "'...";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
sym.val = val;
|
|
return;
|
|
}
|
|
outer->assign(s, val);
|
|
return;
|
|
}
|
|
|
|
void initialize(const std::string& s, const Value& val, bool mut) {
|
|
dictionary[s] = Symbol{ val, mut };
|
|
}
|
|
|
|
void initialize(const std::string& s, Value&& val, bool mut) {
|
|
dictionary[s] = Symbol{ std::move(val), mut };
|
|
}
|
|
|
|
size_t level;
|
|
std::shared_ptr<Environment> outer;
|
|
std::map<std::string, Symbol> dictionary;
|
|
};
|
|
|
|
typedef std::function<void (const peg::Ast& ast, Environment& env, bool force_to_break)> Debugger;
|
|
|
|
inline bool ObjectValue::has(const std::string& name) const {
|
|
if (properties->find(name) == properties->end()) {
|
|
const auto& props = const_cast<ObjectValue*>(this)->builtins();
|
|
return props.find(name) != props.end();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline const Value& ObjectValue::get(const std::string& name) const {
|
|
if (properties->find(name) == properties->end()) {
|
|
const auto& props = const_cast<ObjectValue*>(this)->builtins();
|
|
return props.at(name);
|
|
}
|
|
return properties->at(name).val;
|
|
}
|
|
|
|
inline void ObjectValue::assign(const std::string& name, const Value& val) {
|
|
assert(has(name));
|
|
auto& sym = properties->at(name);
|
|
if (!sym.mut) {
|
|
std::string msg = "immutable property '" + name + "'...";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
sym.val = val;
|
|
return;
|
|
}
|
|
|
|
inline void ObjectValue::initialize(const std::string& name, const Value& val, bool mut) {
|
|
(*properties)[name] = Symbol{ val, mut };
|
|
}
|
|
|
|
inline std::map<std::string, Value>& ObjectValue::builtins() {
|
|
static std::map<std::string, Value> props_ = {
|
|
{
|
|
"size",
|
|
Value(FunctionValue(
|
|
{},
|
|
[](std::shared_ptr<Environment> callEnv) {
|
|
const auto& val = callEnv->get("this");
|
|
long n = val.to_object().properties->size();
|
|
return Value(n);
|
|
}
|
|
))
|
|
}
|
|
};
|
|
return props_;
|
|
}
|
|
|
|
inline std::map<std::string, Value>& ArrayValue::builtins() {
|
|
static std::map<std::string, Value> props_ = {
|
|
{
|
|
"size",
|
|
Value(FunctionValue(
|
|
{},
|
|
[](std::shared_ptr<Environment> callEnv) {
|
|
const auto& val = callEnv->get("this");
|
|
long n = val.to_array().values->size();
|
|
return Value(n);
|
|
}
|
|
))
|
|
},
|
|
{
|
|
"push",
|
|
Value(FunctionValue {
|
|
{ {"arg", false} },
|
|
[](std::shared_ptr<Environment> callEnv) {
|
|
const auto& val = callEnv->get("this");
|
|
const auto& arg = callEnv->get("arg");
|
|
val.to_array().values->push_back(arg);
|
|
return Value();
|
|
}
|
|
})
|
|
}
|
|
};
|
|
return props_;
|
|
}
|
|
|
|
inline std::string Value::str_object() const {
|
|
const auto& properties = *to_object().properties;
|
|
std::string s = "{";
|
|
auto it = properties.begin();
|
|
for (; it != properties.end(); ++it) {
|
|
if (it != properties.begin()) {
|
|
s += ", ";
|
|
}
|
|
const auto& name = it->first;
|
|
const auto& sym = it->second;
|
|
if (sym.mut) {
|
|
s += "mut ";
|
|
}
|
|
s += name;
|
|
s += ": ";
|
|
s += sym.val.str();
|
|
}
|
|
s += "}";
|
|
return s;
|
|
}
|
|
|
|
inline void setup_built_in_functions(Environment& env) {
|
|
env.initialize(
|
|
"puts",
|
|
Value(FunctionValue(
|
|
{ {"arg", true} },
|
|
[](std::shared_ptr<Environment> env) {
|
|
std::cout << env->get("arg").str() << std::endl;
|
|
return Value();
|
|
}
|
|
)),
|
|
false);
|
|
|
|
env.initialize(
|
|
"assert",
|
|
Value(FunctionValue(
|
|
{ {"arg", true} },
|
|
[](std::shared_ptr<Environment> env) {
|
|
auto cond = env->get("arg").to_bool();
|
|
if (!cond) {
|
|
auto line = env->get("__LINE__").to_long();
|
|
auto column = env->get("__COLUMN__").to_long();
|
|
std::string msg = "assert failed at " + std::to_string(line) + ":" + std::to_string(column) + ".";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
return Value();
|
|
}
|
|
)),
|
|
false);
|
|
}
|
|
|
|
struct Interpreter
|
|
{
|
|
Interpreter(Debugger debugger = nullptr)
|
|
: debugger_(debugger) {
|
|
}
|
|
|
|
Value eval(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
using peg::operator"" _;
|
|
|
|
if (debugger_) {
|
|
if (ast.original_tag == "STATEMENT"_) {
|
|
auto force_to_break = ast.tag == "DEBUGGER"_;
|
|
debugger_(ast, *env, force_to_break);
|
|
}
|
|
}
|
|
|
|
switch (ast.tag) {
|
|
case "STATEMENTS"_: return eval_statements(ast, env);
|
|
case "WHILE"_: return eval_while(ast, env);
|
|
case "IF"_: return eval_if(ast, env);
|
|
case "FUNCTION"_: return eval_function(ast, env);
|
|
case "CALL"_: return eval_call(ast, env);
|
|
case "LEXICAL_SCOPE"_: return eval_lexical_scope(ast, env);
|
|
case "ASSIGNMENT"_: return eval_assignment(ast, env);
|
|
case "LOGICAL_OR"_: return eval_logical_or(ast, env);
|
|
case "LOGICAL_AND"_: return eval_logical_and(ast, env);
|
|
case "CONDITION"_: return eval_condition(ast, env);
|
|
case "UNARY_PLUS"_: return eval_unary_plus(ast, env);
|
|
case "UNARY_MINUS"_: return eval_unary_minus(ast, env);
|
|
case "UNARY_NOT"_: return eval_unary_not(ast, env);
|
|
case "ADDITIVE"_:
|
|
case "MULTIPLICATIVE"_: return eval_bin_expression(ast, env);
|
|
case "IDENTIFIER"_: return eval_identifier(ast, env);
|
|
case "OBJECT"_: return eval_object(ast, env);
|
|
case "ARRAY"_: return eval_array(ast, env);
|
|
case "NIL"_: return eval_nil(ast, env);
|
|
case "BOOLEAN"_: return eval_bool(ast, env);
|
|
case "NUMBER"_: return eval_number(ast, env);
|
|
case "INTERPOLATED_STRING"_: return eval_interpolated_string(ast, env);
|
|
case "DEBUGGER"_: return Value();
|
|
case "RETURN"_: eval_return(ast, env);
|
|
}
|
|
|
|
if (ast.is_token) {
|
|
return Value(std::string(ast.token));
|
|
}
|
|
|
|
// NOTREACHED
|
|
throw std::logic_error("invalid Ast type");
|
|
}
|
|
|
|
private:
|
|
Value eval_statements(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
if (ast.is_token) {
|
|
return eval(ast, env);
|
|
} else if (ast.nodes.empty()) {
|
|
return Value();
|
|
}
|
|
auto it = ast.nodes.begin();
|
|
while (it != ast.nodes.end() - 1) {
|
|
eval(**it, env);
|
|
++it;
|
|
}
|
|
return eval(**it, env);
|
|
}
|
|
|
|
Value eval_while(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
for (;;) {
|
|
auto cond = eval(*ast.nodes[0], env);
|
|
if (!cond.to_bool()) {
|
|
break;
|
|
}
|
|
eval(*ast.nodes[1], env);
|
|
}
|
|
return Value();
|
|
}
|
|
|
|
Value eval_if(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
const auto& nodes = ast.nodes;
|
|
|
|
for (auto i = 0u; i < nodes.size(); i += 2) {
|
|
if (i + 1 == nodes.size()) {
|
|
return eval(*nodes[i], env);
|
|
} else {
|
|
auto cond = eval(*nodes[i], env);
|
|
if (cond.to_bool()) {
|
|
return eval(*nodes[i + 1], env);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Value();
|
|
}
|
|
|
|
Value eval_function(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
std::vector<FunctionValue::Parameter> params;
|
|
for (auto node: ast.nodes[0]->nodes) {
|
|
auto mut = node->nodes[0]->token == "mut";
|
|
const auto& name = node->nodes[1]->token;
|
|
params.push_back({ name, mut });
|
|
}
|
|
|
|
auto body = ast.nodes[1];
|
|
|
|
return Value(FunctionValue(
|
|
params,
|
|
[=](std::shared_ptr<Environment> callEnv) {
|
|
callEnv->append_outer(env);
|
|
return eval(*body, callEnv);
|
|
}
|
|
));
|
|
};
|
|
|
|
Value eval_function_call(const peg::Ast& ast, std::shared_ptr<Environment> env, const Value& val) {
|
|
const auto& f = val.to_function();
|
|
const auto& params = *f.params;
|
|
const auto& args = ast.nodes;
|
|
|
|
if (params.size() <= args.size()) {
|
|
auto callEnv = std::make_shared<Environment>(env);
|
|
callEnv->initialize("self", val, false);
|
|
for (auto iprm = 0u; iprm < params.size(); iprm++) {
|
|
auto param = params[iprm];
|
|
auto arg = args[iprm];
|
|
auto val = eval(*arg, env);
|
|
callEnv->initialize(param.name, val, param.mut);
|
|
}
|
|
callEnv->initialize("__LINE__", Value((long)ast.line), false);
|
|
callEnv->initialize("__COLUMN__", Value((long)ast.column), false);
|
|
try {
|
|
return f.eval(callEnv);
|
|
} catch (const Value& e) {
|
|
return e;
|
|
}
|
|
}
|
|
|
|
std::string msg = "arguments error...";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
|
|
Value eval_array_reference(const peg::Ast& ast, std::shared_ptr<Environment> env, const Value& val) {
|
|
const auto& arr = val.to_array();
|
|
auto idx = eval(ast, env).to_long();
|
|
if (idx < 0) {
|
|
idx = arr.values->size() + idx;
|
|
}
|
|
if (0 <= idx && idx < static_cast<long>(arr.values->size())) {
|
|
return arr.values->at(idx);
|
|
} else {
|
|
throw std::logic_error("index out of range.");
|
|
}
|
|
return val;
|
|
}
|
|
|
|
Value eval_property(const peg::Ast& ast, std::shared_ptr<Environment> env, const Value& val) {
|
|
const auto& obj = val.to_object();
|
|
auto name = ast.token;
|
|
if (!obj.has(name)) {
|
|
return Value();
|
|
}
|
|
const auto& prop = obj.get(name);
|
|
if (prop.type == Value::Function) {
|
|
const auto& pf = prop.to_function();
|
|
return Value(FunctionValue(
|
|
*pf.params,
|
|
[=](std::shared_ptr<Environment> callEnv) {
|
|
callEnv->initialize("this", val, false);
|
|
return pf.eval(callEnv);
|
|
}
|
|
));
|
|
}
|
|
return prop;
|
|
}
|
|
|
|
Value eval_call(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
using peg::operator"" _;
|
|
|
|
Value val = eval(*ast.nodes[0], env);
|
|
|
|
for (auto i = 1u; i < ast.nodes.size(); i++) {
|
|
const auto& postfix = *ast.nodes[i];
|
|
|
|
switch (postfix.original_tag) {
|
|
case "ARGUMENTS"_: val = eval_function_call(postfix, env, val); break;
|
|
case "INDEX"_: val = eval_array_reference(postfix, env, val); break;
|
|
case "DOT"_: val = eval_property(postfix, env, val); break;
|
|
default: throw std::logic_error("invalid internal condition.");
|
|
}
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
Value eval_lexical_scope(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
auto scopeEnv = std::make_shared<Environment>();
|
|
scopeEnv->append_outer(env);
|
|
for (auto node: ast.nodes) {
|
|
eval(*node, scopeEnv);
|
|
}
|
|
return Value();
|
|
}
|
|
|
|
Value eval_logical_or(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
assert(ast.nodes.size() > 1); // if the size is 1, thes node will be hoisted.
|
|
Value val;
|
|
for (auto node: ast.nodes) {
|
|
val = eval(*node, env);
|
|
if (val.to_bool()) {
|
|
return val;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
Value eval_logical_and(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
Value val;
|
|
for (auto node: ast.nodes) {
|
|
val = eval(*node, env);
|
|
if (!val.to_bool()) {
|
|
return val;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
Value eval_condition(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
auto lhs = eval(*ast.nodes[0], env);
|
|
auto ope = eval(*ast.nodes[1], env).to_string();
|
|
auto rhs = eval(*ast.nodes[2], env);
|
|
|
|
if (ope == "==") { return Value(lhs == rhs); }
|
|
else if (ope == "!=") { return Value(lhs != rhs); }
|
|
else if (ope == "<=") { return Value(lhs <= rhs); }
|
|
else if (ope == "<") { return Value(lhs < rhs); }
|
|
else if (ope == ">=") { return Value(lhs >= rhs); }
|
|
else if (ope == ">") { return Value(lhs > rhs); }
|
|
else { throw std::logic_error("invalid internal condition."); }
|
|
}
|
|
|
|
Value eval_unary_plus(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
return eval(*ast.nodes[1], env);
|
|
}
|
|
|
|
Value eval_unary_minus(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
return Value(eval(*ast.nodes[1], env).to_long() * -1);
|
|
}
|
|
|
|
Value eval_unary_not(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
return Value(!eval(*ast.nodes[1], env).to_bool());
|
|
}
|
|
|
|
Value eval_bin_expression(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
auto ret = eval(*ast.nodes[0], env).to_long();
|
|
for (auto i = 1u; i < ast.nodes.size(); i += 2) {
|
|
auto val = eval(*ast.nodes[i + 1], env).to_long();
|
|
auto ope = eval(*ast.nodes[i], env).to_string()[0];
|
|
switch (ope) {
|
|
case '+': ret += val; break;
|
|
case '-': ret -= val; break;
|
|
case '*': ret *= val; break;
|
|
case '%': ret %= val; break;
|
|
case '/':
|
|
if (val == 0) {
|
|
throw std::runtime_error("divide by 0 error");
|
|
}
|
|
ret /= val;
|
|
break;
|
|
}
|
|
}
|
|
return Value(ret);
|
|
}
|
|
|
|
bool is_keyword(const std::string& ident) const {
|
|
static std::set<std::string> keywords = { "nil", "true", "false", "mut", "debugger", "return", "while", "if", "else", "fn" };
|
|
return keywords.find(ident) != keywords.end();
|
|
}
|
|
|
|
Value eval_assignment(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
auto lvaloff = 2;
|
|
auto lvalcnt = ast.nodes.size() - 3;
|
|
|
|
auto let = ast.nodes[0]->token == "let";
|
|
auto mut = ast.nodes[1]->token == "mut";
|
|
auto rval = eval(*ast.nodes.back(), env);
|
|
|
|
if (lvalcnt == 1) {
|
|
const auto& ident = ast.nodes[lvaloff]->token;
|
|
if (!let && env->has(ident)) {
|
|
env->assign(ident, rval);
|
|
} else if (is_keyword(ident)) {
|
|
throw std::runtime_error("left-hand side is invalid variable name.");
|
|
} else {
|
|
env->initialize(ident, rval, mut);
|
|
}
|
|
return rval;
|
|
} else {
|
|
using peg::operator"" _;
|
|
|
|
Value lval = eval(*ast.nodes[lvaloff], env);
|
|
|
|
auto end = lvaloff + lvalcnt - 1;
|
|
for (auto i = lvaloff + 1; i < end; i++) {
|
|
const auto& postfix = *ast.nodes[i];
|
|
|
|
switch (postfix.original_tag) {
|
|
case "ARGUMENTS"_: lval = eval_function_call(postfix, env, lval); break;
|
|
case "INDEX"_: lval = eval_array_reference(postfix, env, lval); break;
|
|
case "DOT"_: lval = eval_property(postfix, env, lval); break;
|
|
default: throw std::logic_error("invalid internal condition.");
|
|
}
|
|
}
|
|
|
|
const auto& postfix = *ast.nodes[end];
|
|
|
|
switch (postfix.original_tag) {
|
|
case "INDEX"_: {
|
|
const auto& arr = lval.to_array();
|
|
auto idx = eval(postfix, env).to_long();
|
|
if (0 <= idx && idx < static_cast<long>(arr.values->size())) {
|
|
arr.values->at(idx) = rval;
|
|
} else {
|
|
throw std::logic_error("index out of range.");
|
|
}
|
|
return rval;
|
|
}
|
|
case "DOT"_: {
|
|
auto& obj = lval.to_object();
|
|
auto name = postfix.token;
|
|
if (obj.has(name)) {
|
|
obj.assign(name, rval);
|
|
} else {
|
|
obj.initialize(name, rval, mut);
|
|
}
|
|
return rval;
|
|
}
|
|
default:
|
|
throw std::logic_error("invalid internal condition.");
|
|
}
|
|
}
|
|
};
|
|
|
|
Value eval_identifier(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
return env->get(ast.token);
|
|
};
|
|
|
|
Value eval_object(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
ObjectValue obj;
|
|
for (auto i = 0u; i < ast.nodes.size(); i++) {
|
|
const auto& prop = *ast.nodes[i];
|
|
auto mut = prop.nodes[0]->token == "mut";
|
|
const auto& name = prop.nodes[1]->token;
|
|
auto val = eval(*prop.nodes[2], env);
|
|
obj.properties->emplace(name, Symbol{ std::move(val), mut });
|
|
}
|
|
return Value(std::move(obj));
|
|
}
|
|
|
|
Value eval_array(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
ArrayValue arr;
|
|
|
|
if (ast.nodes.size() >= 2) {
|
|
auto count = eval(*ast.nodes[1], env).to_long();
|
|
if (ast.nodes.size() == 3) {
|
|
auto val = eval(*ast.nodes[2], env);
|
|
arr.values->resize(count, std::move(val));
|
|
} else {
|
|
arr.values->resize(count);
|
|
}
|
|
}
|
|
|
|
const auto& nodes = ast.nodes[0]->nodes;
|
|
for (auto i = 0u; i < nodes.size(); i++) {
|
|
auto expr = nodes[i];
|
|
auto val = eval(*expr, env);
|
|
if (i < arr.values->size()) {
|
|
arr.values->at(i) = std::move(val);
|
|
} else {
|
|
arr.values->push_back(std::move(val));
|
|
}
|
|
}
|
|
|
|
return Value(std::move(arr));
|
|
}
|
|
|
|
Value eval_nil(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
return Value();
|
|
};
|
|
|
|
Value eval_bool(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
return Value(ast.token == "true");
|
|
};
|
|
|
|
Value eval_number(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
return Value(stol(ast.token));
|
|
};
|
|
|
|
Value eval_interpolated_string(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
std::string s;
|
|
for (auto node: ast.nodes) {
|
|
const auto& val = eval(*node, env);
|
|
if (val.type == Value::String) {
|
|
s += val.to_string();
|
|
} else {
|
|
s += val.str();
|
|
}
|
|
}
|
|
return Value(std::move(s));
|
|
};
|
|
|
|
void eval_return(const peg::Ast& ast, std::shared_ptr<Environment> env) {
|
|
if (ast.nodes.empty()) {
|
|
throw Value();
|
|
} else {
|
|
throw eval(*ast.nodes[0], env);
|
|
}
|
|
}
|
|
|
|
Debugger debugger_;
|
|
};
|
|
|
|
inline std::shared_ptr<peg::Ast> parse(
|
|
const std::string& path,
|
|
const char* expr,
|
|
size_t len,
|
|
std::vector<std::string>& msgs)
|
|
{
|
|
auto& parser = get_parser();
|
|
|
|
parser.log = [&](size_t ln, size_t col, const std::string& err_msg) {
|
|
std::stringstream ss;
|
|
ss << path << ":" << ln << ":" << col << ": " << err_msg << std::endl;
|
|
msgs.push_back(ss.str());
|
|
};
|
|
|
|
std::shared_ptr<peg::Ast> ast;
|
|
if (parser.parse_n(expr, len, ast, path.c_str())) {
|
|
return peg::AstOptimizer(true, { "PARAMETERS", "SEQUENCE", "OBJECT", "ARRAY", "RETURN", "LEXICAL_SCOPE" }).optimize(ast);
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
inline bool interpret(
|
|
const std::shared_ptr<peg::Ast>& ast,
|
|
std::shared_ptr<Environment> env,
|
|
Value& val,
|
|
std::vector<std::string>& msgs,
|
|
Debugger debugger = nullptr)
|
|
{
|
|
try {
|
|
val = Interpreter(debugger).eval(*ast, env);
|
|
return true;
|
|
} catch (const Value& e) {
|
|
val = e;
|
|
return true;
|
|
} catch (std::runtime_error& e) {
|
|
msgs.push_back(e.what());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
} // namespace culebra
|
|
|