AIR/cpp-peglib
1
0
Fork 0
mirror of https://github.com/yhirose/cpp-peglib.git synced 2024-12-22 20:05:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Made header-only file.

Browse Source
This commit is contained in:
yhirose 2015-07-24 22:18:03 -04:00
parent c0857d19ec
commit 620c775eee
11 changed files with 468 additions and 627 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
language/CMakeLists.txt
View File

@ -2,4 +2,4 @@ cmake_minimum_required(VERSION 3.0)
include_directories(..) include_directories(..)
add_definitions("-std=c++1y" -DPEGLIB_HAS_CONSTEXPR_SUPPORT) add_definitions("-std=c++1y" -DPEGLIB_HAS_CONSTEXPR_SUPPORT)
add_executable(culebra main.cc repl.cc interpreter.cc parser.cc) add_executable(culebra main.cc)

361
language/interpreter.cc
View File

@ -1,361 +0,0 @@
#include "interpreter.hpp"
#include "parser.hpp"
#include <sstream>
using namespace peglib;
using namespace std;
struct Eval
{
static Value eval(const Ast& ast, shared_ptr<Environment> env) {
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 "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 "NUMBER"_: return eval_number(ast, env);
case "BOOLEAN"_: return eval_bool(ast, env);
case "INTERPOLATED_STRING"_: return eval_interpolated_string(ast, env);
}
if (ast.is_token) {
return Value(string(ast.token));
}
// NOTREACHED
throw logic_error("invalid Ast type");
}
private:
static Value eval_statements(const Ast& ast, 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);
}
static Value eval_while(const Ast& ast, shared_ptr<Environment> env) {
for (;;) {
auto cond = eval(*ast.nodes[0], env);
if (!cond.to_bool()) {
break;
}
eval(*ast.nodes[1], env);
}
return Value();
}
static Value eval_if(const Ast& ast, 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();
}
static Value eval_function(const Ast& ast, 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];
auto f = FunctionValue(
params,
[=](shared_ptr<Environment> callEnv) {
callEnv->append_outer(env);
return eval(*body, callEnv);
}
);
return Value(std::move(f));
};
static Value eval_call(const Ast& ast, shared_ptr<Environment> env) {
Value val = eval(*ast.nodes[0], env);
for (auto i = 1u; i < ast.nodes.size(); i++) {
const auto& n = *ast.nodes[i];
if (n.original_tag == "ARGUMENTS"_) {
// Function call
const auto& f = val.to_function();
const auto& params = f.data->params;
const auto& args = n.nodes;
if (params.size() <= args.size()) {
auto callEnv = make_shared<Environment>();
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);
val = f.data->eval(callEnv);
} else {
string msg = "arguments error...";
throw runtime_error(msg);
}
} else if (n.original_tag == "INDEX"_) {
// Array reference
const auto& arr = val.to_array();
auto idx = eval(n, env).to_long();
if (0 <= idx && idx < static_cast<long>(arr.values->size())) {
val = arr.values->at(idx);
}
} else if (n.original_tag == "DOT"_) {
// Property
auto name = n.token;
auto prop = val.get_property(name);
if (prop.get_type() == Value::Function) {
const auto& pf = prop.to_function();
auto f = FunctionValue(
pf.data->params,
[=](shared_ptr<Environment> callEnv) {
callEnv->initialize("this", val, false);
if (val.get_type() == Value::Object) {
callEnv->set_object(val.to_object());
}
return pf.data->eval(callEnv);
}
);
val = Value(std::move(f));
} else {
val = prop;
}
} else {
throw std::logic_error("invalid internal condition.");
}
}
return val;
}
static Value eval_logical_or(const Ast& ast, shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
Value ret;
for (auto node: ast.nodes) {
ret = eval(*node, env);
if (ret.to_bool()) {
return ret;
}
}
return ret;
}
}
static Value eval_logical_and(const Ast& ast, shared_ptr<Environment> env) {
Value ret;
for (auto node: ast.nodes) {
ret = eval(*node, env);
if (!ret.to_bool()) {
return ret;
}
}
return ret;
}
static Value eval_condition(const Ast& ast, shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
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.");
}
}
}
static Value eval_unary_plus(const Ast& ast, shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
return eval(*ast.nodes[1], env);
}
}
static Value eval_unary_minus(const Ast& ast, shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
return Value(eval(*ast.nodes[1], env).to_long() * -1);
}
}
static Value eval_unary_not(const Ast& ast, shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
return Value(!eval(*ast.nodes[1], env).to_bool());
}
}
static Value eval_bin_expression(const Ast& ast, 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 '%': ret %= val; break;
}
}
return Value(ret);
}
static Value eval_assignment(const Ast& ast, shared_ptr<Environment> env) {
const auto& mut = ast.nodes[0]->token;
const auto& var = ast.nodes[1]->token;
auto val = eval(*ast.nodes[2], env);
if (env->has(var)) {
env->assign(var, val);
} else {
env->initialize(var, val, mut == "mut");
}
return val;
};
static Value eval_identifier(const Ast& ast, shared_ptr<Environment> env) {
const auto& var = ast.token;
return env->get(var);
};
static Value eval_object(const Ast& ast, shared_ptr<Environment> env) {
ObjectValue obj;
for (auto i = 0u; i < ast.nodes.size(); i++) {
const auto& prop = *ast.nodes[i];
const auto& name = prop.nodes[0]->token;
auto val = eval(*prop.nodes[1], env);
obj.properties->emplace(name, val);
}
return Value(std::move(obj));
}
static Value eval_array(const Ast& ast, shared_ptr<Environment> env) {
ArrayValue arr;
for (auto i = 0u; i < ast.nodes.size(); i++) {
auto expr = ast.nodes[i];
auto val = eval(*expr, env);
arr.values->push_back(val);
}
return Value(std::move(arr));
}
static Value eval_number(const Ast& ast, shared_ptr<Environment> env) {
return Value(stol(ast.token));
};
static Value eval_bool(const Ast& ast, shared_ptr<Environment> env) {
return Value(ast.token == "true");
};
static Value eval_interpolated_string(const Ast& ast, shared_ptr<Environment> env) {
string s;
for (auto node: ast.nodes) {
const auto& val = eval(*node, env);
s += val.str();
}
return Value(std::move(s));
};
};
bool run(
const string& path,
shared_ptr<Environment> env,
const char* expr,
size_t len,
Value& val,
string& msg,
bool print_ast)
{
try {
shared_ptr<Ast> ast;
auto& parser = get_parser();
parser.log = [&](size_t ln, size_t col, const string& err_msg) {
stringstream ss;
ss << path << ":" << ln << ":" << col << ": " << err_msg << endl;
msg = ss.str();
};
if (parser.parse_n(expr, len, ast)) {
if (print_ast) {
ast->print();
}
val = Eval::eval(*ast, env);
return true;
}
} catch (runtime_error& e) {
msg = e.what();
}
return false;
}
// vim: et ts=4 sw=4 cin cino={1s ff=unix

