AIR/cpp-peglib
1
0
Fork 0
mirror of https://github.com/yhirose/cpp-peglib.git synced 2025-01-22 21:35:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Applied clang-format

Browse Source
This commit is contained in:
yhirose 2017-08-04 07:03:44 -04:00
parent bb0c7c4522
commit 7c24c30104
1 changed files with 413 additions and 332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
language/pl0/pl0.cc
View File

@ -58,7 +58,8 @@ auto grammar = R"(
/*
* Utilities
*/
string format_error_message(const string& path, size_t ln, size_t col, const string& msg) {
string format_error_message(const string& path, size_t ln, size_t col,
const string& msg) {
stringstream ss;
ss << path << ":" << ln << ":" << col << ": " << msg << endl;
return ss.str();
@ -69,8 +70,7 @@ string format_error_message(const string& path, size_t ln, size_t col, const str
*/
struct SymbolScope;
struct Annotation
{
struct Annotation {
shared_ptr<SymbolScope> scope;
};
@ -79,8 +79,7 @@ typedef AstBase<Annotation> AstPL0;
/*
* Symbol Table
*/
struct SymbolScope
{
struct SymbolScope {
SymbolScope(shared_ptr<SymbolScope> outer) : outer(outer) {}
bool has_symbol(const string& ident) const {
@ -89,15 +88,18 @@ struct SymbolScope
}
bool has_constant(const string& ident) const {
return constants.count(ident) ? true : (outer ? outer->has_constant(ident) : false);
return constants.count(ident) ? true : (outer ? outer->has_constant(ident)
: false);
}
bool has_variable(const string& ident) const {
return variables.count(ident) ? true : (outer ? outer->has_variable(ident) : false);
return variables.count(ident) ? true : (outer ? outer->has_variable(ident)
: false);
}
bool has_procedure(const string& ident) const {
return procedures.count(ident) ? true : (outer ? outer->has_procedure(ident) : false);
return procedures.count(ident) ? true : (outer ? outer->has_procedure(ident)
: false);
}
map<string, int> constants;
@ -109,23 +111,37 @@ private:
};
void throw_runtime_error(const shared_ptr<AstPL0> node, const string& msg) {
throw runtime_error(format_error_message(node->path, node->line, node->column, msg));
throw runtime_error(
format_error_message(node->path, node->line, node->column, msg));
}
struct SymbolTable
{
static void build_on_ast(const shared_ptr<AstPL0> ast, shared_ptr<SymbolScope> scope = nullptr) {
struct SymbolTable {
static void build_on_ast(const shared_ptr<AstPL0> ast,
shared_ptr<SymbolScope> scope = nullptr) {
switch (ast->tag) {
case "block"_: block(ast, scope); break;
case "assignment"_: assignment(ast, scope); break;
case "call"_: call(ast, scope); break;
case "ident"_: ident(ast, scope); break;
default: for (auto node: ast->nodes) { build_on_ast(node, scope); } break;
case "block"_:
block(ast, scope);
break;
case "assignment"_:
assignment(ast, scope);
break;
case "call"_:
call(ast, scope);
break;
case "ident"_:
ident(ast, scope);
break;
default:
for (auto node : ast->nodes) {
build_on_ast(node, scope);
}
break;
}
}
private:
static void block(const shared_ptr<AstPL0> ast, shared_ptr<SymbolScope> outer) {
static void block(const shared_ptr<AstPL0> ast,
shared_ptr<SymbolScope> outer) {
// block <- const var procedure statement
auto scope = make_shared<SymbolScope>(outer);
const auto& nodes = ast->nodes;
@ -136,7 +152,8 @@ private:
ast->scope = scope;
}
static void constants(const shared_ptr<AstPL0> ast, shared_ptr<SymbolScope> scope) {
static void constants(const shared_ptr<AstPL0> ast,
shared_ptr<SymbolScope> scope) {
// const <- ('CONST' __ ident '=' _ number(',' _ ident '=' _ number)* ';' _) ?
const auto& nodes = ast->nodes;
for (auto i = 0u; i < nodes.size(); i += 2) {
@ -149,7 +166,8 @@ private:
}
}
static void variables(const shared_ptr<AstPL0> ast, shared_ptr<SymbolScope> scope) {
static void variables(const shared_ptr<AstPL0> ast,
shared_ptr<SymbolScope> scope) {
// var <- ('VAR' __ ident(',' _ ident)* ';' _) ?
const auto& nodes = ast->nodes;
for (auto i = 0u; i < nodes.size(); i += 1) {
@ -161,7 +179,8 @@ private:
}
}
static void procedures(const shared_ptr<AstPL0> ast, shared_ptr<SymbolScope> scope) {
static void procedures(const shared_ptr<AstPL0> ast,
shared_ptr<SymbolScope> scope) {
// procedure <- ('PROCEDURE' __ ident ';' _ block ';' _)*
const auto& nodes = ast->nodes;
for (auto i = 0u; i < nodes.size(); i += 2) {
@ -172,25 +191,31 @@ private:
}
}
static void assignment(const shared_ptr<AstPL0> ast, shared_ptr<SymbolScope> scope) {
static void assignment(const shared_ptr<AstPL0> ast,
shared_ptr<SymbolScope> scope) {
// assignment <- ident ':=' _ expression
const auto& ident = ast->nodes[0]->token;
if (scope->has_constant(ident)) {
throw_runtime_error(ast->nodes[0], "cannot modify constant value '" + ident + "'...");
throw_runtime_error(ast->nodes[0],
"cannot modify constant value '" + ident + "'...");
} else if (!scope->has_variable(ident)) {
throw_runtime_error(ast->nodes[0], "undefined variable '" + ident + "'...");
throw_runtime_error(ast->nodes[0],
"undefined variable '" + ident + "'...");
}
}
static void call(const shared_ptr<AstPL0> ast, shared_ptr<SymbolScope> scope) {
static void call(const shared_ptr<AstPL0> ast,
shared_ptr<SymbolScope> scope) {
// call <- 'CALL' __ ident
const auto& ident = ast->nodes[0]->token;
if (!scope->has_procedure(ident)) {
throw_runtime_error(ast->nodes[0], "undefined procedure '" + ident + "'...");
throw_runtime_error(ast->nodes[0],
"undefined procedure '" + ident + "'...");
}
}
static void ident(const shared_ptr<AstPL0> ast, shared_ptr<SymbolScope> scope) {
static void ident(const shared_ptr<AstPL0> ast,
shared_ptr<SymbolScope> scope) {
const auto& ident = ast->token;
if (!scope->has_symbol(ident)) {
throw_runtime_error(ast, "undefined variable '" + ident + "'...");
@ -201,8 +226,7 @@ private:
/*
* Environment
*/
struct Environment
{
struct Environment {
Environment(shared_ptr<SymbolScope> scope, shared_ptr<Environment> outer)
: scope(scope), outer(outer) {}
@ -229,7 +253,8 @@ struct Environment
shared_ptr<AstPL0> get_procedure(const string& ident) const {
auto it = scope->procedures.find(ident);
return it != scope->procedures.end() ? it->second : outer->get_procedure(ident);
return it != scope->procedures.end() ? it->second
: outer->get_procedure(ident);
}
private:
@ -241,61 +266,89 @@ private:
/*
* Interpreter
*/
struct Interpreter
{
static void exec(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env = nullptr) {
struct Interpreter {
static void exec(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env = nullptr) {
switch (ast->tag) {
case "block"_: exec_block(ast, env); break;
case "statement"_: exec_statement(ast, env); break;
case "assignment"_: exec_assignment(ast, env); break;
case "call"_: exec_call(ast, env); break;
case "statements"_: exec_statements(ast, env); break;
case "if"_: exec_if(ast, env); break;
case "while"_: exec_while(ast, env); break;
case "out"_: exec_out(ast, env); break;
case "in"_: exec_in(ast, env); break;
default: exec(ast->nodes[0], env); break;
case "block"_:
exec_block(ast, env);
break;
case "statement"_:
exec_statement(ast, env);
break;
case "assignment"_:
exec_assignment(ast, env);
break;
case "call"_:
exec_call(ast, env);
break;
case "statements"_:
exec_statements(ast, env);
break;
case "if"_:
exec_if(ast, env);
break;
case "while"_:
exec_while(ast, env);
break;
case "out"_:
exec_out(ast, env);
break;
case "in"_:
exec_in(ast, env);
break;
default:
exec(ast->nodes[0], env);
break;
}
}
private:
static void exec_block(const shared_ptr<AstPL0> ast, shared_ptr<Environment> outer) {
static void exec_block(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> outer) {
// block <- const var procedure statement
exec(ast->nodes[3], make_shared<Environment>(ast->scope, outer));
}
static void exec_statement(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
// statement <- (assignment / call / statements / if / while / out / in)?
static void exec_statement(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// statement <- (assignment / call / statements / if / while / out /
// in)?
if (!ast->nodes.empty()) {
exec(ast->nodes[0], env);
}
}
static void exec_assignment(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static void exec_assignment(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// assignment <- ident ':=' _ expression
env->set_variable(ast->nodes[0]->token, eval(ast->nodes[1], env));
}
static void exec_call(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static void exec_call(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// call <- 'CALL' __ ident
exec_block(env->get_procedure(ast->nodes[0]->token), env);
}
static void exec_statements(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static void exec_statements(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// statements <- 'BEGIN' __ statement (';' _ statement )* 'END' __
for (auto stmt : ast->nodes) {
exec(stmt, env);
}
}
static void exec_if(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static void exec_if(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// if <- 'IF' __ condition 'THEN' __ statement
if (eval_condition(ast->nodes[0], env)) {
exec(ast->nodes[1], env);
}
}
static void exec_while(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static void exec_while(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// while <- 'WHILE' __ condition 'DO' __ statement
auto cond = ast->nodes[0];
auto stmt = ast->nodes[1];
@ -304,61 +357,82 @@ private:
}
}
static void exec_out(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static void exec_out(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// out <- ('out' __ / 'write' __ / '!' _) expression
cout << eval(ast->nodes[0], env) << endl;
}
static void exec_in(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static void exec_in(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// in <- ('in' __ / 'read' __ / '?' _) ident
int val;
cin >> val;
env->set_variable(ast->nodes[0]->token, val);
}
static bool eval_condition(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static bool eval_condition(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// condition <- odd / compare
const auto& node = ast->nodes[0];
switch (node->tag) {
case "odd"_: return eval_odd(node, env);
case "compare"_: return eval_compare(node, env);
default: throw logic_error("invalid AstPL0 type");
case "odd"_:
return eval_odd(node, env);
case "compare"_:
return eval_compare(node, env);
default:
throw logic_error("invalid AstPL0 type");
}
}
static bool eval_odd(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static bool eval_odd(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// odd <- 'ODD' __ expression
return eval_expression(ast->nodes[0], env) != 0;
}
static bool eval_compare(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static bool eval_compare(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// compare <- expression compare_op expression
const auto& nodes = ast->nodes;
auto lval = eval_expression(nodes[0], env);
auto op = peg::str2tag(nodes[1]->token.c_str());
auto rval = eval_expression(nodes[2], env);
switch (op) {
case "="_: return lval == rval;
case "#"_: return lval != rval;
case "<="_: return lval <= rval;
case "<"_: return lval < rval;
case ">="_: return lval >= rval;
case ">"_: return lval > rval;
default: throw logic_error("invalid operator");
case "="_:
return lval == rval;
case "#"_:
return lval != rval;
case "<="_:
return lval <= rval;
case "<"_:
return lval < rval;
case ">="_:
return lval >= rval;
case ">"_:
return lval > rval;
default:
throw logic_error("invalid operator");
}
}
static int eval(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
switch (ast->tag) {
case "expression"_: return eval_expression(ast, env);
case "term"_: return eval_term(ast, env);
case "ident"_: return eval_ident(ast, env);
case "number"_: return eval_number(ast, env);
default: return eval(ast->nodes[0], env);
case "expression"_:
return eval_expression(ast, env);
case "term"_:
return eval_term(ast, env);
case "ident"_:
return eval_ident(ast, env);
case "number"_:
return eval_number(ast, env);
default:
return eval(ast->nodes[0], env);
}
}
static int eval_expression(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static int eval_expression(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// expression <- sign term (term_op term)*
const auto& nodes = ast->nodes;
auto sign = nodes[0]->token;
@ -368,14 +442,19 @@ private:
auto ope = nodes[i + 0]->token[0];
auto rval = eval(nodes[i + 1], env);
switch (ope) {
case '+': val = val + rval; break;
case '-': val = val - rval; break;
case '+':
val = val + rval;
break;
case '-':
val = val - rval;
break;
}
}
return val;
}
static int eval_term(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static int eval_term(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
// term <- factor (factor_op factor)*
const auto& nodes = ast->nodes;
auto val = eval(nodes[0], env);
@ -397,11 +476,13 @@ private:
return val;
}
static int eval_ident(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static int eval_ident(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
return env->get_value(ast, ast->token);
}
static int eval_number(const shared_ptr<AstPL0> ast, shared_ptr<Environment> env) {
static int eval_number(const shared_ptr<AstPL0> ast,
shared_ptr<Environment> env) {
return stol(ast->token);
}
};
@ -409,8 +490,7 @@ private:
/*
* Main
*/
int main(int argc, const char** argv)
{
int main(int argc, const char** argv) {
if (argc < 2) {
cout << "usage: pl0 PATH [--ast]" << endl;
return 1;
@ -427,7 +507,8 @@ int main(int argc, const char** argv)
}
source.resize(static_cast<unsigned int>(ifs.seekg(0, ios::end).tellg()));
if (!source.empty()) {
ifs.seekg(0, ios::beg).read(&source[0], static_cast<streamsize>(source.size()));
ifs.seekg(0, ios::beg)
.read(&source[0], static_cast<streamsize>(source.size()));
}
// Setup a PEG parser
@ -455,4 +536,4 @@ int main(int argc, const char** argv)
return -1;
}
// vim: et ts=4 sw=4 cin cino={1s ff=unix
// vim: et ts=2 sw=2 cin cino={1s ff=unix