443
language/interpreter.hpp
View File

@ -1,4 +1,5 @@
#include <map> #include <map>
#include <sstream>
#include <string> #include <string>
#include <peglib.h> #include <peglib.h>
@ -443,11 +444,449 @@ inline void setup_built_in_functions(Environment& env) {
} }
} }
bool run( struct Eval
{
static Value eval(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
using peglib::operator"" _;
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 "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 "NUMBER"_: return eval_number(ast, env);
case "BOOLEAN"_: return eval_bool(ast, env);
case "INTERPOLATED_STRING"_: return eval_interpolated_string(ast, env);
}
if (ast.is_token) {
return Value(std::string(ast.token));
}
// NOTREACHED
throw std::logic_error("invalid Ast type");
}
private:
static Value eval_statements(const peglib::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);
}
static Value eval_while(const peglib::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();
}
static Value eval_if(const peglib::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();
}
static Value eval_function(const peglib::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];
auto f = FunctionValue(
params,
[=](std::shared_ptr<Environment> callEnv) {
callEnv->append_outer(env);
return eval(*body, callEnv);
}
);
return Value(std::move(f));
};
static Value eval_call(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
using peglib::operator"" _;
Value val = eval(*ast.nodes[0], env);
for (auto i = 1u; i < ast.nodes.size(); i++) {
const auto& n = *ast.nodes[i];
if (n.original_tag == "ARGUMENTS"_) {
// Function call
const auto& f = val.to_function();
const auto& params = f.data->params;
const auto& args = n.nodes;
if (params.size() <= args.size()) {
auto callEnv = std::make_shared<Environment>();
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);
val = f.data->eval(callEnv);
} else {
std::string msg = "arguments error...";
throw std::runtime_error(msg);
}
} else if (n.original_tag == "INDEX"_) {
// Array reference
const auto& arr = val.to_array();
auto idx = eval(n, env).to_long();
if (0 <= idx && idx < static_cast<long>(arr.values->size())) {
val = arr.values->at(idx);
}
} else if (n.original_tag == "DOT"_) {
// Property
auto name = n.token;
auto prop = val.get_property(name);
if (prop.get_type() == Value::Function) {
const auto& pf = prop.to_function();
auto f = FunctionValue(
pf.data->params,
[=](std::shared_ptr<Environment> callEnv) {
callEnv->initialize("this", val, false);
if (val.get_type() == Value::Object) {
callEnv->set_object(val.to_object());
}
return pf.data->eval(callEnv);
}
);
val = Value(std::move(f));
} else {
val = prop;
}
} else {
throw std::logic_error("invalid internal condition.");
}
}
return val;
}
static Value eval_logical_or(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
Value ret;
for (auto node: ast.nodes) {
ret = eval(*node, env);
if (ret.to_bool()) {
return ret;
}
}
return ret;
}
}
static Value eval_logical_and(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
Value ret;
for (auto node: ast.nodes) {
ret = eval(*node, env);
if (!ret.to_bool()) {
return ret;
}
}
return ret;
}
static Value eval_condition(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
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.");
}
}
}
static Value eval_unary_plus(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
return eval(*ast.nodes[1], env);
}
}
static Value eval_unary_minus(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
return Value(eval(*ast.nodes[1], env).to_long() * -1);
}
}
static Value eval_unary_not(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
if (ast.nodes.size() == 1) {
return eval(*ast.nodes[0], env);
} else {
return Value(!eval(*ast.nodes[1], env).to_bool());
}
}
static Value eval_bin_expression(const peglib::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 '%': ret %= val; break;
}
}
return Value(ret);
}
static Value eval_assignment(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
const auto& mut = ast.nodes[0]->token;
const auto& var = ast.nodes[1]->token;
auto val = eval(*ast.nodes[2], env);
if (env->has(var)) {
env->assign(var, val);
} else {
env->initialize(var, val, mut == "mut");
}
return val;
};
static Value eval_identifier(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
const auto& var = ast.token;
return env->get(var);
};
static Value eval_object(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
ObjectValue obj;
for (auto i = 0u; i < ast.nodes.size(); i++) {
const auto& prop = *ast.nodes[i];
const auto& name = prop.nodes[0]->token;
auto val = eval(*prop.nodes[1], env);
obj.properties->emplace(name, val);
}
return Value(std::move(obj));
}
static Value eval_array(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
ArrayValue arr;
for (auto i = 0u; i < ast.nodes.size(); i++) {
auto expr = ast.nodes[i];
auto val = eval(*expr, env);
arr.values->push_back(val);
}
return Value(std::move(arr));
}
static Value eval_number(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
return Value(stol(ast.token));
};
static Value eval_bool(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
return Value(ast.token == "true");
};
static Value eval_interpolated_string(const peglib::Ast& ast, std::shared_ptr<Environment> env) {
std::string s;
for (auto node: ast.nodes) {
const auto& val = eval(*node, env);
s += val.str();
}
return Value(std::move(s));
};
};
inline peglib::peg& get_parser()
{
using namespace peglib;
using namespace std;
static auto grammar_ = R"(
PROGRAM <- _ STATEMENTS
STATEMENTS <- (EXPRESSION (';' _)?)*
EXPRESSION <- ASSIGNMENT / LOGICAL_OR
ASSIGNMENT <- MUTABLE IDENTIFIER '=' _ EXPRESSION
WHILE <- 'while' _ EXPRESSION BLOCK
IF <- 'if' _ EXPRESSION BLOCK ('else' _ 'if' _ EXPRESSION BLOCK)* ('else' _ BLOCK)?
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 <- '(' _ (EXPRESSION (',' _ EXPRESSION)*)? ')' _
INDEX <- '[' _ EXPRESSION ']' _
DOT <- '.' _ IDENTIFIER
PRIMARY <- WHILE / IF / FUNCTION / IDENTIFIER / OBJECT / ARRAY / NUMBER / BOOLEAN / 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 <- < [*/%] > _
IDENTIFIER <- < [a-zA-Z_][a-zA-Z0-9_]* > _
OBJECT <- '{' _ (OBJECT_PROPERTY (',' _ OBJECT_PROPERTY)*)? '}' _
OBJECT_PROPERTY <- IDENTIFIER ':' _ EXPRESSION
ARRAY <- '[' _ (EXPRESSION (',' _ EXPRESSION)*)? ']' _
NUMBER <- < [0-9]+ > _
BOOLEAN <- < ('true' / 'false') > _
STRING <- ['] < (!['] .)* > ['] _
INTERPOLATED_STRING <- '"' ('{' _ EXPRESSION '}' / INTERPOLATED_CONTENT)* '"' _
INTERPOLATED_CONTENT <- (!["{] .) (!["{] .)*
MUTABLE <- < 'mut'? > _
~_ <- (Space / EndOfLine / Comment)*
Space <- ' ' / '\t'
EndOfLine <- '\r\n' / '\n' / '\r'
EndOfFile <- !.
Comment <- '/*' (!'*/' .)* '*/' / ('#' / '//') (!(EndOfLine / EndOfFile) .)* (EndOfLine / EndOfFile)
)";
static peg parser;
static bool initialized = false;
if (!initialized) {
initialized = true;
parser.log = [&](size_t ln, size_t col, const string& msg) {
cerr << ln << ":" << col << ": " << msg << endl;
};
if (!parser.load_grammar(grammar_)) {
throw logic_error("invalid peg grammar");
}
parser.enable_ast(true, { "PARAMETERS", "ARGUMENTS" });
}
return parser;
}
inline bool run(
const std::string& path, const std::string& path,
std::shared_ptr<Environment> env, std::shared_ptr<Environment> env,
const char* expr, const char* expr,
size_t len, size_t len,
Value& val, Value& val,
std::string& msg, std::string& msg,
bool print_ast); bool print_ast)
{
try {
std::shared_ptr<peglib::Ast> ast;
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;
msg = ss.str();
};
if (parser.parse_n(expr, len, ast)) {
if (print_ast) {
ast->print();
}
val = Eval::eval(*ast, env);
return true;
}
} catch (std::runtime_error& e) {
msg = e.what();
}
return false;
}

27
language/main.cc
View File

@ -1,4 +1,5 @@
#include "repl.hpp" #include "interpreter.hpp"
#include "linenoise.hpp"
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
@ -22,6 +23,30 @@ bool read_file(const char* path, vector<char>& buff)
return true; return true;
} }
int repl(shared_ptr<Environment> env, bool print_ast)
{
for (;;) {
auto line = linenoise::Readline("cul> ");
if (line == "exit" || line == "quit") {
break;
}
if (!line.empty()) {
Value val;
string msg;
if (run("(repl)", env, line.c_str(), line.size(), val, msg, print_ast)) {
cout << val << endl;
linenoise::AddHistory(line.c_str());
} else if (!msg.empty()) {
cout << msg;
}
}
}
return 0;
}
int main(int argc, const char** argv) int main(int argc, const char** argv)
{ {
auto print_ast = false; auto print_ast = false;

92
language/parser.cc
View File

@ -1,92 +0,0 @@
#include "parser.hpp"
using namespace peglib;
using namespace std;
const auto g_grammar = R"(
PROGRAM <- _ STATEMENTS
STATEMENTS <- (EXPRESSION (';' _)?)*
EXPRESSION <- ASSIGNMENT / LOGICAL_OR
ASSIGNMENT <- MUTABLE IDENTIFIER '=' _ EXPRESSION
WHILE <- 'while' _ EXPRESSION BLOCK
IF <- 'if' _ EXPRESSION BLOCK ('else' _ 'if' _ EXPRESSION BLOCK)* ('else' _ BLOCK)?
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 <- '(' _ (EXPRESSION (',' _ EXPRESSION)*)? ')' _
INDEX <- '[' _ EXPRESSION ']' _
DOT <- '.' _ IDENTIFIER
PRIMARY <- WHILE / IF / FUNCTION / IDENTIFIER / OBJECT / ARRAY / NUMBER / BOOLEAN / 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 <- < [*/%] > _
IDENTIFIER <- < [a-zA-Z_][a-zA-Z0-9_]* > _
OBJECT <- '{' _ (OBJECT_PROPERTY (',' _ OBJECT_PROPERTY)*)? '}' _
OBJECT_PROPERTY <- IDENTIFIER ':' _ EXPRESSION
ARRAY <- '[' _ (EXPRESSION (',' _ EXPRESSION)*)? ']' _
NUMBER <- < [0-9]+ > _
BOOLEAN <- < ('true' / 'false') > _
STRING <- ['] < (!['] .)* > ['] _
INTERPOLATED_STRING <- '"' ('{' _ EXPRESSION '}' / INTERPOLATED_CONTENT)* '"' _
INTERPOLATED_CONTENT <- (!["{] .) (!["{] .)*
MUTABLE <- < 'mut'? > _
~_ <- (Space / EndOfLine / Comment)*
Space <- ' ' / '\t'
EndOfLine <- '\r\n' / '\n' / '\r'
EndOfFile <- !.
Comment <- '/*' (!'*/' .)* '*/' / ('#' / '//') (!(EndOfLine / EndOfFile) .)* (EndOfLine / EndOfFile)
)";
peg& get_parser()
{
static peg parser;
static bool initialized = false;
if (!initialized) {
initialized = true;
parser.log = [&](size_t ln, size_t col, const string& msg) {
cerr << ln << ":" << col << ": " << msg << endl;
};
if (!parser.load_grammar(g_grammar)) {
throw logic_error("invalid peg grammar");
}
parser.enable_ast(true, { "PARAMETERS", "ARGUMENTS" });
}
return parser;
}
// vim: et ts=4 sw=4 cin cino={1s ff=unix

5
language/parser.hpp
View File

@ -1,5 +0,0 @@
#include <peglib.h>
peglib::peg& get_parser();
// vim: et ts=4 sw=4 cin cino={1s ff=unix

31
language/repl.cc
View File

@ -1,31 +0,0 @@
#include "linenoise.hpp"
#include "repl.hpp"
#include <iostream>
using namespace std;
int repl(shared_ptr<Environment> env, bool print_ast)
{
for (;;) {
auto line = linenoise::Readline("cul> ");
if (line == "exit" || line == "quit") {
break;
}
if (!line.empty()) {
Value val;
string msg;
if (run("(repl)", env, line.c_str(), line.size(), val, msg, print_ast)) {
cout << val << endl;
linenoise::AddHistory(line.c_str());
} else if (!msg.empty()) {
cout << msg;
}
}
}
return 0;
}
// vim: et ts=4 sw=4 cin cino={1s ff=unix

5
language/repl.hpp
View File

@ -1,5 +0,0 @@
#include "interpreter.hpp"
int repl(std::shared_ptr<Environment> env, bool print_ast);
// vim: et ts=4 sw=4 cin cino={1s ff=unix

26
language/vc12/culebra.sln
View File

@ -1,26 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.31101.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "culebra", "culebra.vcxproj", "{F85B641A-7538-4809-8175-C528FF632CF6}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{F85B641A-7538-4809-8175-C528FF632CF6}.Debug|Win32.ActiveCfg = Debug|Win32
{F85B641A-7538-4809-8175-C528FF632CF6}.Debug|Win32.Build.0 = Debug|Win32
{F85B641A-7538-4809-8175-C528FF632CF6}.Release|Win32.ActiveCfg = Release|Win32
{F85B641A-7538-4809-8175-C528FF632CF6}.Release|Win32.Build.0 = Release|Win32
{1D09607B-E1C0-4D62-8AB4-9E2D2C2DC6E4}.Debug|Win32.ActiveCfg = Debug|Win32
{1D09607B-E1C0-4D62-8AB4-9E2D2C2DC6E4}.Debug|Win32.Build.0 = Debug|Win32
{1D09607B-E1C0-4D62-8AB4-9E2D2C2DC6E4}.Release|Win32.ActiveCfg = Release|Win32
{1D09607B-E1C0-4D62-8AB4-9E2D2C2DC6E4}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

98
language/vc12/culebra.vcxproj
View File

@ -1,98 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\peglib.h" />
<ClInclude Include="..\interpreter.hpp" />
<ClInclude Include="..\linenoise.hpp" />
<ClInclude Include="..\parser.hpp" />
<ClInclude Include="..\repl.hpp" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\interpreter.cc" />
<ClCompile Include="..\main.cc" />
<ClCompile Include="..\parser.cc" />
<ClCompile Include="..\repl.cc" />
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{F85B641A-7538-4809-8175-C528FF632CF6}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<ProjectName>culebra</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v120</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v120</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>../..</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>../..</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<AdditionalDependencies>Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

5
language/vc14/culebra.vcxproj
View File

@ -14,14 +14,9 @@
<ClInclude Include="..\..\peglib.h" /> <ClInclude Include="..\..\peglib.h" />
<ClInclude Include="..\interpreter.hpp" /> <ClInclude Include="..\interpreter.hpp" />
<ClInclude Include="..\linenoise.hpp" /> <ClInclude Include="..\linenoise.hpp" />
<ClInclude Include="..\parser.hpp" />
<ClInclude Include="..\repl.hpp" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="..\interpreter.cc" />
<ClCompile Include="..\main.cc" /> <ClCompile Include="..\main.cc" />
<ClCompile Include="..\parser.cc" />
<ClCompile Include="..\repl.cc" />
</ItemGroup> </ItemGroup>
<PropertyGroup Label="Globals"> <PropertyGroup Label="Globals">
<ProjectGuid>{F85B641A-7538-4809-8175-C528FF632CF6}</ProjectGuid> <ProjectGuid>{F85B641A-7538-4809-8175-C528FF632CF6}</ProjectGuid>